@suluk/drizzle 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suluk/drizzle",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Drizzle ORM schema -> v4 'Suluk' contract: table -> Zod (drizzle-zod) -> v4 Schema Objects, DB metadata, and generated CRUD RouteContracts. CANDIDATE tooling.",
   "publishConfig": {
   "access": "public"
@@ -19,7 +19,7 @@
 ".": "./src/index.ts"
 },
 "dependencies": {
-"@suluk/core": "^0.1.7",
+"@suluk/core": "^0.1.11",
 "@suluk/zod": "^0.1.2",
 "@suluk/hono": "^0.1.2"
 },

package/src/ddl.ts

@@ -0,0 +1,50 @@
+/**
+ * Emit SQLite `CREATE TABLE` DDL from a drizzle table's {@link tableMetadata} — the generator that lets a dev
+ * in-memory bun:sqlite DB be built FROM the Drizzle schema instead of a hand-mirrored SQL string that silently
+ * drifts. Reads only the honest metadata floor (types, notNull, defaults, PK/autoincrement); identifiers are
+ * quoted so reserved words (e.g. `order`) are safe. Booleans map to INTEGER (drizzle's storage), enums to plain
+ * TEXT (drizzle adds no CHECK). Prod migrations stay the source of truth for prod; this is the dev-schema twin.
+ */
+import { tableMetadata, type AnyTable, type ColumnMeta, type TableMeta } from "./meta";
+
+const SQLITE_TYPE: Record<string, string> = {
+  SQLiteInteger: "INTEGER", SQLiteBoolean: "INTEGER", SQLiteTimestamp: "INTEGER",
+  SQLiteText: "TEXT", SQLiteTextJson: "TEXT", SQLiteReal: "REAL", SQLiteNumeric: "NUMERIC", SQLiteBlob: "BLOB",
+};
+
+/** Double-quote an identifier (table/column) so reserved words + odd names are always safe. */
+const q = (id: string): string => `"${id.replace(/"/g, '""')}"`;
+/** A SQL literal for a static default: booleans → 0/1, numbers verbatim, strings single-quoted. */
+const lit = (v: string | number | boolean): string =>
+  typeof v === "boolean" ? (v ? "1" : "0") : typeof v === "number" ? String(v) : `'${String(v).replace(/'/g, "''")}'`;
+
+function columnDDL(c: ColumnMeta): string {
+  const parts = [q(c.sqlName), SQLITE_TYPE[c.columnType] ?? "TEXT"];
+  if (c.primaryKey) parts.push(c.autoIncrement ? "PRIMARY KEY AUTOINCREMENT" : "PRIMARY KEY");
+  else if (c.notNull) parts.push("NOT NULL");
+  if (c.defaultValue !== undefined) parts.push("DEFAULT " + lit(c.defaultValue));
+  return parts.join(" ");
+}
+
+export interface DdlOptions {
+  /** prefix with `IF NOT EXISTS` (default true). */
+  ifNotExists?: boolean;
+}
+
+/**
+ * `CREATE TABLE` DDL for one drizzle table (or its already-read metadata). Single-column primary keys only — a
+ * table-level composite `primaryKey({columns})` isn't visible on the column-descriptor floor (it needs
+ * dialect-specific `getTableConfig`, deferred like FK/relation projection); such a table emits its columns without
+ * the composite constraint, so declare those tables' DDL by hand for now.
+ */
+export function tableDDL(table: AnyTable | TableMeta, opts: DdlOptions = {}): string {
+  const m: TableMeta = "columns" in table ? table : tableMetadata(table);
+  const cols = m.columns.map(columnDDL).join(", ");
+  const exists = opts.ifNotExists === false ? "" : "IF NOT EXISTS ";
+  return `CREATE TABLE ${exists}${q(m.name)} (${cols});`;
+}
+
+/** `CREATE TABLE` DDL for many tables, newline-joined — the dev-schema twin of the prod migrations. */
+export function schemaDDL(tables: (AnyTable | TableMeta)[], opts: DdlOptions = {}): string {
+  return tables.map((t) => tableDDL(t, opts)).join("\n");
+}

package/src/index.ts

@@ -39,3 +39,5 @@ export {
   softDeleteValues, anonymizeValues, touchTimestamps, notSoftDeleted,
   type SoftDeleteOptions, type TimestampOptions,
 } from "./mutations";
+// SQLite CREATE TABLE generator — build a dev in-memory schema FROM the Drizzle tables (no hand-mirrored SQL drift).
+export { tableDDL, schemaDDL, type DdlOptions } from "./ddl";

package/src/meta.ts

