rastack 0.0.16

package/test/compile.spec.ts

@@ -0,0 +1,192 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  analyzeResources,
+  buildOpenApi,
+  collisions,
+  compile,
+  ResourceModel,
+} from "../src/compile";
+import { generateFiles, generateFolders } from "../src/schema-entities";
+import { removeNonModelPaths } from "../src/schema/remove-non-model-paths";
+
+/**
+ * The compiler's fixtures are real `.ts` files that import the DSL by its
+ * package name (`rad-tools/define`); `createProgram` maps that to the in-tree
+ * source, so the type checker resolves the `Ref`/`Resource` brands exactly as it
+ * would in a consumer project.
+ */
+const workRoot = join(__dirname, "compile-fixtures");
+const resourcesDir = join(workRoot, "resources");
+const outDir = join(workRoot, "out");
+
+const AIRPORTS_TS = `
+import { resource, s } from "rad-tools/define";
+
+export const Airport = resource("airports", "airport", {
+  code: s.string({ maxLength: 3, unique: true }),
+  name: s.string({ maxLength: 120 }),
+}, { search: ["code", "name"], admin: { listDisplay: ["code", "name"] } });
+
+export const Terminal = resource("airports", "terminal", {
+  airport: s.ref(() => Airport),
+  label: s.string({ maxLength: 20 }),
+});
+
+export const Flight = resource("airports", "flight", {
+  number: s.string({ maxLength: 8 }),
+  status: s.string({ maxLength: 20, default: "scheduled" }),
+}, { sync: { mode: "local", scope: "owner_id={user.id}", confirmed: ["update"] } });
+
+export const Gate = resource("airports", "gate", {
+  number: s.string({ maxLength: 5 }),
+}, { sync: { mode: "local", load: "lazy" } });
+
+export const Booking = resource("airports", "booking", {
+  reference: s.string({ maxLength: 12 }),
+}, { sync: { mode: "local", clientIds: true } });
+`;
+
+function findResource(
+  resources: ResourceModel[],
+  app: string,
+  model: string,
+): ResourceModel {
+  const found = resources.find((r) => r.app === app && r.model === model);
+  if (!found) throw new Error(`missing ${app}.${model}`);
+  return found;
+}
+
+describe("rad compile — resource analysis & FK inference", () => {
+  beforeAll(() => {
+    mkdirSync(resourcesDir, { recursive: true });
+    writeFileSync(join(resourcesDir, "airports.ts"), AIRPORTS_TS);
+  });
+
+  afterAll(() => {
+    rmSync(workRoot, { recursive: true, force: true });
+  });
+
+  it("infers a foreign key from the field type", () => {
+    const resources = analyzeResources(resourcesDir);
+    const terminal = findResource(resources, "airports", "terminal");
+
+    const airportField = terminal.fields.find((f) => f.name === "airport");
+    expect(airportField?.type).toBe("fk");
+    expect(airportField?.relation).toEqual({ app: "airports", model: "airport" });
+
+    expect(terminal.relations).toEqual([
+      { field: "airport", target: "airports.airport", kind: "fk" },
+    ]);
+  });
+
+  it("maps scalar fields and their constraints", () => {
+    const resources = analyzeResources(resourcesDir);
+    const airport = findResource(resources, "airports", "airport");
+
+    const code = airport.fields.find((f) => f.name === "code");
+    expect(code).toMatchObject({ type: "string", maxLength: 3, unique: true });
+
+    const name = airport.fields.find((f) => f.name === "name");
+    expect(name).toMatchObject({ type: "string", maxLength: 120 });
+
+    expect(airport.search).toEqual(["code", "name"]);
+    expect(airport.admin).toEqual({ listDisplay: ["code", "name"] });
+  });
+
+  it("captures sync config (local / lazy / client-ids / confirmed)", () => {
+    const resources = analyzeResources(resourcesDir);
+
+    expect(findResource(resources, "airports", "flight").sync).toMatchObject({
+      mode: "local",
+      scope: "owner_id={user.id}",
+      confirmed: ["update"],
+    });
+    expect(findResource(resources, "airports", "gate").sync).toMatchObject({
+      mode: "local",
+      load: "lazy",
+    });
+    expect(findResource(resources, "airports", "booking").sync).toMatchObject({
+      mode: "local",
+      clientIds: true,
+    });
+  });
+
+  it("reports no collisions for a valid graph", () => {
+    const resources = analyzeResources(resourcesDir);
+    expect(collisions(resources)).toEqual([]);
+  });
+});
+
+describe("rad compile — OpenAPI emission", () => {
+  beforeAll(() => {
+    mkdirSync(resourcesDir, { recursive: true });
+    writeFileSync(join(resourcesDir, "airports.ts"), AIRPORTS_TS);
+  });
+
+  afterAll(() => {
+    rmSync(workRoot, { recursive: true, force: true });
+  });
+
+  it("writes schema.rad.json and openapi.json", () => {
+    const result = compile(resourcesDir, outDir);
+    expect(existsSync(join(outDir, "schema.rad.json"))).toBe(true);
+    expect(existsSync(join(outDir, "openapi.json"))).toBe(true);
+    expect(result.manifest.resources.length).toBe(5);
+  });
+
+  it("emits the /api/{app}/v1/{model}/ contract with FK + sync extensions", () => {
+    const resources = analyzeResources(resourcesDir);
+    const doc = buildOpenApi(resources);
+
+    // URL-segment contract the codegen keys off.
+    expect(doc.paths["/api/airports/v1/terminal/"]).toBeDefined();
+    expect(doc.paths["/api/airports/v1/terminal/{id}/"]).toBeDefined();
+
+    // FK field carries the new relation extension.
+    const terminalSchema = doc.components.schemas.Terminal;
+    expect(terminalSchema.properties.airport["x-rastack-relation"]).toEqual({
+      app: "airports",
+      model: "airport",
+    });
+
+    // Local-mode sync extensions, confirmed on update.
+    const flightList = doc.paths["/api/airports/v1/flight/"];
+    expect(flightList.get["x-rastack-sync"]).toBe("local");
+    expect(doc.paths["/api/airports/v1/flight/{id}/"].put["x-rastack-sync"]).toBe(
+      "confirmed",
+    );
+    expect(doc.paths["/api/airports/v1/gate/"].get["x-rastack-sync-load"]).toBe(
+      "lazy",
+    );
+    expect(
+      doc.paths["/api/airports/v1/booking/"].post["x-rastack-sync-client-ids"],
+    ).toBe(true);
+  });
+
+  it("round-trips through the existing hooks codegen", async () => {
+    const resources = analyzeResources(resourcesDir);
+    const doc = buildOpenApi(resources);
+    const paths = removeNonModelPaths(doc.paths);
+
+    const entitiesPath = join(workRoot, "entities");
+    mkdirSync(entitiesPath, { recursive: true });
+    await generateFolders(entitiesPath, paths);
+    await generateFiles(entitiesPath, paths);
+
+    // Non-sync entity → plain async hook.
+    const airportApi = readFileSync(
+      join(entitiesPath, "airports", "airport", "api.ts"),
+      "utf-8",
+    );
+    expect(airportApi).toContain("export function useListAirport(");
+
+    // Sync entity → store-backed hooks + a defineEntity descriptor.
+    const flightApi = readFileSync(
+      join(entitiesPath, "airports", "flight", "api.ts"),
+      "utf-8",
+    );
+    expect(flightApi).toContain("defineEntity<IFlight>({");
+    expect(flightApi).toContain("from 'rastack/sync'");
+  });
+});

