shapecraft 1.0.0

package/packages/core/src/shape/transforms/sql/from-sql.test.ts

@@ -0,0 +1,704 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect } from "vitest";
+import { R } from "../../../common/result";
+import { shapes } from "../../shape";
+import { fromSQL } from "./from-sql";
+import { toSQL } from "./transform";
+
+const ok = (res: R.Result<shapes.Shape, string[]>): shapes.Shape => {
+  if (!R.isOk(res))
+    throw new Error(`expected ok, got err: ${res.error.join("; ")}`);
+  return res.value;
+};
+
+const err = (res: R.Result<shapes.Shape, string[]>): string[] => {
+  if (R.isOk(res))
+    throw new Error(`expected err, got ok: ${String(res.value)}`);
+  return res.error;
+};
+
+const asMapping = (s: shapes.Shape): shapes.ShapeMapping => {
+  if (s.type !== "mapping") throw new Error(`expected mapping, got ${s.type}`);
+  return s;
+};
+
+const asModule = (s: shapes.Shape): shapes.ShapeModule => {
+  if (s.type !== "module") throw new Error(`expected module, got ${s.type}`);
+  return s;
+};
+
+describe("fromSQL — basics", (it) => {
+  it("empty / no tables → err", () => {
+    expect(err(fromSQL("-- nothing here"))).toEqual([
+      "no CREATE TABLE statements found",
+    ]);
+  });
+
+  it("minimal table", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          id integer primary key,
+          name text not null
+        );
+      `),
+      ),
+    );
+    expect(m.anno.title).toBe("t");
+    expect(Object.keys(m.input)).toEqual(["id", "name"]);
+    const id = m.input["id"]!;
+    expect(id.type).toBe("number");
+    expect(id.anno.primary).toBe(true);
+    // primary implies notNull, so no optional
+    expect(id.anno.optional).toBeUndefined();
+    const name = m.input["name"]!;
+    expect(name.type).toBe("string");
+    expect(name.anno.optional).toBeUndefined();
+  });
+
+  it("optional column", () => {
+    const m = asMapping(ok(fromSQL(`CREATE TABLE t (a integer, b text);`)));
+    expect(m.input["a"]!.anno.optional).toBe(true);
+    expect(m.input["b"]!.anno.optional).toBe(true);
+  });
+
+  it("scalar pg types map to expected number tags", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(
+          `CREATE TABLE t (
+              a smallint not null,
+              b integer not null,
+              c bigint not null,
+              d real not null,
+              e double precision not null,
+              f boolean not null
+            );`,
+        ),
+      ),
+    );
+    expect((m.input["a"] as shapes.ShapeNumber).tag).toBe("int16");
+    expect((m.input["b"] as shapes.ShapeNumber).tag).toBe("int32");
+    expect((m.input["c"] as shapes.ShapeNumber).tag).toBe("int64");
+    expect((m.input["d"] as shapes.ShapeNumber).tag).toBe("float32");
+    expect((m.input["e"] as shapes.ShapeNumber).tag).toBe("float64");
+    expect(m.input["f"]!.type).toBe("boolean");
+  });
+
+  it("SERIAL family → autoIncrement", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(
+          `CREATE TABLE t (
+              a smallserial not null,
+              b serial not null,
+              c bigserial not null
+            );`,
+        ),
+      ),
+    );
+    expect((m.input["a"] as shapes.ShapeNumber).tag).toBe("int16");
+    expect(m.input["a"]!.anno.autoIncrement).toBe(true);
+    expect((m.input["b"] as shapes.ShapeNumber).tag).toBe("int32");
+    expect(m.input["b"]!.anno.autoIncrement).toBe(true);
+    expect((m.input["c"] as shapes.ShapeNumber).tag).toBe("int64");
+    expect(m.input["c"]!.anno.autoIncrement).toBe(true);
+  });
+
+  it("VARCHAR(n) → string with max=n; CHAR(n) → string with min=max=n", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`CREATE TABLE t (a varchar(50) not null, b char(3) not null);`),
+      ),
+    );
+    expect(m.input["a"]!.anno.max).toBe(50);
+    expect(m.input["a"]!.anno.min).toBeUndefined();
+    expect(m.input["b"]!.anno.min).toBe(3);
+    expect(m.input["b"]!.anno.max).toBe(3);
+  });
+
+  it("NUMERIC(20,0) → uint64; NUMERIC(p,s) → number+format", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(
+          `CREATE TABLE t (a numeric(20,0) not null, b numeric(10,2) not null);`,
+        ),
+      ),
+    );
+    expect((m.input["a"] as shapes.ShapeNumber).tag).toBe("uint64");
+    expect(m.input["b"]!.type).toBe("number");
+    expect(m.input["b"]!.anno.format).toBe("pgtype:numeric(10,2)");
+  });
+
+  it("uuid → string + format=uuid + pattern", () => {
+    const m = asMapping(ok(fromSQL(`CREATE TABLE t (id uuid not null);`)));
+    expect(m.input["id"]!.type).toBe("string");
+    expect(m.input["id"]!.anno.format).toBe("uuid");
+    expect(m.input["id"]!.anno.pattern).toBeInstanceOf(RegExp);
+  });
+
+  it("text[] / int[] → array shapes", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`CREATE TABLE t (tags text[] not null, ints int[] not null);`),
+      ),
+    );
+    const tags = m.input["tags"] as shapes.ShapeArray;
+    expect(tags.type).toBe("array");
+    expect(tags.input.type).toBe("string");
+    const ints = m.input["ints"] as shapes.ShapeArray;
+    expect(ints.input.type).toBe("number");
+    expect((ints.input as shapes.ShapeNumber).tag).toBe("int32");
+  });
+
+  it("vector(N) → vector shape", () => {
+    const m = asMapping(
+      ok(fromSQL(`CREATE TABLE t (e vector(1536) not null);`)),
+    );
+    const v = m.input["e"] as shapes.ShapeVector;
+    expect(v.type).toBe("vector");
+    expect(v.input.dims).toBe(1536);
+  });
+});
+
+describe("fromSQL — CREATE TYPE / DOMAIN", (it) => {
+  it("ENUM resolved to union of literals + title", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TYPE color AS ENUM ('red','green','blue');
+        CREATE TABLE t (c color not null);
+      `),
+      ),
+    );
+    const u = m.input["c"] as shapes.ShapeUnion;
+    expect(u.type).toBe("union");
+    expect(u.anno.title).toBe("color");
+    const vals = (u.input as shapes.Shape[]).map(
+      (v) => (v as shapes.ShapeString).input,
+    );
+    expect(vals).toEqual(["red", "green", "blue"]);
+  });
+
+  it("schema-qualified ENUM", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE SCHEMA shop;
+        CREATE TYPE shop.status AS ENUM ('a','b');
+        CREATE TABLE shop.t (s shop.status not null);
+      `),
+      ),
+    );
+    expect(m.anno.schema).toBe("shop");
+    const u = m.input["s"] as shapes.ShapeUnion;
+    expect(u.anno.title).toBe("status");
+    expect(u.anno.schema).toBe("shop");
+  });
+
+  it("DOMAIN folds pattern from CHECK", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE DOMAIN email AS text CHECK (VALUE ~ '^[A-Z]+$');
+        CREATE TABLE t (e email not null);
+      `),
+      ),
+    );
+    expect(m.input["e"]!.type).toBe("string");
+    expect(m.input["e"]!.anno.format).toBe("pgtype:email");
+    // Pattern from the domain check (the value~ pattern lands as a pattern)
+    expect(m.input["e"]!.anno.pattern).toBe("^[A-Z]+$");
+  });
+});
+
+describe("fromSQL — constraints", (it) => {
+  it("composite primary key (table-level)", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          primary key (a, b)
+        );
+      `),
+      ),
+    );
+    expect(m.input["a"]!.anno.primary).toBe(true);
+    expect(m.input["b"]!.anno.primary).toBe(true);
+  });
+
+  it("column-level UNIQUE", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`CREATE TABLE t (id integer primary key, email text unique);`),
+      ),
+    );
+    expect(m.input["email"]!.anno.unique).toBe(true);
+  });
+
+  it("table-level single-col UNIQUE", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(
+          `CREATE TABLE t (id integer primary key, email text not null, unique (email));`,
+        ),
+      ),
+    );
+    expect(m.input["email"]!.anno.unique).toBe(true);
+  });
+
+  it("multi-col UNIQUE (bare) lands on mapping anno", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          unique (a, b)
+        );
+      `),
+      ),
+    );
+    expect(m.anno.uniqueConstraints).toEqual([{ columns: ["a", "b"] }]);
+    expect(m.input["a"]!.anno.unique).not.toBe(true);
+    expect(m.input["b"]!.anno.unique).not.toBe(true);
+  });
+
+  it("multi-col UNIQUE with named CONSTRAINT preserves name", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          constraint uniq_ab unique (a, b)
+        );
+      `),
+      ),
+    );
+    expect(m.anno.uniqueConstraints).toEqual([
+      { columns: ["a", "b"], name: "uniq_ab" },
+    ]);
+  });
+
+  it("multi-col UNIQUE round-trips through toSQL → fromSQL", () => {
+    const m1 = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          c integer not null,
+          constraint uniq_ab unique (a, b),
+          unique (b, c)
+        );
+      `),
+      ),
+    );
+    const sqlRes = toSQL(m1);
+    if (!R.isOk(sqlRes)) throw new Error(sqlRes.error.join("; "));
+    const m2 = asMapping(ok(fromSQL(sqlRes.value)));
+    expect(m2.anno.uniqueConstraints).toEqual(m1.anno.uniqueConstraints);
+  });
+});
+
+describe("fromSQL — multi-table", (it) => {
+  it("two tables → module", () => {
+    const mod = asModule(
+      ok(
+        fromSQL(`
+        CREATE TABLE u (id integer primary key);
+        CREATE TABLE t (
+          uid integer not null references u(id) on delete cascade
+        );
+      `),
+      ),
+    );
+    expect(Object.keys(mod.input).sort()).toEqual(["t", "u"]);
+    const t = mod.input["t"]!;
+    const uid = t.input["uid"]!;
+    expect(uid.anno.foreign).toEqual({
+      table: "u",
+      column: "id",
+      onDelete: "cascade",
+    });
+  });
+
+  it("multi-col FK decomposes to per-column foreign", () => {
+    const mod = asModule(
+      ok(
+        fromSQL(`
+        CREATE TABLE parent (
+          id uuid not null,
+          created_at timestamptz not null,
+          primary key (id, created_at)
+        );
+        CREATE TABLE child (
+          pid uuid not null,
+          pcreated timestamptz not null,
+          foreign key (pid, pcreated) references parent(id, created_at) on delete cascade
+        );
+      `),
+      ),
+    );
+    const child = mod.input["child"]!;
+    expect(child.input["pid"]!.anno.foreign).toEqual({
+      table: "parent",
+      column: "id",
+      onDelete: "cascade",
+    });
+    expect(child.input["pcreated"]!.anno.foreign).toEqual({
+      table: "parent",
+      column: "created_at",
+      onDelete: "cascade",
+    });
+  });
+});
+
+describe("fromSQL — defaults", (it) => {
+  it("literal defaults are decoded; expressions preserved", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a text not null default 'hello',
+          b integer not null default 42,
+          c boolean not null default true,
+          d uuid not null default uuid_generate_v4(),
+          e timestamptz not null default CURRENT_TIMESTAMP,
+          f jsonb not null default '{}'::jsonb
+        );
+      `),
+      ),
+    );
+    expect(m.input["a"]!.anno.default).toBe("hello");
+    expect(m.input["b"]!.anno.default).toBe(42);
+    expect(m.input["c"]!.anno.default).toBe(true);
+    expect(m.input["d"]!.anno.defaultExpr).toBe("UUID_GENERATE_V4 ( )");
+    expect(m.input["e"]!.anno.defaultExpr).toBe("CURRENT_TIMESTAMP");
+    expect(m.input["f"]!.anno.default).toEqual({});
+  });
+});
+
+describe("fromSQL — CHECK decoding", (it) => {
+  it("char_length / cardinality / pattern / IN", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          name text not null check (char_length(name) >= 3),
+          tags text[] not null check (cardinality(tags) <= 5),
+          ssn text not null check (ssn ~ '^[0-9]+$'),
+          color text not null check (color in ('red','blue'))
+        );
+      `),
+      ),
+    );
+    expect(m.input["name"]!.anno.min).toBe(3);
+    expect(m.input["tags"]!.anno.max).toBe(5);
+    expect(m.input["ssn"]!.anno.pattern).toBe("^[0-9]+$");
+    expect(m.input["color"]!.type).toBe("union");
+    const u = m.input["color"] as shapes.ShapeUnion;
+    expect((u.input as shapes.Shape[]).map((x) => (x as any).input)).toEqual([
+      "red",
+      "blue",
+    ]);
+  });
+
+  it("BETWEEN decoded", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          r integer not null check (r between 1 and 5)
+        );
+      `),
+      ),
+    );
+    expect(m.input["r"]!.anno.min).toBe(1);
+    expect(m.input["r"]!.anno.max).toBe(5);
+  });
+
+  it("opaque CHECK preserved as raw", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          check (a + b > 0)
+        );
+      `),
+      ),
+    );
+    expect(m.anno.check).toBeDefined();
+  });
+
+  it("IS NULL OR pattern is peeled", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          dob date,
+          phone text check (phone is null or phone ~ '^\\+?[0-9]+$')
+        );
+      `),
+      ),
+    );
+    expect(m.input["phone"]!.anno.pattern).toBe("^\\+?[0-9]+$");
+  });
+});
+
+describe("fromSQL — GENERATED columns", (it) => {
+  it("GENERATED ALWAYS AS (...) STORED", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          c integer generated always as (a + b) stored
+        );
+      `),
+      ),
+    );
+    expect(m.input["c"]!.anno.generated).toEqual({
+      expression: "a + b",
+      stored: true,
+    });
+  });
+
+  it("GENERATED ALWAYS AS IDENTITY → autoIncrement", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (id integer generated always as identity primary key);
+      `),
+      ),
+    );
+    expect(m.input["id"]!.anno.autoIncrement).toBe(true);
+    expect(m.input["id"]!.anno.primary).toBe(true);
+  });
+});
+
+describe("fromSQL — TSTZRANGE", (it) => {
+  it("tstzrange → range(date())", () => {
+    const m = asMapping(
+      ok(fromSQL(`CREATE TABLE t (during tstzrange not null);`)),
+    );
+    const r = m.input["during"] as shapes.ShapeRange;
+    expect(r.type).toBe("range");
+    expect(r.input.type).toBe("date");
+    expect(r.anno.format).toBe("pgtype:tstzrange");
+  });
+});
+
+describe("fromSQL — skip-able statements", (it) => {
+  it("ignores INDEX / TRIGGER / VIEW / INSERT / EXTENSION / SCHEMA / FUNCTION", () => {
+    const m = asMapping(
+      ok(
+        fromSQL(`
+        CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+        CREATE SCHEMA IF NOT EXISTS s;
+        CREATE TABLE t (id integer primary key);
+        CREATE INDEX t_idx ON t(id);
+        CREATE OR REPLACE FUNCTION foo() RETURNS integer LANGUAGE sql AS $$ SELECT 1; $$;
+        CREATE TRIGGER tr BEFORE UPDATE ON t FOR EACH ROW EXECUTE FUNCTION foo();
+        CREATE VIEW v AS SELECT * FROM t;
+        CREATE MATERIALIZED VIEW mv AS SELECT * FROM t WITH NO DATA;
+        ALTER TABLE t ENABLE ROW LEVEL SECURITY;
+        CREATE POLICY p ON t FOR SELECT USING (true);
+        INSERT INTO t (id) VALUES (1);
+      `),
+      ),
+    );
+    expect(m.anno.title).toBe("t");
+    expect(Object.keys(m.input)).toEqual(["id"]);
+  });
+
+  it("PARTITION OF children skipped; parent with PARTITION BY parsed", () => {
+    const mod = asModule(
+      ok(
+        fromSQL(`
+        CREATE TABLE orders (
+          id uuid not null,
+          created_at timestamptz not null,
+          primary key (id, created_at)
+        ) PARTITION BY RANGE (created_at);
+        CREATE TABLE orders_2025 PARTITION OF orders FOR VALUES FROM ('2025-01-01') TO ('2026-01-01');
+        CREATE TABLE other (id integer primary key);
+      `),
+      ),
+    );
+    expect(Object.keys(mod.input).sort()).toEqual(["orders", "other"]);
+    expect(mod.input["orders"]!.input["id"]!.anno.primary).toBe(true);
+  });
+});
+
+describe("fromSQL — schema qualifier", (it) => {
+  it("CREATE TABLE shop.users → title=users, schema=shop", () => {
+    const m = asMapping(
+      ok(fromSQL(`CREATE TABLE shop.users (id integer primary key);`)),
+    );
+    expect(m.anno.title).toBe("users");
+    expect(m.anno.schema).toBe("shop");
+  });
+});
+
+describe("fromSQL — ecommerce.sql fixture", (it) => {
+  const fixturePath = join(
+    process.cwd(),
+    "..",
+    "..",
+    "test-data",
+    "sql",
+    "ecommerce.sql",
+  );
+
+  it("parses successfully and produces expected tables", () => {
+    const sql = readFileSync(fixturePath, "utf8");
+    const result = fromSQL(sql);
+    if (!R.isOk(result)) {
+      throw new Error(`fromSQL failed: ${result.error.join("\n")}`);
+    }
+    const mod = asModule(result.value);
+    const expected = [
+      "users",
+      "addresses",
+      "vendors",
+      "categories",
+      "products",
+      "product_variants",
+      "inventory_movements",
+      "carts",
+      "cart_items",
+      "orders",
+      "order_items",
+      "payments",
+      "reviews",
+      "wishlists",
+      "coupons",
+      "promotions",
+      "event_log",
+    ];
+    for (const name of expected) {
+      expect(
+        Object.keys(mod.input).includes(name),
+        `missing table ${name}`,
+      ).toBe(true);
+    }
+    // orders_2024/5/6 should NOT be present (skipped partition children)
+    expect(Object.keys(mod.input).includes("orders_2024")).toBe(false);
+
+    // Spot-check users
+    const users = mod.input["users"]!;
+    expect(users.anno.schema).toBe("shop");
+    expect(users.input["email"]!.type).toBe("string");
+    // email is a domain — pattern from domain CHECK
+    expect(users.input["email"]!.anno.format).toBe("pgtype:shop.email");
+    // is_active should have default true
+    expect(users.input["is_active"]!.anno.default).toBe(true);
+
+    // FK in addresses with onDelete cascade
+    const addrs = mod.input["addresses"]!;
+    expect(addrs.input["user_id"]!.anno.foreign).toEqual({
+      table: "users",
+      column: "id",
+      onDelete: "cascade",
+    });
+
+    // products.search_doc should be a generated column
+    const products = mod.input["products"]!;
+    expect(products.input["search_doc"]!.anno.generated).toBeDefined();
+  });
+
+  it("toSQL round-trip emits something that re-parses to the same table count", () => {
+    const sql = readFileSync(fixturePath, "utf8");
+    const first = fromSQL(sql);
+    if (!R.isOk(first)) throw new Error(first.error.join("; "));
+    const emitted = toSQL(first.value);
+    if (!R.isOk(emitted))
+      throw new Error(`toSQL failed: ${emitted.error.join("; ")}`);
+    const second = fromSQL(emitted.value);
+    if (!R.isOk(second))
+      throw new Error(`re-parse failed: ${second.error.join("; ")}`);
+    const a = asModule(first.value);
+    const b = asModule(second.value);
+    expect(Object.keys(b.input).sort()).toEqual(Object.keys(a.input).sort());
+  });
+});
+
+describe("toSQL — new annotation emission", (it) => {
+  it("ON DELETE CASCADE in REFERENCES", () => {
+    const shape = ok(
+      fromSQL(`CREATE TABLE u (id integer primary key);
+                   CREATE TABLE t (uid integer not null references u(id) on delete cascade);
+                   `),
+    );
+    const out = toSQL(shape);
+    if (!R.isOk(out)) throw new Error(out.error.join("; "));
+    expect(out.value).toContain('REFERENCES "u"("id") ON DELETE CASCADE');
+  });
+
+  it("schema prefix on table name + CREATE SCHEMA prelude", () => {
+    const out = toSQL(
+      ok(
+        fromSQL(`
+        CREATE TABLE s.t (id integer primary key);
+        CREATE TABLE other (id integer primary key);
+      `),
+      ),
+    );
+    if (!R.isOk(out)) throw new Error(out.error.join("; "));
+    expect(out.value).toContain('CREATE SCHEMA IF NOT EXISTS "s"');
+    expect(out.value).toContain('CREATE TABLE IF NOT EXISTS "s"."t"');
+  });
+
+  it("defaultExpr is emitted verbatim", () => {
+    const out = toSQL(
+      ok(
+        fromSQL(
+          `CREATE TABLE t (id uuid not null default uuid_generate_v4() primary key);`,
+        ),
+      ),
+    );
+    if (!R.isOk(out)) throw new Error(out.error.join("; "));
+    expect(out.value).toContain("DEFAULT UUID_GENERATE_V4 ( )");
+  });
+
+  it("raw CHECK at mapping level", () => {
+    const out = toSQL(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          check (a + b > 0)
+        );
+      `),
+      ),
+    );
+    if (!R.isOk(out)) throw new Error(out.error.join("; "));
+    expect(out.value).toContain("CHECK (a + b > 0)");
+  });
+
+  it("GENERATED ALWAYS AS (...) STORED is re-emitted", () => {
+    const out = toSQL(
+      ok(
+        fromSQL(`
+        CREATE TABLE t (
+          a integer not null,
+          b integer not null,
+          c integer generated always as (a + b) stored
+        );
+      `),
+      ),
+    );
+    if (!R.isOk(out)) throw new Error(out.error.join("; "));
+    expect(out.value).toContain("GENERATED ALWAYS AS (a + b) STORED");
+  });
+});