rastack 0.0.16 → 0.0.20

package/provider/warehouse.ts

@@ -1,167 +1,167 @@
-/**
- * Persistence for the in-browser warehouse blob produced by
- * `RadApi.exportWarehouse()`. A single blob (the whole Iceberg warehouse)
- * lives in a one-row IndexedDB store so `local` mode survives reloads; `s3`
- * mode swaps this for a {@link WarehouseSource} over object storage.
- */
-
-const STORE = "warehouse";
-const KEY = "blob";
-
-function openDb(name: string): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(name, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(STORE)) {
-        db.createObjectStore(STORE);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-
-export class WarehousePersistence {
-  private db: Promise<IDBDatabase> | null;
-
-  constructor(private databaseName: string) {
-    this.db =
-      typeof indexedDB !== "undefined" ? openDb(databaseName) : null;
-  }
-
-  get enabled(): boolean {
-    return this.db !== null;
-  }
-
-  async load(): Promise<Uint8Array | null> {
-    if (!this.db) return null;
-    const db = await this.db;
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(STORE, "readonly");
-      const request = tx.objectStore(STORE).get(KEY);
-      request.onsuccess = () => {
-        const value = request.result;
-        resolve(value ? new Uint8Array(value) : null);
-      };
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async save(blob: Uint8Array): Promise<void> {
-    if (!this.db) return;
-    const db = await this.db;
-    await new Promise<void>((resolve, reject) => {
-      const tx = db.transaction(STORE, "readwrite");
-      // Store a copy of the bytes; the ArrayBuffer is structured-clonable.
-      tx.objectStore(STORE).put(blob.slice().buffer, KEY);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-}
-
-/** Fetch bytes, or `null` on 404. */
-async function fetchBytes(url: string): Promise<Uint8Array | null> {
-  const response = await fetch(url);
-  if (!response.ok) {
-    if (response.status === 404) return null;
-    throw new Error(`failed to fetch ${url} (${response.status})`);
-  }
-  return new Uint8Array(await response.arrayBuffer());
-}
-
-/** The engine surface the seeder needs. */
-interface Seedable {
-  seedFile(key: string, bytes: Uint8Array): Promise<void>;
-}
-
-/**
- * Seed the engine by walking a committed Iceberg warehouse over HTTP — the
- * database is a *list of Iceberg files*, not a bundled blob. For each resource
- * it follows the Iceberg pointers: `version-hint.text` → the current snapshot
- * metadata → that snapshot's `.parquet` data files, handing each raw file to
- * `engine.seedFile`. This is the same walk the server does over object storage;
- * no directory listing is needed because Iceberg metadata is self-describing.
- *
- * Returns the number of tables seeded.
- */
-export async function seedFromIceberg(
-  engine: Seedable,
-  baseUrl: string,
-  resources: { app: string; model: string }[],
-): Promise<number> {
-  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  const decoder = new TextDecoder();
-  let tables = 0;
-
-  for (const { app, model } of resources) {
-    const prefix = `${app}.db/${model}`;
-    const hintKey = `${prefix}/metadata/version-hint.text`;
-    const hint = await fetchBytes(base + hintKey);
-    if (!hint) continue; // table has no committed data yet
-
-    await engine.seedFile(hintKey, hint);
-    const version = decoder.decode(hint).trim();
-
-    const metaKey = `${prefix}/metadata/v${version}.metadata.json`;
-    const metaBytes = await fetchBytes(base + metaKey);
-    if (!metaBytes) continue;
-    await engine.seedFile(metaKey, metaBytes);
-
-    const meta = JSON.parse(decoder.decode(metaBytes)) as { data_files?: string[] };
-    for (const rel of meta.data_files || []) {
-      const key = `${prefix}/${rel}`;
-      const bytes = await fetchBytes(base + key);
-      if (bytes) await engine.seedFile(key, bytes);
-    }
-    tables++;
-  }
-  return tables;
-}
-
-/** Read the `{app, model}` list out of a compiled manifest (object or string). */
-export function manifestResources(
-  manifest: object | string,
-): { app: string; model: string }[] {
-  const parsed = typeof manifest === "string" ? JSON.parse(manifest) : manifest;
-  return (parsed?.resources || []).map((r: any) => ({
-    app: r.app,
-    model: r.model,
-  }));
-}
-
-/** Trigger a browser download of the warehouse blob so it can be committed. */
-export function downloadBlob(blob: Uint8Array, filename: string): void {
-  const url = URL.createObjectURL(new Blob([blob.slice().buffer]));
-  const a = document.createElement("a");
-  a.href = url;
-  a.download = filename;
-  document.body.appendChild(a);
-  a.click();
-  a.remove();
-  URL.revokeObjectURL(url);
-}
-
-/** A trailing debounce that always fires a final call. */
-export function debounce<T extends (...args: any[]) => void>(
-  fn: T,
-  ms: number,
-): T & { flush: () => void } {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const wrapped = ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as T & { flush: () => void };
-  wrapped.flush = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-      fn();
-    }
-  };
-  return wrapped;
-}
+/**
+ * Persistence for the in-browser warehouse blob produced by
+ * `RadApi.exportWarehouse()`. A single blob (the whole Iceberg warehouse)
+ * lives in a one-row IndexedDB store so `local` mode survives reloads; `s3`
+ * mode swaps this for a {@link WarehouseSource} over object storage.
+ */
+
+const STORE = "warehouse";
+const KEY = "blob";
+
+function openDb(name: string): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE)) {
+        db.createObjectStore(STORE);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+export class WarehousePersistence {
+  private db: Promise<IDBDatabase> | null;
+
+  constructor(private databaseName: string) {
+    this.db =
+      typeof indexedDB !== "undefined" ? openDb(databaseName) : null;
+  }
+
+  get enabled(): boolean {
+    return this.db !== null;
+  }
+
+  async load(): Promise<Uint8Array | null> {
+    if (!this.db) return null;
+    const db = await this.db;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE, "readonly");
+      const request = tx.objectStore(STORE).get(KEY);
+      request.onsuccess = () => {
+        const value = request.result;
+        resolve(value ? new Uint8Array(value) : null);
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async save(blob: Uint8Array): Promise<void> {
+    if (!this.db) return;
+    const db = await this.db;
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction(STORE, "readwrite");
+      // Store a copy of the bytes; the ArrayBuffer is structured-clonable.
+      tx.objectStore(STORE).put(blob.slice().buffer, KEY);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+}
+
+/** Fetch bytes, or `null` on 404. */
+async function fetchBytes(url: string): Promise<Uint8Array | null> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    if (response.status === 404) return null;
+    throw new Error(`failed to fetch ${url} (${response.status})`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+/** The engine surface the seeder needs. */
+interface Seedable {
+  seedFile(key: string, bytes: Uint8Array): Promise<void>;
+}
+
+/**
+ * Seed the engine by walking a committed Iceberg warehouse over HTTP — the
+ * database is a *list of Iceberg files*, not a bundled blob. For each resource
+ * it follows the Iceberg pointers: `version-hint.text` → the current snapshot
+ * metadata → that snapshot's `.parquet` data files, handing each raw file to
+ * `engine.seedFile`. This is the same walk the server does over object storage;
+ * no directory listing is needed because Iceberg metadata is self-describing.
+ *
+ * Returns the number of tables seeded.
+ */
+export async function seedFromIceberg(
+  engine: Seedable,
+  baseUrl: string,
+  resources: { app: string; model: string }[],
+): Promise<number> {
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const decoder = new TextDecoder();
+  let tables = 0;
+
+  for (const { app, model } of resources) {
+    const prefix = `${app}.db/${model}`;
+    const hintKey = `${prefix}/metadata/version-hint.text`;
+    const hint = await fetchBytes(base + hintKey);
+    if (!hint) continue; // table has no committed data yet
+
+    await engine.seedFile(hintKey, hint);
+    const version = decoder.decode(hint).trim();
+
+    const metaKey = `${prefix}/metadata/v${version}.metadata.json`;
+    const metaBytes = await fetchBytes(base + metaKey);
+    if (!metaBytes) continue;
+    await engine.seedFile(metaKey, metaBytes);
+
+    const meta = JSON.parse(decoder.decode(metaBytes)) as { data_files?: string[] };
+    for (const rel of meta.data_files || []) {
+      const key = `${prefix}/${rel}`;
+      const bytes = await fetchBytes(base + key);
+      if (bytes) await engine.seedFile(key, bytes);
+    }
+    tables++;
+  }
+  return tables;
+}
+
+/** Read the `{app, model}` list out of a compiled manifest (object or string). */
+export function manifestResources(
+  manifest: object | string,
+): { app: string; model: string }[] {
+  const parsed = typeof manifest === "string" ? JSON.parse(manifest) : manifest;
+  return (parsed?.resources || []).map((r: any) => ({
+    app: r.app,
+    model: r.model,
+  }));
+}
+
+/** Trigger a browser download of the warehouse blob so it can be committed. */
+export function downloadBlob(blob: Uint8Array, filename: string): void {
+  const url = URL.createObjectURL(new Blob([blob.slice().buffer]));
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+}
+
+/** A trailing debounce that always fires a final call. */
+export function debounce<T extends (...args: any[]) => void>(
+  fn: T,
+  ms: number,
+): T & { flush: () => void } {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const wrapped = ((...args: any[]) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      fn(...args);
+    }, ms);
+  }) as T & { flush: () => void };
+  wrapped.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+      fn();
+    }
+  };
+  return wrapped;
+}

