@helloleo/runtime 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helloleo/runtime",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "authors": [
     "Herbie Vine <herbie@terros>"
   ],

package/src/cf-shim.ts

@@ -17,6 +17,8 @@ import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync }
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { createClient } from "@libsql/client";
+import { is, SQL } from "drizzle-orm";
+import { getTableConfig, SQLiteSyncDialect, SQLiteTable } from "drizzle-orm/sqlite-core";
 
 // ---- D1 (libsql) ------------------------------------------------------
 //
@@ -28,14 +30,66 @@ import { createClient } from "@libsql/client";
 const dbFile = process.env.DEV_DB_PATH ?? ".dev.db";
 const client = createClient({ url: `file:${dbFile}` });
 
-// Apply schema.sql on boot if present, so a query in a route loader never hits
-// "no such table" on a fresh sandbox.
+// `ready` gates every D1 query: the dev tables must exist before the first
+// loader query runs. Two ways to populate them, both funnelled through here:
+//   1. createDb(schema) → __pushSchema(schema): generate CREATE TABLE from the
+//      drizzle schema (the single source of truth — no schema.sql to drift).
+//   2. legacy schema.sql, applied on boot if present (kept for back-compat).
+let ready: Promise<void> = Promise.resolve();
+
+// Apply legacy schema.sql on boot if present.
 if (existsSync("schema.sql")) {
-  try {
-    await client.executeMultiple(readFileSync("schema.sql", "utf-8"));
-  } catch (e) {
-    console.error("[cf-shim] failed to apply schema.sql:", e);
-  }
+  ready = ready
+    .then(() => client.executeMultiple(readFileSync("schema.sql", "utf-8")))
+    .then(() => undefined)
+    .catch((e) => console.error("[cf-shim] failed to apply schema.sql:", e));
+}
+
+// Generate `CREATE TABLE IF NOT EXISTS` from a drizzle sqlite table. Covers the
+// common scaffold cases: column types, single/composite primary keys,
+// autoincrement, NOT NULL, and literal/SQL defaults. Indexes, FKs and unique
+// constraints are out of scope (dev convenience, not a migration engine).
+const dialect = new SQLiteSyncDialect();
+
+function tableDDL(table: SQLiteTable): string {
+  const cfg = getTableConfig(table);
+  const pkCols = cfg.primaryKeys[0]?.columns?.map((c) => c.name) ?? [];
+  const compositePk = pkCols.length > 1;
+
+  const cols = cfg.columns.map((col) => {
+    const parts = [`"${col.name}"`, col.getSQLType()];
+    if (!compositePk && col.primary) {
+      parts.push("PRIMARY KEY");
+      // autoIncrement only exists on integer columns.
+      if ((col as { autoIncrement?: boolean }).autoIncrement) parts.push("AUTOINCREMENT");
+    } else if (col.notNull) {
+      parts.push("NOT NULL");
+    }
+    if (col.hasDefault && col.default !== undefined) {
+      const d = col.default;
+      const rendered = is(d, SQL)
+        ? dialect.sqlToQuery(d).sql
+        : typeof d === "string"
+          ? `'${d.replace(/'/g, "''")}'`
+          : typeof d === "boolean"
+            ? d ? "1" : "0"
+            : String(d);
+      parts.push(`DEFAULT ${rendered}`);
+    }
+    return parts.join(" ");
+  });
+
+  if (compositePk) cols.push(`PRIMARY KEY (${pkCols.map((c) => `"${c}"`).join(", ")})`);
+  return `CREATE TABLE IF NOT EXISTS "${cfg.name}" (${cols.join(", ")});`;
+}
+
+function pushDrizzleSchema(schema: Record<string, unknown>): Promise<void> {
+  const tables = Object.values(schema).filter((v): v is SQLiteTable => is(v, SQLiteTable));
+  const ddl = tables.map(tableDDL).join("\n");
+  if (!ddl) return Promise.resolve();
+  return client.executeMultiple(ddl).catch((e) => {
+    console.error("[cf-shim] failed to push drizzle schema:", e);
+  });
 }
 
 // Minimal D1Database surface over libsql. Covers what drizzle-orm/d1 calls:
@@ -46,16 +100,19 @@ function makeD1() {
       const args = params as Array<string | number | bigint | boolean | null | Uint8Array>;
       return {
         async all<T = unknown>() {
+          await ready;
           const r = await client.execute({ sql, args });
           return { results: r.rows as unknown as T[], success: true, meta: {} };
         },
         async first<T = unknown>(col?: string) {
+          await ready;
           const r = await client.execute({ sql, args });
           const row = r.rows[0] as Record<string, unknown> | undefined;
           if (!row) return null;
           return (col ? row[col] : row) as T;
         },
         async run() {
+          await ready;
           const r = await client.execute({ sql, args });
           return {
             success: true,
@@ -67,6 +124,7 @@ function makeD1() {
           };
         },
         async raw<T = unknown[]>() {
+          await ready;
           const r = await client.execute({ sql, args });
           return r.rows.map((row) =>
             r.columns.map((c) => (row as Record<string, unknown>)[c]),
@@ -84,9 +142,16 @@ function makeD1() {
       return out;
     },
     async exec(sql: string) {
+      await ready;
       await client.executeMultiple(sql);
       return { count: 0, duration: 0 };
     },
+    // DEV-ONLY hook: createDb(schema) calls this so the drizzle schema is the
+    // single source of truth for the local tables. Chained into `ready` so
+    // queries wait for the tables. No-op shape in prod (real D1 lacks it).
+    __pushSchema(schema: Record<string, unknown>) {
+      ready = ready.then(() => pushDrizzleSchema(schema));
+    },
   };
 }
 

package/src/index.ts

@@ -26,8 +26,21 @@ export const db = lazy(() => drizzle(env.DB));
 // Typed Drizzle client bound to an app schema (enables `db.query.*` relational
 // queries + full inference). Still lazy, so safe to call at app module scope.
 //
+//   import * as schema from "./db/schema";
 //   export const db = createDb(schema);
+//
+// DEV BONUS: the drizzle schema is the single source of truth for the dev
+// tables. In the sandbox shim we push CREATE TABLE straight from `schema` —
+// no schema.sql to hand-maintain and drift. Gated on __TARGET__ so prod
+// (workerd) never touches `env` at module scope (it would crash at isolate
+// boot); there the real D1 binding has no __pushSchema and migrations run at
+// deploy instead.
+declare const __TARGET__: "workerd" | "sandbox" | undefined;
+
 export function createDb<TSchema extends Record<string, unknown>>(schema: TSchema) {
+  if (typeof __TARGET__ !== "undefined" && __TARGET__ === "sandbox") {
+    (env.DB as { __pushSchema?: (s: TSchema) => void }).__pushSchema?.(schema);
+  }
   return lazy(() => drizzle(env.DB, { schema }));
 }