package/test/csv-schema.spec.ts

@@ -0,0 +1,143 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { parseCsv, inferSchema, discoverCsvFiles } from "../src/csv-schema";
+
+const REPO_ROOT = path.join(__dirname, "..");
+
+function tmpCsv(content: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rad-test-"));
+  const file = path.join(dir, "test.csv");
+  fs.writeFileSync(file, content);
+  return file;
+}
+
+describe("parseCsv", () => {
+  it("parses headers and rows", () => {
+    const { headers, rows } = parseCsv("id,name,age\n1,Alice,30\n2,Bob,25");
+    expect(headers).toEqual(["id", "name", "age"]);
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toEqual(["1", "Alice", "30"]);
+  });
+
+  it("handles quoted fields with commas", () => {
+    const { headers, rows } = parseCsv(`name,bio\nAlice,"Engineer, Pilot"\nBob,Writer`);
+    expect(rows[0][1]).toBe("Engineer, Pilot");
+  });
+
+  it("returns empty for blank input", () => {
+    const { headers, rows } = parseCsv("");
+    expect(headers).toHaveLength(0);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe("inferSchema — type inference", () => {
+  it("infers integer columns", () => {
+    const csv = tmpCsv("id,score\n1,100\n2,200\n3,300");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    const id = schema.columns.find((c) => c.name === "id")!;
+    const score = schema.columns.find((c) => c.name === "score")!;
+    expect(id.type).toBe("integer");
+    expect(score.type).toBe("integer");
+  });
+
+  it("infers float columns", () => {
+    const csv = tmpCsv("price\n1.99\n3.50\n0.01");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    expect(schema.columns[0].type).toBe("float");
+  });
+
+  it("infers boolean columns", () => {
+    const csv = tmpCsv("active\ntrue\nfalse\ntrue");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    expect(schema.columns[0].type).toBe("boolean");
+  });
+
+  it("infers date columns", () => {
+    const csv = tmpCsv("dob\n1990-01-01\n1985-06-15");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    // dob matches PII but type should still be date
+    expect(schema.columns[0].type).toBe("date");
+  });
+
+  it("infers datetime columns", () => {
+    const csv = tmpCsv("created_at\n2024-01-01T10:00:00Z\n2024-02-01T12:30:00Z");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    expect(schema.columns[0].type).toBe("datetime");
+  });
+
+  it("marks id column as primaryKey", () => {
+    const csv = tmpCsv("id,name\n1,Alice");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    const id = schema.columns.find((c) => c.name === "id")!;
+    expect(id.primaryKey).toBe(true);
+  });
+
+  it("detects nullable columns", () => {
+    const csv = tmpCsv("id,note\n1,hello\n2,\n3,world");
+    const { schema } = inferSchema(csv, REPO_ROOT);
+    const note = schema.columns.find((c) => c.name === "note")!;
+    expect(note.nullable).toBe(true);
+  });
+});
+
+describe("inferSchema — PII detection", () => {
+  it("flags passport_no as PII", () => {
+    const csv = tmpCsv("id,passport_no\n1,AB123456\n2,CD789012");
+    const { schema, piiViolations } = inferSchema(csv, REPO_ROOT);
+    const col = schema.columns.find((c) => c.name === "passport_no")!;
+    expect(col.pii).toBe(true);
+    expect(piiViolations).toHaveLength(1);
+    expect(piiViolations[0].column).toBe("passport_no");
+  });
+
+  it("flags email as PII", () => {
+    const csv = tmpCsv("id,email\n1,alice@example.com");
+    const { piiViolations } = inferSchema(csv, REPO_ROOT);
+    expect(piiViolations.some((v) => v.column === "email")).toBe(true);
+  });
+
+  it("flags dob as PII", () => {
+    const csv = tmpCsv("id,dob\n1,1990-01-01");
+    const { piiViolations } = inferSchema(csv, REPO_ROOT);
+    expect(piiViolations.some((v) => v.column === "dob")).toBe(true);
+  });
+
+  it("does not flag non-PII columns", () => {
+    const csv = tmpCsv("id,flight_code,origin,destination\n1,SA101,JNB,LHR");
+    const { piiViolations } = inferSchema(csv, REPO_ROOT);
+    expect(piiViolations).toHaveLength(0);
+  });
+
+  it("generates a stable fingerprint", () => {
+    const csv = tmpCsv("id,name\n1,Alice\n2,Bob");
+    const { schema: a } = inferSchema(csv, REPO_ROOT);
+    const { schema: b } = inferSchema(csv, REPO_ROOT);
+    expect(a.fingerprint).toBe(b.fingerprint);
+  });
+
+  it("generates different fingerprints for different schemas", () => {
+    const csvA = tmpCsv("id,name\n1,Alice");
+    const csvB = tmpCsv("id,name,email\n1,Alice,a@b.com");
+    const { schema: a } = inferSchema(csvA, REPO_ROOT);
+    const { schema: b } = inferSchema(csvB, REPO_ROOT);
+    expect(a.fingerprint).not.toBe(b.fingerprint);
+  });
+});
+
+describe("discoverCsvFiles", () => {
+  it("finds all csv files in a directory", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "rad-test-"));
+    fs.writeFileSync(path.join(dir, "a.csv"), "id\n1");
+    fs.writeFileSync(path.join(dir, "b.csv"), "id\n2");
+    fs.writeFileSync(path.join(dir, "readme.txt"), "not a csv");
+    const files = discoverCsvFiles(dir);
+    expect(files).toHaveLength(2);
+    expect(files.every((f) => f.endsWith(".csv"))).toBe(true);
+  });
+
+  it("returns empty for missing directory", () => {
+    expect(discoverCsvFiles("/nonexistent/path")).toHaveLength(0);
+  });
+});