feat: add INLINE + ARROW_STREAM format support for analytics plugin

docs/docs/api/appkit/Class.ExecutionError.md

@@ -22,6 +22,7 @@ throw new ExecutionError("Statement was canceled");
 new ExecutionError(message: string, options?: {
   cause?: Error;
   context?: Record<string, unknown>;
+  errorCode?: string;
 }): ExecutionError;
 ```
 
@@ -30,15 +31,16 @@ new ExecutionError(message: string, options?: {
 | Parameter | Type |
 | ------ | ------ |
 | `message` | `string` |
-| `options?` | \{ `cause?`: `Error`; `context?`: `Record`\<`string`, `unknown`\>; \} |
+| `options?` | \{ `cause?`: `Error`; `context?`: `Record`\<`string`, `unknown`\>; `errorCode?`: `string`; \} |
 | `options.cause?` | `Error` |
 | `options.context?` | `Record`\<`string`, `unknown`\> |
+| `options.errorCode?` | `string` |
 
 #### Returns
 
 `ExecutionError`
 
-#### Inherited from
+#### Overrides
 
 [`AppKitError`](Class.AppKitError.md).[`constructor`](Class.AppKitError.md#constructor)
 
@@ -86,6 +88,19 @@ Additional context for the error
 
 ***
 
+### errorCode?
+
+```ts
+readonly optional errorCode: string;
+```
+
+Structured error code from the upstream source (typically the warehouse's
+`error_code` for statement-level failures, or the SDK's `ApiError.errorCode`
+for HTTP failures). Preserved through wrapping so callers can branch on a
+stable identifier without substring-matching the message.
+
+***
+
 ### isRetryable
 
 ```ts
@@ -202,16 +217,17 @@ Create an execution error for closed/expired results
 ### statementFailed()
 
 ```ts
-static statementFailed(errorMessage?: string): ExecutionError;
+static statementFailed(errorMessage?: string, errorCode?: string): ExecutionError;
 ```
 
-Create an execution error for statement failure
+Create an execution error for statement failure.
 
 #### Parameters
 
-| Parameter | Type |
-| ------ | ------ |
-| `errorMessage?` | `string` |
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `errorMessage?` | `string` | Human-readable error from the warehouse / SDK. |
+| `errorCode?` | `string` | Structured code (e.g. "INVALID_PARAMETER_VALUE") to preserve through wrapping. Optional. |
 
 #### Returns
 

packages/appkit-ui/src/js/sse/connect-sse.ts

@@ -18,7 +18,10 @@ export async function connectSSE<Payload = unknown>(
     lastEventId: initialLastEventId = null,
     retryDelay = 2000,
     maxRetries = 3,
-    maxBufferSize = 1024 * 1024, // 1MB
+    // 8 MiB — sized to receive inline Arrow IPC attachments from
+    // ARROW_STREAM analytics responses; matches the server's stream
+    // `maxEventSize`. Most events are well under 1 MiB in practice.
+    maxBufferSize = 8 * 1024 * 1024,
     timeout = 300000, // 5 minutes
     onError,
   } = options;

packages/appkit-ui/src/react/charts/__tests__/types.test.ts

