rastack 0.0.57 → 0.0.59

package/test/validate.spec.ts

@@ -1,319 +0,0 @@
-/**
- * The constraint state machine (`rastack/validate`): compilation from both
- * adapters (manifest field, write JSON Schema property), gate-by-gate
- * execution, dataset-level `unique`/`resolved` gates, record machines, and
- * the form-hook integration (`getFieldMachine`).
- */
-
-import {
-  compileFieldMachine,
-  compileRecordMachine,
-  createDatasetContext,
-  describeMachine,
-  runFieldMachine,
-  runRecordMachine,
-  specFromManifestField,
-  specFromSchemaProperty,
-  specsFromResource,
-  type FieldSpec,
-} from "../src/validate";
-import { getFieldMachine } from "../hooks/form/structure";
-import type { FieldModel } from "../src/compile/model";
-
-// The Airport.code field, as `rastack compile` writes it to the manifest.
-const CODE_FIELD: FieldModel = {
-  name: "code",
-  type: "string",
-  maxLength: 3,
-  unique: true,
-};
-
-describe("constraint state machine — compilation", () => {
-  it("builds one gate per constraint, in canonical order", () => {
-    const machine = compileFieldMachine(specFromManifestField(CODE_FIELD));
-    expect(machine.states).toEqual([
-      "pristine",
-      "present",
-      "typed",
-      "bounded",
-      "unique",
-      "valid",
-    ]);
-  });
-
-  it("emits no gate for an absent constraint", () => {
-    const machine = compileFieldMachine(
-      specFromManifestField({ name: "note", type: "string", null: true }),
-    );
-    expect(machine.states).toEqual(["pristine", "present", "typed", "valid"]);
-  });
-
-  it("describes the constraint chain for UI hints", () => {
-    const machine = compileFieldMachine(specFromManifestField(CODE_FIELD));
-    expect(describeMachine(machine)).toEqual([
-      "required",
-      "string",
-      "maxLength ≤ 3",
-      "unique",
-    ]);
-  });
-});
-
-describe("constraint state machine — execution", () => {
-  const codeMachine = compileFieldMachine(specFromManifestField(CODE_FIELD));
-
-  it("accepts a conforming value, recording the full path", () => {
-    const run = runFieldMachine(codeMachine, "LHR");
-    expect(run.state).toBe("valid");
-    expect(run.value).toBe("LHR");
-    expect(run.path).toEqual([
-      "pristine",
-      "present",
-      "typed",
-      "bounded",
-      "unique",
-      "valid",
-    ]);
-  });
-
-  it("halts at `present` for a missing required value", () => {
-    const run = runFieldMachine(codeMachine, "");
-    expect(run.state).toBe("invalid");
-    expect(run.failed?.gate).toBe("present");
-    expect(run.path).toEqual(["pristine", "invalid"]);
-  });
-
-  it("halts at `bounded` when maxLength is exceeded", () => {
-    const run = runFieldMachine(codeMachine, "LHRX");
-    expect(run.state).toBe("invalid");
-    expect(run.failed).toMatchObject({
-      gate: "bounded",
-      constraint: "maxLength ≤ 3",
-    });
-    // The path shows exactly how far the value got.
-    expect(run.path).toEqual(["pristine", "present", "typed", "invalid"]);
-  });
-
-  it("short-circuits an empty optional field to valid with its default", () => {
-    const machine = compileFieldMachine(
-      specFromManifestField({
-        name: "status",
-        type: "string",
-        maxLength: 20,
-        default: "scheduled",
-      }),
-    );
-    const run = runFieldMachine(machine, "");
-    expect(run.state).toBe("valid");
-    expect(run.value).toBe("scheduled");
-    expect(run.path).toEqual(["pristine", "present", "valid"]);
-  });
-
-  it("coerces at the `typed` gate (int strings become ints)", () => {
-    const machine = compileFieldMachine(
-      specFromManifestField({ name: "owner_id", type: "int" }),
-    );
-    expect(runFieldMachine(machine, "12").value).toBe(12);
-    expect(runFieldMachine(machine, 12).value).toBe(12);
-
-    const bad = runFieldMachine(machine, "12.5");
-    expect(bad.state).toBe("invalid");
-    expect(bad.failed?.gate).toBe("typed");
-  });
-
-  it("coerces booleans and datetimes", () => {
-    const bool = compileFieldMachine(
-      specFromManifestField({ name: "active", type: "bool" }),
-    );
-    expect(runFieldMachine(bool, "yes").value).toBe(true);
-    expect(runFieldMachine(bool, "0").value).toBe(false);
-    expect(runFieldMachine(bool, "maybe").state).toBe("invalid");
-
-    const dt = compileFieldMachine(
-      specFromManifestField({ name: "departs_at", type: "datetime" }),
-    );
-    expect(runFieldMachine(dt, "2026-07-13T10:30:00Z").state).toBe("valid");
-    expect(runFieldMachine(dt, "not a date").state).toBe("invalid");
-  });
-
-  it("enforces enum membership at the `member` gate", () => {
-    const spec: FieldSpec = {
-      name: "status",
-      type: "string",
-      required: true,
-      nullable: false,
-      options: ["scheduled", "boarding", "departed"],
-    };
-    const machine = compileFieldMachine(spec);
-    expect(runFieldMachine(machine, "boarding").state).toBe("valid");
-    const bad = runFieldMachine(machine, "cancelled");
-    expect(bad.failed?.gate).toBe("member");
-  });
-
-  it("leaves the `unique` gate inert without a dataset context", () => {
-    expect(runFieldMachine(codeMachine, "LHR").state).toBe("valid");
-    expect(runFieldMachine(codeMachine, "LHR").state).toBe("valid");
-  });
-
-  it("rejects duplicates through a dataset context", () => {
-    const record = compileRecordMachine([specFromManifestField(CODE_FIELD)]);
-    const ctx = createDatasetContext(record);
-    expect(runRecordMachine(record, { code: "LHR" }, ctx).state).toBe("valid");
-    const dup = runRecordMachine(record, { code: "LHR" }, ctx);
-    expect(dup.state).toBe("invalid");
-    expect(dup.errors[0]).toMatchObject({ field: "code", gate: "unique" });
-  });
-
-  it("resolves foreign keys through the context, inert without one", () => {
-    const fk: FieldModel = {
-      name: "airport",
-      type: "fk",
-      relation: { app: "airports", model: "airport" },
-    };
-    const machine = compileFieldMachine(specFromManifestField(fk));
-    expect(machine.states).toContain("resolved");
-
-    // No resolver — the gate passes (FK existence is a dataset/server check).
-    expect(runFieldMachine(machine, "7").state).toBe("valid");
-
-    const record = compileRecordMachine([specFromManifestField(fk)]);
-    const ctx = createDatasetContext(record, {
-      relatedIds: { "airports.airport": new Set(["1", "2"]) },
-    });
-    expect(runRecordMachine(record, { airport: "2" }, ctx).state).toBe("valid");
-    const dangling = runRecordMachine(record, { airport: "7" }, ctx);
-    expect(dangling.errors[0]).toMatchObject({
-      field: "airport",
-      gate: "resolved",
-    });
-  });
-});
-
-describe("spec adapters", () => {
-  it("manifest: required iff not nullable, no default, not a primary key", () => {
-    expect(
-      specFromManifestField({ name: "code", type: "string" }).required,
-    ).toBe(true);
-    expect(
-      specFromManifestField({ name: "code", type: "string", null: true })
-        .required,
-    ).toBe(false);
-    expect(
-      specFromManifestField({ name: "code", type: "string", default: "x" })
-        .required,
-    ).toBe(false);
-    expect(
-      specFromManifestField({ name: "id", type: "int", primaryKey: true })
-        .required,
-    ).toBe(false);
-  });
-
-  it("manifest: primary keys are excluded from a resource's input specs", () => {
-    const specs = specsFromResource({
-      fields: [
-        { name: "id", type: "int", primaryKey: true },
-        { name: "code", type: "string", maxLength: 3 },
-      ],
-    });
-    expect(specs.map((s) => s.name)).toEqual(["code"]);
-  });
-
-  it("JSON Schema: recovers type, nullability, maxLength, enum and the FK relation", () => {
-    const schema = {
-      type: "object",
-      required: ["code", "airport"],
-      properties: {
-        code: { type: "string", maxLength: 3 },
-        seats: { type: ["integer", "null"] },
-        status: { type: "string", enum: ["scheduled", "departed"] },
-        contact: { type: "string", format: "email" },
-        airport: {
-          type: "integer",
-          "x-rastack-relation": { app: "airports", model: "airport" },
-        },
-      },
-    };
-
-    expect(specFromSchemaProperty(schema, "code")).toMatchObject({
-      type: "string",
-      required: true,
-      maxLength: 3,
-    });
-    expect(specFromSchemaProperty(schema, "seats")).toMatchObject({
-      type: "int",
-      required: false,
-      nullable: true,
-    });
-    expect(specFromSchemaProperty(schema, "status")?.options).toEqual([
-      "scheduled",
-      "departed",
-    ]);
-    expect(specFromSchemaProperty(schema, "contact")).toMatchObject({
-      type: "string",
-      format: "email",
-    });
-    expect(specFromSchemaProperty(schema, "airport")).toMatchObject({
-      type: "fk",
-      relation: { app: "airports", model: "airport" },
-    });
-    expect(specFromSchemaProperty(schema, "missing")).toBeUndefined();
-  });
-
-  it("both adapters compile machines that agree on a value", () => {
-    const fromManifest = compileFieldMachine(specFromManifestField(CODE_FIELD));
-    const fromSchema = compileFieldMachine(
-      specFromSchemaProperty(
-        {
-          type: "object",
-          required: ["code"],
-          properties: { code: { type: "string", maxLength: 3 } },
-        },
-        "code",
-      )!,
-    );
-
-    for (const value of ["LHR", "LHRX", "", 42]) {
-      const a = runFieldMachine(fromManifest, value);
-      const b = runFieldMachine(fromSchema, value);
-      expect(b.state).toBe(a.state);
-      expect(b.failed?.gate).toBe(a.failed?.gate);
-    }
-  });
-});
-
-describe("form hook integration — getFieldMachine", () => {
-  const writeSchema = {
-    type: "object",
-    required: ["code"],
-    properties: {
-      code: { type: "string", maxLength: 3 },
-      contact: { type: "string", format: "email", nullable: true },
-    },
-  };
-
-  it("compiles a machine straight from the write schema the form validates against", () => {
-    const machine = getFieldMachine(writeSchema, "code")!;
-    expect(machine.states).toEqual([
-      "pristine",
-      "present",
-      "typed",
-      "bounded",
-      "valid",
-    ]);
-    expect(runFieldMachine(machine, "LHRX").failed?.gate).toBe("bounded");
-  });
-
-  it("routes string formats through the `typed` gate", () => {
-    const machine = getFieldMachine(writeSchema, "contact")!;
-    expect(runFieldMachine(machine, "ops@example.com").state).toBe("valid");
-    const bad = runFieldMachine(machine, "not-an-email");
-    expect(bad.failed?.gate).toBe("typed");
-    // Optional: empty is fine.
-    expect(runFieldMachine(machine, "").state).toBe("valid");
-  });
-
-  it("returns undefined for a field the schema does not describe", () => {
-    expect(getFieldMachine(writeSchema, "nope")).toBeUndefined();
-    expect(getFieldMachine(undefined, "code")).toBeUndefined();
-  });
-});

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "lib": [
-      "ES2023"
-    ],
-    "types": [
-      "node",
-      "jest"
-    ],
-    "outDir": "dist",
-    "rootDir": "src",
-    "paths": {
-      "rastack/tokens": ["./tokens.ts"]
-    },
-    "declaration": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true
-  },
-  "include": [
-    "src",
-    "src/index.ts"
-  ]
-}