@@ -12,7 +12,10 @@ export type AnyTable = Parameters<typeof getTableColumns>[0];
 
 /** One column's metadata, lifted from drizzle's column descriptor (verified against drizzle-orm 0.45). */
 export interface ColumnMeta {
+  /** the JS property key on the table object (e.g. `reviewId`) — the v4 component property name. */
   name: string;
+  /** the SQL column name (e.g. `review_id`) — what DDL + raw SQL must use; differs from `name` under camel/snake. */
+  sqlName: string;
   /** drizzle's coarse JS dataType, e.g. "string" | "number" | "boolean" | "date". */
   dataType: string;
   /** drizzle's concrete column type tag, e.g. "SQLiteText" | "SQLiteInteger". */
@@ -23,10 +26,15 @@ export interface ColumnMeta {
   hasDefault: boolean;
   /** Part of the (single-column) primary key. */
   primaryKey: boolean;
+  /** An AUTOINCREMENT primary key (SQLite integer PK declared with autoIncrement). */
+  autoIncrement: boolean;
   /** Carries a column-level UNIQUE constraint (drizzle's `.unique()` / `isUnique`). */
   unique: boolean;
   /** SQL CHECK/enum allowed values when the column was declared with `{ enum: [...] }`. */
   enumValues?: string[];
+  /** The STATIC default value (number/string/boolean) when the column carries one — for DDL emit. Absent for a
+   *  runtime `$defaultFn` column (hasDefault true, no SQL-literal value) and for autoincrement PKs. */
+  defaultValue?: string | number | boolean;
 }
 
 export interface TableMeta {
@@ -57,19 +65,26 @@ export function tableMetadata(table: AnyTable): TableMeta {
       notNull: boolean;
       hasDefault: boolean;
       primary: boolean;
+      autoIncrement?: boolean;
       isUnique?: boolean;
       enumValues?: string[];
+      default?: unknown;
+      name?: string;
     };
+    const staticDefault = c.hasDefault && (typeof c.default === "string" || typeof c.default === "number" || typeof c.default === "boolean");
     const meta: ColumnMeta = {
       name,
+      sqlName: c.name ?? name, // drizzle's column descriptor carries the SQL name; fall back to the JS key
       dataType: c.dataType,
       columnType: c.columnType,
       notNull: !!c.notNull,
       hasDefault: !!c.hasDefault,
       primaryKey: !!c.primary,
+      autoIncrement: !!c.autoIncrement,
       unique: !!c.isUnique,
       // enumValues is often an empty array on non-enum columns — only surface a non-empty one.
       ...(Array.isArray(c.enumValues) && c.enumValues.length ? { enumValues: c.enumValues } : {}),
+      ...(staticDefault ? { defaultValue: c.default as string | number | boolean } : {}),
     };
     columns.push(meta);
     if (meta.primaryKey) primaryKey.push(name);

package/test/ddl.test.ts

@@ -0,0 +1,56 @@
+/**
+ * tableDDL / schemaDDL — generate SQLite CREATE TABLE from a Drizzle table. Asserts the type/default/PK mapping,
+ * reserved-word quoting, AND the SQL-column-name (snake_case) vs JS-key (camelCase) distinction, then round-trips:
+ * the generated DDL runs in a real bun:sqlite DB and accepts inserts that honor the defaults — proof the schema is
+ * valid + faithful, not just string-shaped.
+ */
+import { test, expect, describe } from "bun:test";
+import { Database } from "bun:sqlite";
+import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
+import { tableDDL, schemaDDL } from "../src/index";
+
+// "order" is a SQLite reserved word; customer_id (camel JS key) exercises the SQL-name path; boolean+enum+defaults the mapping.
+const order = sqliteTable("order", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  customerId: text("customer_id"),                                  // camelCase key → snake_case SQL name
+  total: integer("total").notNull().default(0),
+  status: text("status", { enum: ["pending", "paid"] }).notNull().default("pending"),
+  paid: integer("paid", { mode: "boolean" }).notNull().default(false),
+  note: text("note"),
+});
+
+describe("tableDDL", () => {
+  const ddl = tableDDL(order);
+  test("quotes reserved table names + maps types + uses the SQL column name", () => {
+    expect(ddl).toContain('CREATE TABLE IF NOT EXISTS "order"');
+    expect(ddl).toContain('"customer_id" TEXT');   // SQL name, not the JS key "customerId"
+    expect(ddl).not.toContain("customerId");
+    expect(ddl).toContain('"total" INTEGER NOT NULL DEFAULT 0');
+    expect(ddl).toContain('"note" TEXT');           // nullable, no default
+    expect(ddl).not.toContain('"note" TEXT NOT NULL');
+  });
+  test("autoincrement PK, boolean→INTEGER 0/1, string defaults quoted", () => {
+    expect(ddl).toContain('"id" INTEGER PRIMARY KEY AUTOINCREMENT');
+    expect(ddl).toContain('"paid" INTEGER NOT NULL DEFAULT 0');     // boolean false → 0, type INTEGER
+    expect(ddl).toContain(`"status" TEXT NOT NULL DEFAULT 'pending'`);
+  });
+  test("ifNotExists:false drops the guard", () => {
+    expect(tableDDL(order, { ifNotExists: false })).toContain('CREATE TABLE "order"');
+  });
+});
+
+describe("round-trip in a real bun:sqlite DB", () => {
+  test("the generated DDL is valid SQL + applies the defaults under the SQL column names", () => {
+    const db = new Database(":memory:");
+    db.exec(schemaDDL([order]));
+    db.exec(`INSERT INTO "order" (customer_id, note) VALUES ('u1', 'hi')`); // rely on total/status/paid defaults
+    const row = db.query(`SELECT id, customer_id, total, status, paid, note FROM "order"`).get() as Record<string, unknown>;
+    expect(row.id).toBe(1);              // autoincrement
+    expect(row.customer_id).toBe("u1");  // snake_case column exists
+    expect(row.total).toBe(0);           // default 0
+    expect(row.status).toBe("pending");  // default 'pending'
+    expect(row.paid).toBe(0);            // boolean default false → 0
+    expect(row.note).toBe("hi");
+    db.close();
+  });
+});