cogsbox-shape 0.5.193 → 0.5.195

package/dist/vitest/generateSQL.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vitest/generateSQL.test.js

@@ -0,0 +1,70 @@
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { describe, expect, it } from "vitest";
+import { generateSQL } from "../generateSQL.js";
+import { s, schema } from "../schema.js";
+async function withOutputFile(fn) {
+    const dir = await mkdtemp(join(tmpdir(), "cogsbox-shape-sql-"));
+    try {
+        return await fn(join(dir, "schema.sql"));
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+describe("generateSQL dialect columns", () => {
+    it("generates SQLite enum columns as text with a check constraint", async () => {
+        const posts = schema({
+            _tableName: "posts",
+            id: s.sqlite({ type: "int", pk: true }),
+            status: s.sqlite({
+                type: "enum",
+                values: ["draft", "published", "archived"],
+                default: "draft",
+            }),
+        });
+        const sql = await withOutputFile((path) => generateSQL({ posts }, path));
+        expect(sql).toContain("id INTEGER PRIMARY KEY");
+        expect(sql).toContain("status TEXT NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived'))");
+    });
+    it("generates MySQL enum columns using native ENUM", async () => {
+        const posts = schema({
+            _tableName: "posts",
+            id: s.mysql({ type: "int", pk: true }),
+            status: s.mysql({
+                type: "enum",
+                values: ["draft", "published", "archived"],
+            }),
+        });
+        const sql = await withOutputFile((path) => generateSQL({ posts }, path));
+        expect(sql).toContain("id INTEGER PRIMARY KEY AUTO_INCREMENT");
+        expect(sql).toContain("status ENUM('draft', 'published', 'archived') NOT NULL");
+    });
+    it("generates Postgres enum type DDL before table DDL", async () => {
+        const posts = schema({
+            _tableName: "posts",
+            id: s.postgres({ type: "int", pk: true }),
+            status: s.postgres({
+                type: "enum",
+                name: "post_status",
+                values: ["draft", "published", "archived"],
+            }),
+        });
+        const sql = await withOutputFile((path) => generateSQL({ posts }, path));
+        expect(sql).toContain("CREATE TYPE post_status AS ENUM ('draft', 'published', 'archived');");
+        expect(sql).toContain("status post_status NOT NULL");
+        expect(sql.indexOf("CREATE TYPE post_status")).toBeLessThan(sql.indexOf("CREATE TABLE posts"));
+    });
+    it("rejects mixed SQL dialects in the same table", async () => {
+        const posts = schema({
+            _tableName: "posts",
+            id: s.sqlite({ type: "int", pk: true }),
+            status: s.mysql({
+                type: "enum",
+                values: ["draft", "published"],
+            }),
+        });
+        await expect(withOutputFile((path) => generateSQL({ posts }, path))).rejects.toThrow(/Mixed SQL dialects/);
+    });
+});

package/dist/vitest/packageExports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vitest/packageExports.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+describe("package exports", () => {
+    it("exposes the root cogsbox-shape entry at runtime", async () => {
+        const pkg = await import("cogsbox-shape");
+        expect(pkg.s).toBeDefined();
+        expect(pkg.schema).toBeDefined();
+        expect(pkg.createSchemaBox).toBeDefined();
+    });
+    it("exposes db subpath entries at runtime", async () => {
+        const dbPkg = await import("cogsbox-shape/db");
+        const sqlitePkg = await import("cogsbox-shape/db/sqlite");
+        expect(dbPkg.connect).toBeDefined();
+        expect(sqlitePkg.createSqliteDb).toBeDefined();
+    });
+});

package/dist/vitest/refineRuntime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vitest/refineRuntime.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import z from "zod";
+import { s, schema, createSchemaBox } from "../schema.js";
+describe("refine runtime behavior", () => {
+    function makeRefinedBox() {
+        const rules = schema({
+            _tableName: "rules",
+            id: s.sqlite({ type: "int", pk: true }),
+            min: s.sqlite({ type: "int", nullable: true }).clientInput({ value: null, schema: z.number().nullable() }),
+            max: s.sqlite({ type: "int", nullable: true }).clientInput({ value: null, schema: z.number().nullable() }),
+            label: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+        }).refine({
+            client: (row) => {
+                if (row.min !== null && row.max !== null && row.min >= row.max) {
+                    return { path: ["max"], message: "Max must be > min" };
+                }
+                return undefined;
+            },
+            server: (row) => {
+                if (row.min !== null && row.max !== null && row.min >= row.max) {
+                    return { path: ["max"], message: "Max must be > min" };
+                }
+                if (!row.label) {
+                    return { path: ["label"], message: "Label required" };
+                }
+                return undefined;
+            },
+        });
+        return createSchemaBox({ rules }, { rules: {} });
+    }
+    it("schemas.clientInput catches client refine", () => {
+        const box = makeRefinedBox();
+        const good = box.rules.schemas.clientInput.safeParse({ id: 1, min: 1, max: 10, label: "x" });
+        expect(good.success).toBe(true);
+        const bad = box.rules.schemas.clientInput.safeParse({ id: 1, min: 10, max: 1, label: "x" });
+        expect(bad.success).toBe(false);
+        if (!bad.success) {
+            expect(bad.error.issues[0].message).toBe("Max must be > min");
+        }
+    });
+    it("schemas.client catches client refine", () => {
+        const box = makeRefinedBox();
+        const bad = box.rules.schemas.client.safeParse({ id: 1, min: 10, max: 1, label: "x" });
+        expect(bad.success).toBe(false);
+        if (!bad.success) {
+            expect(bad.error.issues[0].message).toBe("Max must be > min");
+        }
+    });
+    it("schemas.server catches server refine", () => {
+        const box = makeRefinedBox();
+        const bad = box.rules.schemas.server.safeParse({ id: 1, min: 1, max: 10, label: "" });
+        expect(bad.success).toBe(false);
+        if (!bad.success) {
+            expect(bad.error.issues[0].message).toBe("Label required");
+        }
+    });
+    it("schemas.sql catches server refine", () => {
+        const box = makeRefinedBox();
+        const bad = box.rules.schemas.sql.safeParse({ id: 1, min: 1, max: 10, label: "" });
+        expect(bad.success).toBe(false);
+        if (!bad.success) {
+            expect(bad.error.issues[0].message).toBe("Label required");
+        }
+    });
+    it("parseForDb rejects invalid data via server refine", () => {
+        const box = makeRefinedBox();
+        expect(() => box.rules.transforms.parseForDb({ id: 1, min: 10, max: 1, label: "" })).toThrow();
+    });
+    it("parseFromDb rejects invalid DB data via server refine", () => {
+        const box = makeRefinedBox();
+        expect(() => box.rules.transforms.parseFromDb({ id: 1, min: 1, max: 10, label: "" })).toThrow("Label required");
+    });
+    it("parsePatchForDb does NOT run refine (uses partial base)", () => {
+        const box = makeRefinedBox();
+        expect(() => box.rules.transforms.parsePatchForDb({ min: 10, max: 1 })).not.toThrow();
+    });
+    it("unrefined box has no refine on any schema", () => {
+        const rules = schema({
+            _tableName: "rules",
+            id: s.sqlite({ type: "int", pk: true }),
+            min: s.sqlite({ type: "int", nullable: true }).clientInput({ value: null, schema: z.number().nullable() }),
+            max: s.sqlite({ type: "int", nullable: true }).clientInput({ value: null, schema: z.number().nullable() }),
+        });
+        const box = createSchemaBox({ rules }, { rules: {} });
+        const good = box.rules.schemas.clientInput.safeParse({ id: 1, min: 10, max: 1 });
+        expect(good.success).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.193",
+  "version": "0.5.195",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
     "test": "vitest  ",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p src/vitest/tsconfig.json",
     "playground": "pnpm --filter cogsbox-shape-playground dev"
   },
   "bin": {