package/wasm/package.json

@@ -1,4 +0,0 @@
-{
-  "type": "module",
-  "sideEffects": false
-}

package/wasm/rastack_wasm.d.ts

@@ -1,100 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/**
- * The in-browser API engine. Cheap to clone (everything behind `Arc`), which
- * is what lets each async call own its state without borrowing across `await`.
- */
-export class RastackApi {
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Snapshot the entire warehouse to a blob for persistence (`data/` folder,
-     * IndexedDB, or an upload to S3).
-     */
-    exportWarehouse(): Promise<any>;
-    /**
-     * Handle one request. `query` is a `{ [k]: string }` object, `body` any
-     * JSON value (or `undefined`). Resolves to `{ status, body }`.
-     */
-    handle(method: string, path: string, query: any, body: any): Promise<any>;
-    /**
-     * Seed the warehouse from a blob previously produced by
-     * [`export_warehouse`](Self::export_warehouse) (the `data/` folder or an
-     * IndexedDB/OPFS snapshot).
-     */
-    importWarehouse(blob: Uint8Array): Promise<any>;
-    /**
-     * Build an engine from the compiled manifest (`schema.rastack.json`) and an
-     * optional OpenAPI document (`openapi.json`, served at `/api/schema/`).
-     */
-    constructor(manifest_json: string, openapi_json?: string | null);
-    /**
-     * Seed one Iceberg file (metadata or data file) at its warehouse key. The
-     * provider walks the committed `data/warehouse` Iceberg tree over HTTP and
-     * calls this for each file, so the browser reads the *actual* Iceberg files
-     * — no bundled blob.
-     */
-    seedFile(key: string, bytes: Uint8Array): Promise<any>;
-    /**
-     * Run subsequent requests as a signed-in identity (the Cognito `sub` and
-     * `cognito:groups` claims). Owner fields are stamped from — and row
-     * filters and tenant scoping keyed by — this subject, matching the server
-     * byte-for-byte. Pass no subject to fall back to the trusted local
-     * context.
-     */
-    setAuth(subject: string | null | undefined, groups: any): void;
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-    readonly memory: WebAssembly.Memory;
-    readonly __wbg_rastackapi_free: (a: number, b: number) => void;
-    readonly rastackapi_exportWarehouse: (a: number) => any;
-    readonly rastackapi_handle: (a: number, b: number, c: number, d: number, e: number, f: any, g: any) => any;
-    readonly rastackapi_importWarehouse: (a: number, b: number, c: number) => any;
-    readonly rastackapi_new: (a: number, b: number, c: number, d: number) => [number, number, number];
-    readonly rastackapi_seedFile: (a: number, b: number, c: number, d: number, e: number) => any;
-    readonly rastackapi_setAuth: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
-    readonly rust_zstd_wasm_shim_free: (a: number) => void;
-    readonly rust_zstd_wasm_shim_malloc: (a: number) => number;
-    readonly rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
-    readonly rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
-    readonly rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
-    readonly rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
-    readonly rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
-    readonly wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
-    readonly __wbindgen_malloc: (a: number, b: number) => number;
-    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-    readonly __wbindgen_exn_store: (a: number) => void;
-    readonly __externref_table_alloc: () => number;
-    readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
-    readonly __externref_table_dealloc: (a: number) => void;
-    readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-
-/**
- * Instantiates the given `module`, which can either be bytes or
- * a precompiled `WebAssembly.Module`.
- *
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
- *
- * @returns {InitOutput}
- */
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
- * for everything else, calls `WebAssembly.instantiate` directly.
- *
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
- *
- * @returns {Promise<InitOutput>}
- */
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;