rastack 0.0.57 → 0.0.59

package/test/import.spec.ts

@@ -1,241 +0,0 @@
-/**
- * The external-data import pipeline: format parsers (CSV via `parseCsv`, the
- * dependency-free XLSX and PDF readers) and the pure validation core that
- * runs a whole tabular source through a resource's constraint state machine.
- *
- * The XLSX fixture is built with the repo's own `zipStore` (deploy/zip.ts) —
- * the reader handles STORE entries, which is exactly what the writer emits.
- * The PDF fixtures are hand-written minimal documents (one raw content
- * stream, one FlateDecode) exercising the text operators the extractor
- * replays.
- */
-
-import { deflateSync } from "zlib";
-import { zipStore } from "../src/deploy/zip";
-import {
-  formatOf,
-  idsFromTabular,
-  mapHeaders,
-  parsePdfTable,
-  parseTabular,
-  parseXlsx,
-  validateDataset,
-} from "../src/import";
-import { specsFromResource } from "../src/validate";
-import type { FieldModel } from "../src/compile/model";
-
-// The airline fixtures, as `rastack compile` writes them to the manifest.
-const AIRPORT_FIELDS: FieldModel[] = [
-  { name: "code", type: "string", maxLength: 3, unique: true },
-  { name: "name", type: "string", maxLength: 120 },
-];
-const TERMINAL_FIELDS: FieldModel[] = [
-  {
-    name: "airport",
-    type: "fk",
-    relation: { app: "airports", model: "airport" },
-  },
-  { name: "label", type: "string", maxLength: 20 },
-];
-
-describe("header mapping", () => {
-  it("matches case-, space- and separator-insensitively", () => {
-    const specs = specsFromResource({
-      fields: [
-        { name: "owner_id", type: "int" },
-        { name: "code", type: "string" },
-      ] as FieldModel[],
-    });
-    const { columns, missingFields } = mapHeaders(
-      ["Owner ID", "CODE", "junk"],
-      specs,
-    );
-    expect(columns).toEqual([
-      { header: "Owner ID", field: "owner_id" },
-      { header: "CODE", field: "code" },
-      { header: "junk", field: null },
-    ]);
-    expect(missingFields).toEqual([]);
-  });
-
-  it("reports fields no column covers", () => {
-    const specs = specsFromResource({ fields: AIRPORT_FIELDS });
-    const { missingFields } = mapHeaders(["code"], specs);
-    expect(missingFields).toEqual(["name"]);
-  });
-});
-
-describe("dataset validation through the state machine", () => {
-  const airportSpecs = specsFromResource({ fields: AIRPORT_FIELDS });
-
-  it("validates a CSV row-by-row, locating each failed gate", () => {
-    const csv = Buffer.from(
-      "code,name\n" +
-        "LHR,Heathrow\n" +
-        "LHRX,Too Long A Code\n" +
-        "LHR,Duplicate Of Row One\n" +
-        ",Missing Code\n",
-    );
-    const report = validateDataset(airportSpecs, parseTabular("csv", csv));
-
-    expect(report.total).toBe(4);
-    expect(report.valid).toBe(1);
-    expect(report.invalid).toBe(3);
-    expect(report.records).toEqual([{ code: "LHR", name: "Heathrow" }]);
-    expect(report.issues).toMatchObject([
-      { row: 1, field: "code", gate: "bounded" },
-      { row: 2, field: "code", gate: "unique" },
-      { row: 3, field: "code", gate: "present" },
-    ]);
-  });
-
-  it("resolves foreign keys against a related file's ids", () => {
-    const airports = parseTabular(
-      "csv",
-      Buffer.from("id,code,name\n1,LHR,Heathrow\n2,JFK,Kennedy\n"),
-    );
-    const terminals = parseTabular(
-      "csv",
-      Buffer.from("airport,label\n1,Terminal 5\n9,Ghost Terminal\n"),
-    );
-
-    const report = validateDataset(
-      specsFromResource({ fields: TERMINAL_FIELDS }),
-      terminals,
-      { relatedIds: { "airports.airport": idsFromTabular(airports) } },
-    );
-
-    expect(report.valid).toBe(1);
-    // FK ids coerce to numbers on the way through the `typed` gate.
-    expect(report.records).toEqual([{ airport: 1, label: "Terminal 5" }]);
-    expect(report.issues).toMatchObject([
-      { row: 1, field: "airport", gate: "resolved" },
-    ]);
-  });
-
-  it("infers the source format from the file name", () => {
-    expect(formatOf("airports.csv")).toBe("csv");
-    expect(formatOf("Airports.XLSX")).toBe("xlsx");
-    expect(formatOf("report.pdf")).toBe("pdf");
-    expect(formatOf("notes.txt")).toBeNull();
-  });
-});
-
-describe("XLSX reader", () => {
-  const SHARED_STRINGS =
-    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
-    `<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="4" uniqueCount="4">` +
-    `<si><t>code</t></si><si><t>name</t></si><si><t>LHR</t></si>` +
-    `<si><r><t>Heath</t></r><r><t>row &amp; Co</t></r></si>` +
-    `</sst>`;
-
-  const SHEET =
-    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
-    `<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>` +
-    `<row r="1"><c r="A1" t="s"><v>0</v></c><c r="B1" t="s"><v>1</v></c></row>` +
-    `<row r="2"><c r="A2" t="s"><v>2</v></c><c r="B2" t="s"><v>3</v></c></row>` +
-    `<row r="3"><c r="A3" t="inlineStr"><is><t>JFK</t></is></c><c r="B3"><v>42</v></c></row>` +
-    // A row with only column B populated — column A must come back as "".
-    `<row r="4"><c r="B4" t="inlineStr"><is><t>Orphan</t></is></c></row>` +
-    `</sheetData></worksheet>`;
-
-  const workbook = () =>
-    zipStore([
-      { name: "xl/sharedStrings.xml", data: Buffer.from(SHARED_STRINGS) },
-      { name: "xl/worksheets/sheet1.xml", data: Buffer.from(SHEET) },
-    ]);
-
-  it("reads shared strings (incl. rich-text runs), inline strings and numbers", () => {
-    const { headers, rows } = parseXlsx(workbook());
-    expect(headers).toEqual(["code", "name"]);
-    expect(rows).toEqual([
-      ["LHR", "Heathrow & Co"],
-      ["JFK", "42"],
-      ["", "Orphan"],
-    ]);
-  });
-
-  it("feeds straight into the state machine like any other source", () => {
-    const report = validateDataset(
-      specsFromResource({ fields: AIRPORT_FIELDS }),
-      parseXlsx(workbook()),
-    );
-    expect(report.valid).toBe(2);
-    // Row 3 has no `code` — required, so it halts at `present`.
-    expect(report.issues).toMatchObject([
-      { row: 2, field: "code", gate: "present" },
-    ]);
-  });
-});
-
-describe("PDF table extractor", () => {
-  const CONTENT =
-    "BT\n" +
-    "/F1 12 Tf\n" +
-    "72 720 Td\n" +
-    "(code) Tj\n" +
-    "150 0 Td\n" +
-    "(name) Tj\n" +
-    "ET\n" +
-    "BT\n" +
-    "72 700 Td\n" +
-    "(LHR) Tj\n" +
-    "150 0 Td\n" +
-    "(Heathrow \\(west\\)) Tj\n" +
-    "ET\n" +
-    "BT\n" +
-    "72 680 Td\n" +
-    "[(J) 20 (FK)] TJ\n" +
-    "150 0 Td\n" +
-    "(Kennedy) Tj\n" +
-    "ET\n";
-
-  function rawPdf(content: string): Buffer {
-    return Buffer.from(
-      `%PDF-1.4\n1 0 obj\n<< /Length ${content.length} >>\nstream\n` +
-        content +
-        `\nendstream\nendobj\n%%EOF\n`,
-      "latin1",
-    );
-  }
-
-  function flatePdf(content: string): Buffer {
-    const compressed = deflateSync(Buffer.from(content, "latin1"));
-    return Buffer.concat([
-      Buffer.from(
-        `%PDF-1.4\n1 0 obj\n<< /Length ${compressed.length} /Filter /FlateDecode >>\nstream\n`,
-        "latin1",
-      ),
-      compressed,
-      Buffer.from(`\nendstream\nendobj\n%%EOF\n`, "latin1"),
-    ]);
-  }
-
-  const expected = {
-    headers: ["code", "name"],
-    rows: [
-      ["LHR", "Heathrow (west)"],
-      ["JFK", "Kennedy"],
-    ],
-  };
-
-  it("clusters positioned text into rows (raw stream)", () => {
-    expect(parsePdfTable(rawPdf(CONTENT))).toEqual(expected);
-  });
-
-  it("decodes FlateDecode content streams", () => {
-    expect(parsePdfTable(flatePdf(CONTENT))).toEqual(expected);
-  });
-
-  it("feeds straight into the state machine like any other source", () => {
-    const report = validateDataset(
-      specsFromResource({ fields: AIRPORT_FIELDS }),
-      parsePdfTable(rawPdf(CONTENT)),
-    );
-    expect(report.valid).toBe(2);
-    expect(report.records).toEqual([
-      { code: "LHR", name: "Heathrow (west)" },
-      { code: "JFK", name: "Kennedy" },
-    ]);
-  });
-});

