@shapecraft/core 1.0.0

package/src/shape/transforms/sql/transform.sqlite.test.ts

@@ -0,0 +1,448 @@
+import { describe, expect } from "vitest";
+import { R } from "../../../common/result";
+import { B } from "../../builder";
+import { annotate, shapes } from "../../shape";
+import { fromSQL } from "./from-sql";
+import { toSQL } from "./transform";
+
+const sqlite = { dialect: "sqlite" as const };
+
+const ok = (res: R.Result<string, string[]>): string => {
+  if (!R.isOk(res))
+    throw new Error(`expected ok, got err: ${res.error.join("; ")}`);
+  return res.value;
+};
+
+const err = (res: R.Result<string, string[]>): string[] => {
+  if (R.isOk(res)) throw new Error(`expected err, got ok: ${res.value}`);
+  return res.error;
+};
+
+describe("toSQL sqlite — basics", (it) => {
+  it("trails every CREATE TABLE with STRICT", () => {
+    const m = annotate.titled(shapes.mapping({ id: shapes.int32() }), "t");
+    expect(ok(toSQL(m, sqlite))).toContain(") STRICT;");
+  });
+
+  it("string max → TEXT + length CHECK (not varchar)", () => {
+    const m = annotate.titled(
+      shapes.mapping({ name: annotate.max(shapes.string(), 50) }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toBe(
+      'CREATE TABLE IF NOT EXISTS "t" (\n' +
+        '  "name" TEXT NOT NULL CHECK (length("name") <= 50)\n' +
+        ") STRICT;",
+    );
+  });
+
+  it("string min → length() check (not char_length)", () => {
+    const m = annotate.titled(
+      shapes.mapping({ name: annotate.min(shapes.string(), 1) }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain('length("name") >= 1');
+  });
+
+  it("string pattern → REGEXP operator", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        slug: annotate.pattern(shapes.string(), /^[a-z]+$/),
+      }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain("\"slug\" REGEXP '^[a-z]+$'");
+  });
+
+  it("boolean → INTEGER + CHECK IN (0,1)", () => {
+    const m = annotate.titled(
+      shapes.mapping({ active: shapes.boolean() }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain(
+      '"active" INTEGER NOT NULL CHECK ("active" IN (0, 1))',
+    );
+  });
+
+  it("boolean default → 1/0 (no TRUE/FALSE)", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        a: annotate.defaulted(shapes.boolean(), true),
+        b: annotate.defaulted(shapes.boolean(), false),
+      }),
+      "t",
+    );
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).toContain('"a" INTEGER NOT NULL DEFAULT 1');
+    expect(sql).toContain('"b" INTEGER NOT NULL DEFAULT 0');
+  });
+
+  it("int8 → INTEGER + range CHECKs", () => {
+    const m = annotate.titled(shapes.mapping({ x: shapes.int8() }), "t");
+    expect(ok(toSQL(m, sqlite))).toBe(
+      'CREATE TABLE IF NOT EXISTS "t" (\n' +
+        '  "x" INTEGER NOT NULL CHECK ("x" >= -128) CHECK ("x" <= 127)\n' +
+        ") STRICT;",
+    );
+  });
+
+  it("uint64 → INTEGER + >= 0 (range-lossy, no error)", () => {
+    const m = annotate.titled(shapes.mapping({ x: shapes.uint64() }), "t");
+    expect(ok(toSQL(m, sqlite))).toContain(
+      '"x" INTEGER NOT NULL CHECK ("x" >= 0)',
+    );
+  });
+
+  it("int64 → INTEGER (no range CHECKs)", () => {
+    const m = annotate.titled(shapes.mapping({ x: shapes.int64() }), "t");
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).not.toContain('CHECK ("x"');
+  });
+
+  it("float → REAL", () => {
+    const m = annotate.titled(shapes.mapping({ x: shapes.float() }), "t");
+    expect(ok(toSQL(m, sqlite))).toContain('"x" REAL NOT NULL');
+  });
+
+  it("date → TEXT (ISO 8601)", () => {
+    const m = annotate.titled(shapes.mapping({ t: shapes.date() }), "t");
+    expect(ok(toSQL(m, sqlite))).toContain('"t" TEXT NOT NULL');
+  });
+
+  it("binary → BLOB", () => {
+    const m = annotate.titled(shapes.mapping({ b: shapes.binary() }), "t");
+    expect(ok(toSQL(m, sqlite))).toContain('"b" BLOB NOT NULL');
+  });
+
+  it("unknown / mapping / record → TEXT + json_valid", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        u: shapes.unknown(),
+        m: shapes.mapping({ k: shapes.string() }),
+        r: shapes.record(shapes.string(), shapes.int()),
+      }),
+      "t",
+    );
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).toContain('"u" TEXT NOT NULL CHECK (json_valid("u"))');
+    expect(sql).toContain('"m" TEXT NOT NULL CHECK (json_valid("m"))');
+    expect(sql).toContain('"r" TEXT NOT NULL CHECK (json_valid("r"))');
+  });
+
+  it("tuple → TEXT + json_valid + array length check", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        p: shapes.tuple(shapes.float(), shapes.float()),
+      }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain(
+      'CHECK (json_valid("p") AND json_array_length("p") = 2)',
+    );
+  });
+
+  it("array → TEXT + json_valid + json_array_length min/max", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        xs: annotate.max(annotate.min(shapes.array(shapes.string()), 1), 20),
+      }),
+      "t",
+    );
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).toContain('"xs" TEXT NOT NULL CHECK (json_valid("xs"))');
+    expect(sql).toContain('CHECK (json_array_length("xs") <= 20)');
+    expect(sql).toContain('CHECK (json_array_length("xs") >= 1)');
+  });
+
+  it("array uniqueItems → inline json_each CHECK (no prelude function)", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        xs: annotate.as(shapes.array(shapes.string()), { uniqueItems: true }),
+      }),
+      "t",
+    );
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).toContain(
+      'CHECK ((SELECT COUNT(*) FROM json_each("xs")) = (SELECT COUNT(DISTINCT value) FROM json_each("xs")))',
+    );
+    // No prelude function emitted
+    expect(sql).not.toContain("CREATE OR REPLACE FUNCTION");
+    expect(sql).not.toContain("shapecraft_array_is_unique");
+  });
+
+  it("vector → BLOB + length check (sqlite-vec layout)", () => {
+    const m = annotate.titled(
+      shapes.mapping({ embedding: shapes.vector(384) }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain(
+      '"embedding" BLOB NOT NULL CHECK (length("embedding") = 1536)',
+    );
+  });
+
+  it("union of string literals → inline CHECK IN (no CREATE TYPE)", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        status: annotate.titled(
+          shapes.union(shapes.literal("draft"), shapes.literal("published")),
+          "Status",
+        ),
+      }),
+      "t",
+    );
+    const sql = ok(toSQL(m, sqlite));
+    expect(sql).not.toContain("CREATE TYPE");
+    expect(sql).toContain(
+      `"status" TEXT NOT NULL CHECK ("status" IN ('draft', 'published'))`,
+    );
+  });
+
+  it("autoIncrement + integer → INTEGER PRIMARY KEY AUTOINCREMENT", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        id: annotate.autoIncremented(annotate.primary(shapes.uint32())),
+      }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain(
+      '"id" INTEGER PRIMARY KEY AUTOINCREMENT',
+    );
+  });
+
+  it("autoIncrement auto-promotes to primary when not yet primary", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        id: annotate.autoIncremented(shapes.uint32()),
+      }),
+      "t",
+    );
+    expect(ok(toSQL(m, sqlite))).toContain(
+      '"id" INTEGER PRIMARY KEY AUTOINCREMENT',
+    );
+  });
+});
+
+describe("toSQL sqlite — errors", (it) => {
+  it("anno.schema → err", () => {
+    const m = annotate.as(
+      annotate.titled(shapes.mapping({ id: shapes.int32() }), "t"),
+      { schema: "public" },
+    );
+    expect(err(toSQL(m, sqlite))).toEqual([
+      "table 't': sqlite has no schemas; remove anno.schema or use dialect='postgres'",
+    ]);
+  });
+
+  it("autoIncrement on uint64 → err", () => {
+    const m = annotate.titled(
+      shapes.mapping({ x: annotate.autoIncremented(shapes.uint64()) }),
+      "t",
+    );
+    expect(err(toSQL(m, sqlite))).toEqual([
+      "field 'x': autoIncrement is not supported on uint64 in sqlite",
+    ]);
+  });
+
+  it("autoIncrement on non-integer → err", () => {
+    const m = annotate.titled(
+      shapes.mapping({ s: annotate.autoIncremented(shapes.string()) }),
+      "t",
+    );
+    expect(err(toSQL(m, sqlite))).toEqual([
+      "field 's': autoIncrement requires an integer type",
+    ]);
+  });
+
+  it("autoIncrement column conflicts with another primary col", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        id: annotate.autoIncremented(annotate.primary(shapes.int32())),
+        other: annotate.primary(shapes.string()),
+      }),
+      "t",
+    );
+    expect(err(toSQL(m, sqlite))[0]).toMatch(
+      /autoIncrement column 'id' must be the sole primary key/,
+    );
+  });
+});
+
+describe("toSQL sqlite — cross-dialect divergence", (it) => {
+  it("PG emits ENUM, SQLite emits inline CHECK", () => {
+    const m = annotate.titled(
+      shapes.mapping({
+        status: annotate.titled(
+          shapes.union(shapes.literal("a"), shapes.literal("b")),
+          "Status",
+        ),
+      }),
+      "t",
+    );
+    const pg = ok(toSQL(m));
+    const sl = ok(toSQL(m, sqlite));
+    expect(pg).toContain("CREATE TYPE");
+    expect(sl).not.toContain("CREATE TYPE");
+    expect(pg).not.toEqual(sl);
+  });
+
+  it("PG emits varchar(N), SQLite emits TEXT + length CHECK", () => {
+    const m = annotate.titled(
+      shapes.mapping({ name: annotate.max(shapes.string(), 50) }),
+      "t",
+    );
+    expect(ok(toSQL(m))).toContain("varchar(50)");
+    expect(ok(toSQL(m, sqlite))).toContain(
+      'TEXT NOT NULL CHECK (length("name") <= 50)',
+    );
+  });
+});
+
+describe("toSQL sqlite — round-trip", (it) => {
+  it("comprehensive table round-trips byte-equal", () => {
+    const Tag = B.mapping({
+      id: B.uint32().primary().autoIncrement(),
+      slug: B.string()
+        .regex(/^[a-z0-9-]+$/)
+        .unique(),
+      label: B.string().min(1).max(40),
+      tags: B.array(B.string()).max(20).uniqueItems(),
+      embedding: B.vector(384),
+      active: B.boolean().default(true),
+      metadata: B.mapping({ key: B.string() }).optional(),
+    }).title("Tag");
+
+    const emitted = ok(toSQL(Tag.shape, sqlite));
+    const parsed = fromSQL(emitted, sqlite);
+    if (!parsed.ok) throw new Error("parse failed: " + parsed.error.join("; "));
+    const reEmitted = ok(toSQL(parsed.value, sqlite));
+    expect(reEmitted).toBe(emitted);
+  });
+
+  it("module with FK + multi-table round-trips", () => {
+    const User = B.mapping({
+      id: B.uint32().primary().autoIncrement(),
+      email: B.string().unique(),
+    }).title("User");
+    const Post = B.mapping({
+      id: B.uint32().primary().autoIncrement(),
+      author: B.uint32().references(User, "id"),
+      title: B.string().min(1).max(200),
+      publishedAt: B.date().optional(),
+    }).title("Post");
+    const mod = B.module({ User, Post });
+
+    const emitted = ok(toSQL(mod.shape, sqlite));
+    const parsed = fromSQL(emitted, sqlite);
+    if (!parsed.ok) throw new Error("parse failed: " + parsed.error.join("; "));
+    const reEmitted = ok(toSQL(parsed.value, sqlite));
+    expect(reEmitted).toBe(emitted);
+  });
+});
+
+describe("fromSQL sqlite — parsing", (it) => {
+  it("INTEGER PRIMARY KEY AUTOINCREMENT → primary + autoIncrement on int64", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("id" INTEGER PRIMARY KEY AUTOINCREMENT) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    const id = m.input.id!;
+    expect(id.type).toBe("number");
+    expect((id as shapes.ShapeNumber).tag).toBe("int64");
+    expect(id.anno.primary).toBe(true);
+    expect(id.anno.autoIncrement).toBe(true);
+  });
+
+  it("INTEGER + CHECK IN (0,1) + DEFAULT 1 → boolean with default true", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("a" INTEGER NOT NULL DEFAULT 1 CHECK ("a" IN (0,1))) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    const a = m.input.a!;
+    expect(a.type).toBe("boolean");
+    expect(a.anno.default).toBe(true);
+  });
+
+  it("TEXT + json_valid + json_array_length(col) = N → tuple", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("p" TEXT NOT NULL CHECK (json_valid("p") AND json_array_length("p") = 2)) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.input.p!.type).toBe("tuple");
+  });
+
+  it("TEXT + json_valid only → unknown", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("u" TEXT NOT NULL CHECK (json_valid("u"))) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.input.u!.type).toBe("unknown");
+  });
+
+  it("TEXT + json_valid + array length CHECKs → array(unknown)", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("xs" TEXT NOT NULL CHECK (json_valid("xs")) CHECK (json_array_length("xs") <= 5)) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.input.xs!.type).toBe("array");
+    expect(m.input.xs!.anno.max).toBe(5);
+  });
+
+  it("backtick-quoted identifiers parse", () => {
+    const r = fromSQL(
+      "CREATE TABLE `t` (`id` INTEGER PRIMARY KEY, `name` TEXT) STRICT;",
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.anno.title).toBe("t");
+    expect(Object.keys(m.input)).toEqual(["id", "name"]);
+  });
+
+  it("WITHOUT ROWID is tolerated", () => {
+    const r = fromSQL(
+      `CREATE TABLE "t" ("id" INTEGER PRIMARY KEY) WITHOUT ROWID;`,
+      sqlite,
+    );
+    expect(r.ok).toBe(true);
+  });
+
+  it("main.<table> qualified name drops the database prefix", () => {
+    const r = fromSQL(
+      `CREATE TABLE main."t" ("id" INTEGER PRIMARY KEY) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.anno.title).toBe("t");
+    expect(m.anno.schema).toBeUndefined();
+  });
+
+  it("CREATE VIRTUAL TABLE is skipped without error", () => {
+    const r = fromSQL(
+      `CREATE VIRTUAL TABLE "vec_idx" USING vec0(embedding float[3]);` +
+        `\nCREATE TABLE "t" ("id" INTEGER PRIMARY KEY) STRICT;`,
+      sqlite,
+    );
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.anno.title).toBe("t");
+  });
+
+  it("varchar(N) → string with max", () => {
+    const r = fromSQL(`CREATE TABLE "t" ("s" VARCHAR(50)) STRICT;`, sqlite);
+    if (!r.ok) throw new Error(r.error.join("; "));
+    const m = r.value as shapes.ShapeMapping;
+    expect(m.input.s!.type).toBe("string");
+    expect(m.input.s!.anno.max).toBe(50);
+  });
+});