package/provider/wasm.ts

@@ -1,124 +1,124 @@
-import { AxiosAdapter, AxiosError, AxiosResponse } from "axios";
-import { RadEngine, RadEngineLoader, RadWasmModule } from "./types";
-
-/**
- * Default WASM loader: import the bundle `rad wasm` generates
- * (`rastack/wasm/rad_wasm.js`) and run its init. The indirection through
- * `new Function` keeps a genuine dynamic `import()` at runtime even when the
- * package is transpiled to CommonJS, so the consumer's bundler resolves and
- * code-splits the `.wasm`.
- */
-const runtimeImport: (specifier: string) => Promise<any> =
-  // eslint-disable-next-line no-new-func
-  new Function("s", "return import(s)") as any;
-
-export const defaultEngineLoader: RadEngineLoader = async () => {
-  const mod: RadWasmModule = await runtimeImport("rastack/wasm/rad_wasm.js");
-  const init = mod.default || mod.init;
-  if (typeof init === "function") {
-    await init();
-  }
-  return mod;
-};
-
-/**
- * Instantiate the engine from a loaded module and the compiled schema. The
- * manifest/openapi are passed as JSON strings — the same `schema.rad.json` /
- * `openapi.json` the Rust server reads.
- */
-export function createEngine(
-  mod: RadWasmModule,
-  manifest: object | string,
-  openapi?: object | string,
-): RadEngine {
-  const manifestJson =
-    typeof manifest === "string" ? manifest : JSON.stringify(manifest);
-  const openapiJson =
-    openapi === undefined
-      ? undefined
-      : typeof openapi === "string"
-        ? openapi
-        : JSON.stringify(openapi);
-  return new mod.RadApi(manifestJson, openapiJson);
-}
-
-const MUTATING = new Set(["POST", "PUT", "PATCH", "DELETE"]);
-
-/**
- * An axios adapter that dispatches requests into the in-browser WASM engine
- * instead of over the network. Translates an axios request into the engine's
- * `handle(method, path, query, body)` and maps the `{ status, body }` result
- * back to an `AxiosResponse` — rejecting on non-2xx exactly as HTTP axios does,
- * so `react-query` error handling is unchanged.
- *
- * `onWrite` fires after each successful mutation so the provider can debounce a
- * persist of the warehouse.
- */
-export function createWasmAdapter(
-  engine: RadEngine,
-  onWrite?: () => void,
-): AxiosAdapter {
-  return async (config: any): Promise<AxiosResponse> => {
-    const method = String(config.method || "get").toUpperCase();
-
-    const rawUrl = config.url || "";
-    const [rawPath, rawQuery] = rawUrl.split("?");
-    // Strip any origin so only the `/api/...` path reaches the engine.
-    const path = rawPath.replace(/^https?:\/\/[^/]+/i, "") || "/";
-
-    const query: Record<string, string> = {};
-    if (rawQuery) {
-      new URLSearchParams(rawQuery).forEach((value, key) => {
-        query[key] = value;
-      });
-    }
-    if (config.params && typeof config.params === "object") {
-      for (const [key, value] of Object.entries(config.params)) {
-        if (value !== undefined && value !== null) query[key] = String(value);
-      }
-    }
-
-    // axios has already run transformRequest, so JSON bodies arrive as strings.
-    let body: unknown;
-    if (typeof config.data === "string" && config.data.length > 0) {
-      try {
-        body = JSON.parse(config.data);
-      } catch {
-        body = config.data;
-      }
-    } else if (config.data && typeof config.data === "object") {
-      body = config.data;
-    }
-
-    const result = await engine.handle(
-      method,
-      path,
-      Object.keys(query).length ? query : undefined,
-      body,
-    );
-
-    const response: AxiosResponse = {
-      data: result.body,
-      status: result.status,
-      statusText: String(result.status),
-      headers: {},
-      config,
-      request: null,
-    };
-
-    const validate =
-      config.validateStatus || ((s: number) => s >= 200 && s < 300);
-    if (!validate(result.status)) {
-      throw new AxiosError(
-        `Request failed with status code ${result.status}`,
-        result.status >= 500 ? "ERR_BAD_RESPONSE" : "ERR_BAD_REQUEST",
-        config,
-        null,
-        response,
-      );
-    }
-
-    if (MUTATING.has(method) && onWrite) onWrite();
-    return response;
-  };
-}
+import { AxiosAdapter, AxiosError, AxiosResponse } from "axios";
+import { RadEngine, RadEngineLoader, RadWasmModule } from "./types";
+
+/**
+ * Default WASM loader: import the bundle `rad wasm` generates
+ * (`rastack/wasm/rad_wasm.js`) and run its init. The indirection through
+ * `new Function` keeps a genuine dynamic `import()` at runtime even when the
+ * package is transpiled to CommonJS, so the consumer's bundler resolves and
+ * code-splits the `.wasm`.
+ */
+const runtimeImport: (specifier: string) => Promise<any> =
+  // eslint-disable-next-line no-new-func
+  new Function("s", "return import(s)") as any;
+
+export const defaultEngineLoader: RadEngineLoader = async () => {
+  const mod: RadWasmModule = await runtimeImport("rastack/wasm/rad_wasm.js");
+  const init = mod.default || mod.init;
+  if (typeof init === "function") {
+    await init();
+  }
+  return mod;
+};
+
+/**
+ * Instantiate the engine from a loaded module and the compiled schema. The
+ * manifest/openapi are passed as JSON strings — the same `schema.rad.json` /
+ * `openapi.json` the Rust server reads.
+ */
+export function createEngine(
+  mod: RadWasmModule,
+  manifest: object | string,
+  openapi?: object | string,
+): RadEngine {
+  const manifestJson =
+    typeof manifest === "string" ? manifest : JSON.stringify(manifest);
+  const openapiJson =
+    openapi === undefined
+      ? undefined
+      : typeof openapi === "string"
+        ? openapi
+        : JSON.stringify(openapi);
+  return new mod.RadApi(manifestJson, openapiJson);
+}
+
+const MUTATING = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+
+/**
+ * An axios adapter that dispatches requests into the in-browser WASM engine
+ * instead of over the network. Translates an axios request into the engine's
+ * `handle(method, path, query, body)` and maps the `{ status, body }` result
+ * back to an `AxiosResponse` — rejecting on non-2xx exactly as HTTP axios does,
+ * so `react-query` error handling is unchanged.
+ *
+ * `onWrite` fires after each successful mutation so the provider can debounce a
+ * persist of the warehouse.
+ */
+export function createWasmAdapter(
+  engine: RadEngine,
+  onWrite?: () => void,
+): AxiosAdapter {
+  return async (config: any): Promise<AxiosResponse> => {
+    const method = String(config.method || "get").toUpperCase();
+
+    const rawUrl = config.url || "";
+    const [rawPath, rawQuery] = rawUrl.split("?");
+    // Strip any origin so only the `/api/...` path reaches the engine.
+    const path = rawPath.replace(/^https?:\/\/[^/]+/i, "") || "/";
+
+    const query: Record<string, string> = {};
+    if (rawQuery) {
+      new URLSearchParams(rawQuery).forEach((value, key) => {
+        query[key] = value;
+      });
+    }
+    if (config.params && typeof config.params === "object") {
+      for (const [key, value] of Object.entries(config.params)) {
+        if (value !== undefined && value !== null) query[key] = String(value);
+      }
+    }
+
+    // axios has already run transformRequest, so JSON bodies arrive as strings.
+    let body: unknown;
+    if (typeof config.data === "string" && config.data.length > 0) {
+      try {
+        body = JSON.parse(config.data);
+      } catch {
+        body = config.data;
+      }
+    } else if (config.data && typeof config.data === "object") {
+      body = config.data;
+    }
+
+    const result = await engine.handle(
+      method,
+      path,
+      Object.keys(query).length ? query : undefined,
+      body,
+    );
+
+    const response: AxiosResponse = {
+      data: result.body,
+      status: result.status,
+      statusText: String(result.status),
+      headers: {},
+      config,
+      request: null,
+    };
+
+    const validate =
+      config.validateStatus || ((s: number) => s >= 200 && s < 300);
+    if (!validate(result.status)) {
+      throw new AxiosError(
+        `Request failed with status code ${result.status}`,
+        result.status >= 500 ? "ERR_BAD_RESPONSE" : "ERR_BAD_REQUEST",
+        config,
+        null,
+        response,
+      );
+    }
+
+    if (MUTATING.has(method) && onWrite) onWrite();
+    return response;
+  };
+}

package/runtime.ts

@@ -1,3 +1,3 @@
-export * from "./hooks";
-export * from "./types";
-export * from "./provider";
+export * from "./hooks";
+export * from "./types";
+export * from "./provider";

package/src/.prettierrc

@@ -1,7 +1,7 @@
-{
-  "tabWidth": 2,
-  "semi": true,
-  "bracketSpacing": true,
-  "arrowParens": "always",
-  "printWidth": 80
-}
+{
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "printWidth": 80
+}