package/test/plugin.spec.ts

@@ -1,315 +0,0 @@
-/**
- * The dev-server schema compiler (`rastack/plugin`) — the way around
- * "classes need a compile step". The plugin runs the same
- * `analyzeProject`/`compile` pass as the CLI *inside* the bundler: entities
- * authored as plain classes/interfaces become the `virtual:rastack-manifest`
- * module, recompiled on save, with `rastack-env.d.ts` kept fresh and the
- * last good manifest served through broken in-progress edits.
- */
-
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import {
-  GLOBAL_MANIFEST_KEY,
-  isEntitySource,
-  manifestModuleCode,
-  rastackPlugin,
-  registerModuleCode,
-  resolveOptions,
-  RESOLVED_MANIFEST_ID,
-  startRastackWatcher,
-  VIRTUAL_MANIFEST_ID,
-  VIRTUAL_REGISTER_ID,
-  virtualModuleDts,
-} from "../src/plugin";
-import { getGlobalManifest } from "../hooks/manifest";
-import { resolveEntityRef } from "../hooks/entity";
-
-const workRoot = join(__dirname, "plugin-fixtures");
-const resourcesDir = join(workRoot, "entities");
-const outDir = join(workRoot, ".rastack");
-
-// Plain classes + a hook-rooted interface — no resource() DSL anywhere.
-const GOOD_SOURCE = `
-export class Airport {
-  code!: string;
-  name!: string;
-}
-
-export class Terminal {
-  airport!: Airport;   // FK — inferred from the type
-  label!: string;
-}
-`;
-
-// An all-required FK cycle — a compile *error* (the mid-edit breakage case).
-const BROKEN_SOURCE = `
-export class Airport {
-  code!: string;
-  home!: Terminal;
-}
-
-export class Terminal {
-  airport!: Airport;
-  label!: string;
-}
-`;
-
-function writeEntities(source: string): void {
-  writeFileSync(join(resourcesDir, "airports.ts"), source);
-}
-
-beforeEach(() => {
-  rmSync(workRoot, { recursive: true, force: true });
-  mkdirSync(resourcesDir, { recursive: true });
-  writeEntities(GOOD_SOURCE);
-});
-
-afterAll(() => {
-  rmSync(workRoot, { recursive: true, force: true });
-});
-
-function makePlugin(overrides: Record<string, unknown> = {}) {
-  return rastackPlugin({
-    resourcesDir,
-    outDir,
-    onError: () => {},
-    ...overrides,
-  });
-}
-
-describe("rastackPlugin — the bundler hooks", () => {
-  it("serves class entities as the virtual manifest module", () => {
-    const plugin = makePlugin();
-    plugin.buildStart();
-
-    expect(plugin.resolveId(VIRTUAL_MANIFEST_ID)).toBe(RESOLVED_MANIFEST_ID);
-    expect(plugin.resolveId("some/other/module")).toBeUndefined();
-
-    const code = plugin.load(RESOLVED_MANIFEST_ID)!;
-    expect(code).toContain("export default manifest");
-    const manifest = plugin.api.manifest();
-    expect(code).toContain(JSON.stringify(manifest));
-
-    // The classes were compiled: fields read off the type system, the
-    // Airport-typed property inferred as a foreign key.
-    // The app name derives from the defining file (airports.ts → "airports").
-    const terminal = manifest.resources.find((r) => r.model === "terminal")!;
-    expect(terminal.relations).toEqual([
-      { field: "airport", target: "airports.airport", kind: "fk" },
-    ]);
-    expect(manifestModuleCode(manifest)).toBe(code);
-  });
-
-  it("writes the artifacts — schema, openapi, env.d.ts, virtual-module types", () => {
-    makePlugin().buildStart();
-    expect(existsSync(join(outDir, "schema.rastack.json"))).toBe(true);
-    expect(existsSync(join(outDir, "openapi.json"))).toBe(true);
-
-    const env = readFileSync(join(outDir, "rastack-env.d.ts"), "utf8");
-    expect(env).toContain('"airports.airport": import("../entities/airports").Airport;');
-
-    const dts = readFileSync(join(outDir, "rastack-plugin.d.ts"), "utf8");
-    expect(dts).toBe(virtualModuleDts());
-    expect(dts).toContain(`declare module "${VIRTUAL_MANIFEST_ID}"`);
-  });
-
-  it("recompiles when a watched entity changes", () => {
-    const plugin = makePlugin();
-    plugin.buildStart();
-    expect(
-      plugin.api.manifest().resources.map((r) => r.model),
-    ).toEqual(["airport", "terminal"]);
-
-    writeEntities(GOOD_SOURCE + "\nexport class Gate { number!: string }\n");
-    plugin.watchChange(join(resourcesDir, "airports.ts"));
-
-    expect(plugin.api.manifest().resources.map((r) => r.model)).toEqual([
-      "airport",
-      "gate",
-      "terminal",
-    ]);
-    expect(plugin.load(RESOLVED_MANIFEST_ID)).toContain('"gate"');
-  });
-
-  it("keeps serving the last good manifest through a broken edit", () => {
-    const errors: unknown[] = [];
-    const plugin = makePlugin({ onError: (e: unknown) => errors.push(e) });
-    plugin.buildStart();
-    const goodCode = plugin.load(RESOLVED_MANIFEST_ID);
-
-    writeEntities(BROKEN_SOURCE);
-    plugin.watchChange(join(resourcesDir, "airports.ts"));
-
-    // The compile failed (reported), but the app keeps its manifest.
-    expect(plugin.load(RESOLVED_MANIFEST_ID)).toBe(goodCode);
-    expect(errors).toHaveLength(1);
-    expect(String((errors[0] as Error).message)).toMatch(/circular/i);
-    expect(plugin.api.error()).toBe(errors[0]);
-
-    // Fixing the file recovers on the next change (load() recompiles).
-    writeEntities(GOOD_SOURCE);
-    plugin.watchChange(join(resourcesDir, "airports.ts"));
-    expect(plugin.load(RESOLVED_MANIFEST_ID)).toBe(goodCode);
-    expect(plugin.api.error()).toBeUndefined();
-  });
-
-  it("throws at startup when there is no good manifest to fall back to", () => {
-    writeEntities(BROKEN_SOURCE);
-    const plugin = makePlugin();
-    expect(() => plugin.buildStart()).toThrow(/circular/i);
-  });
-
-  it("hot-invalidates the virtual module in a Vite-shaped server", () => {
-    const plugin = makePlugin();
-    plugin.buildStart();
-
-    const virtualModule = { id: RESOLVED_MANIFEST_ID };
-    const invalidated: unknown[] = [];
-    const server = {
-      moduleGraph: {
-        getModuleById: (id: string) =>
-          id === RESOLVED_MANIFEST_ID ? virtualModule : undefined,
-        invalidateModule: (mod: unknown) => invalidated.push(mod),
-      },
-    };
-
-    const changed = { id: "changed" };
-    const result = plugin.handleHotUpdate({
-      file: join(resourcesDir, "airports.ts"),
-      server,
-      modules: [changed],
-    });
-    expect(invalidated).toEqual([virtualModule]);
-    expect(result).toEqual([changed, virtualModule]);
-
-    // Unrelated files don't touch the schema.
-    expect(
-      plugin.handleHotUpdate({
-        file: join(workRoot, "App.tsx"),
-        server,
-        modules: [changed],
-      }),
-    ).toBeUndefined();
-  });
-});
-
-describe("auto-registration — no manifest prop anywhere", () => {
-  afterEach(() => {
-    delete (globalThis as Record<string, unknown>)[GLOBAL_MANIFEST_KEY];
-  });
-
-  it("serves a register module that publishes the manifest globally", () => {
-    const plugin = makePlugin();
-    plugin.buildStart();
-
-    expect(plugin.resolveId(VIRTUAL_REGISTER_ID)).toBe(VIRTUAL_REGISTER_ID);
-    const code = plugin.load(VIRTUAL_REGISTER_ID)!;
-    expect(code).toBe(registerModuleCode());
-    expect(code).toContain(`import manifest from "${VIRTUAL_MANIFEST_ID}"`);
-    expect(code).toContain(`globalThis.${GLOBAL_MANIFEST_KEY} = manifest`);
-  });
-
-  it("injects the register script into index.html (dev src, build inline)", () => {
-    const plugin = makePlugin();
-    expect(plugin.transformIndexHtml.order).toBe("pre");
-
-    const dev = plugin.transformIndexHtml.handler("<html/>", { server: {} });
-    expect(dev).toEqual([
-      {
-        tag: "script",
-        attrs: { type: "module", src: `/@id/${VIRTUAL_REGISTER_ID}` },
-        injectTo: "head-prepend",
-      },
-    ]);
-
-    const build = plugin.transformIndexHtml.handler("<html/>", {});
-    expect(build).toEqual([
-      {
-        tag: "script",
-        attrs: { type: "module" },
-        children: `import "${VIRTUAL_REGISTER_ID}";`,
-        injectTo: "head-prepend",
-      },
-    ]);
-  });
-
-  it("the runtime falls back to the registered global manifest", () => {
-    class Airport {
-      code!: string;
-    }
-    // Nothing registered → the class cannot resolve without a manifest.
-    expect(getGlobalManifest()).toBeUndefined();
-    expect(() => resolveEntityRef(Airport, getGlobalManifest())).toThrow(
-      /manifest/,
-    );
-
-    // What the injected register module does at boot:
-    (globalThis as Record<string, unknown>)[GLOBAL_MANIFEST_KEY] = {
-      version: 1,
-      resources: [
-        { app: "airports", model: "airport", fields: [], relations: [] },
-      ],
-    };
-
-    const manifest = getGlobalManifest()!;
-    expect(manifest.resources).toHaveLength(1);
-    expect(getGlobalManifest()).toBe(manifest); // cached per assignment
-    // useRastackManifest (which useData/useForm read outside any provider)
-    // falls back to this global, so a bare useData(Airport) resolves with
-    // zero schema wiring in app code.
-    expect(resolveEntityRef(Airport, getGlobalManifest()).listUrl).toBe(
-      "/api/airports/v1/airport/",
-    );
-  });
-});
-
-describe("isEntitySource — what triggers a recompile", () => {
-  const options = resolveOptions({ resourcesDir, outDir }, workRoot);
-
-  it("accepts .ts/.tsx under the resources dir and nothing else", () => {
-    expect(isEntitySource(join(resourcesDir, "a.ts"), options)).toBe(true);
-    expect(isEntitySource(join(resourcesDir, "deep", "b.tsx"), options)).toBe(true);
-    expect(isEntitySource(join(resourcesDir, "a.d.ts"), options)).toBe(false);
-    expect(isEntitySource(join(resourcesDir, "notes.md"), options)).toBe(false);
-    expect(isEntitySource(join(workRoot, "elsewhere.ts"), options)).toBe(false);
-    // The emitted artifacts must never re-trigger the compiler.
-    expect(isEntitySource(join(outDir, "rastack-env.d.ts"), options)).toBe(false);
-  });
-});
-
-describe("startRastackWatcher — the non-Rollup dev servers", () => {
-  it("compiles at start and rewrites artifacts on save", async () => {
-    const watcher = startRastackWatcher({
-      resourcesDir,
-      outDir,
-      onError: () => {},
-    });
-    try {
-      expect(existsSync(join(outDir, "schema.rastack.json"))).toBe(true);
-      expect(
-        watcher.state.manifest().resources.map((r) => r.model),
-      ).toEqual(["airport", "terminal"]);
-
-      writeEntities(GOOD_SOURCE + "\nexport class Gate { number!: string }\n");
-      await waitFor(() =>
-        readFileSync(join(outDir, "schema.rastack.json"), "utf8").includes(
-          '"gate"',
-        ),
-      );
-    } finally {
-      watcher.close();
-    }
-  });
-});
-
-async function waitFor(check: () => boolean, timeoutMs = 5000): Promise<void> {
-  const start = Date.now();
-  for (;;) {
-    if (check()) return;
-    if (Date.now() - start > timeoutMs) {
-      throw new Error("waitFor: condition not met in time");
-    }
-    await new Promise((r) => setTimeout(r, 50));
-  }
-}