@@ -93,7 +93,7 @@ describe("isQueryProps", () => {
     const props = {
       queryKey: "test_query",
       parameters: { limit: 100 },
-      format: "json" as const,
+      format: "json_array" as const,
     };
 
     expect(isQueryProps(props as any)).toBe(true);

packages/appkit-ui/src/react/charts/types.ts

@@ -5,7 +5,7 @@ import type { Table } from "apache-arrow";
 // ============================================================================
 
 /** Supported data formats for analytics queries */
-export type DataFormat = "json" | "arrow" | "auto";
+export type DataFormat = "json_array" | "arrow_stream" | "auto";
 
 /** Chart orientation */
 export type Orientation = "vertical" | "horizontal";
@@ -77,8 +77,8 @@ export interface QueryProps extends ChartBaseProps {
   parameters?: Record<string, unknown>;
   /**
    * Data format to use
-   * - "json": Use JSON format (smaller payloads, simpler)
-   * - "arrow": Use Arrow format (faster for large datasets)
+   * - "json_array": Use JSON format (smaller payloads, simpler)
+   * - "arrow_stream": Use Arrow format (faster for large datasets)
    * - "auto": Automatically select based on expected data size
    * @default "auto"
    */

packages/appkit-ui/src/react/hooks/__tests__/use-analytics-query.test.ts

@@ -0,0 +1,143 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+// Capture the onMessage handler so tests can drive SSE messages directly.
+let lastConnectArgs: any = null;
+const mockProcessArrowBuffer = vi.fn();
+const mockFetchArrow = vi.fn();
+
+vi.mock("@/js", () => ({
+  connectSSE: vi.fn((args: any) => {
+    lastConnectArgs = args;
+    return () => {};
+  }),
+  ArrowClient: {
+    fetchArrow: (...args: unknown[]) => mockFetchArrow(...args),
+    processArrowBuffer: (...args: unknown[]) => mockProcessArrowBuffer(...args),
+  },
+}));
+
+// useQueryHMR is a no-op shim for tests; mock to avoid HMR side effects.
+vi.mock("../use-query-hmr", () => ({
+  useQueryHMR: vi.fn(),
+}));
+
+import { useAnalyticsQuery } from "../use-analytics-query";
+
+describe("useAnalyticsQuery", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    lastConnectArgs = null;
+  });
+
+  test("decodes arrow_inline base64 attachment via ArrowClient.processArrowBuffer", async () => {
+    const fakeTable = { numRows: 1, schema: { fields: [] } };
+    mockProcessArrowBuffer.mockResolvedValueOnce(fakeTable);
+
+    // 'AQID' decodes to bytes [1, 2, 3].
+    const base64 = "AQID";
+
+    const { result } = renderHook(() =>
+      useAnalyticsQuery("q", null, { format: "ARROW_STREAM" }),
+    );
+
+    // Drive the SSE onMessage handler with an arrow_inline payload.
+    await lastConnectArgs.onMessage({
+      data: JSON.stringify({ type: "arrow_inline", attachment: base64 }),
+    });
+
+    await waitFor(() => {
+      expect(result.current.data).toBe(fakeTable);
+    });
+
+    expect(mockProcessArrowBuffer).toHaveBeenCalledTimes(1);
+    const passedBuffer = mockProcessArrowBuffer.mock.calls[0][0] as Uint8Array;
+    expect(passedBuffer).toBeInstanceOf(Uint8Array);
+    expect(Array.from(passedBuffer)).toEqual([1, 2, 3]);
+    // Inline path must NOT trigger a network fetch.
+    expect(mockFetchArrow).not.toHaveBeenCalled();
+  });
+
+  test("surfaces an error when arrow_inline decode fails", async () => {
+    mockProcessArrowBuffer.mockRejectedValueOnce(new Error("bad ipc"));
+
+    const { result } = renderHook(() =>
+      useAnalyticsQuery("q", null, { format: "ARROW_STREAM" }),
+    );
+
+    await lastConnectArgs.onMessage({
+      data: JSON.stringify({ type: "arrow_inline", attachment: "AQID" }),
+    });
+
+    await waitFor(() => {
+      expect(result.current.error).toBe(
+        "Unable to load data, please try again",
+      );
+    });
+    expect(result.current.loading).toBe(false);
+  });
+
+  test("rejects arrow_inline with missing/empty/non-string attachment without crashing atob", async () => {
+    const cases: Array<unknown> = [undefined, null, "", 123, { foo: "bar" }];
+
+    for (const attachment of cases) {
+      mockProcessArrowBuffer.mockClear();
+      const { result, unmount } = renderHook(() =>
+        useAnalyticsQuery("q", null, { format: "ARROW_STREAM" }),
+      );
+
+      await lastConnectArgs.onMessage({
+        data: JSON.stringify({ type: "arrow_inline", attachment }),
+      });
+
+      await waitFor(() => {
+        expect(result.current.error).toBe(
+          "Unable to load data, please try again",
+        );
+      });
+      // Critically: must NOT call processArrowBuffer (or atob) on the bad input.
+      expect(mockProcessArrowBuffer).not.toHaveBeenCalled();
+
+      unmount();
+    }
+  });
+
+  test("rejects oversized arrow_inline attachment without allocating a huge buffer", async () => {
+    // Base64 string that would decode to ~9 MiB (>8 MiB cap). The hook
+    // should reject before calling decodeBase64 / processArrowBuffer.
+    const oversized = "A".repeat(13 * 1024 * 1024);
+
+    const { result } = renderHook(() =>
+      useAnalyticsQuery("q", null, { format: "ARROW_STREAM" }),
+    );
+
+    await lastConnectArgs.onMessage({
+      data: JSON.stringify({ type: "arrow_inline", attachment: oversized }),
+    });
+
+    await waitFor(() => {
+      expect(result.current.error).toBe(
+        "Unable to load data, please try again",
+      );
+    });
+    expect(mockProcessArrowBuffer).not.toHaveBeenCalled();
+  });
+
+  test("still handles type:result rows for JSON_ARRAY", async () => {
+    const { result } = renderHook(() =>
+      useAnalyticsQuery("q", null, { format: "JSON_ARRAY" }),
+    );
+
+    await lastConnectArgs.onMessage({
+      data: JSON.stringify({
+        type: "result",
+        data: [{ id: 1 }, { id: 2 }],
+      }),
+    });
+
+    await waitFor(() => {
+      expect(result.current.data).toEqual([{ id: 1 }, { id: 2 }]);
+    });
+    expect(mockProcessArrowBuffer).not.toHaveBeenCalled();
+  });
+});