okengine 0.10.2 → 0.11.0

package/src/elements/store/resource.test.ts

@@ -6,11 +6,10 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import { Database } from "bun:sqlite";
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import { z } from "zod";
-import { sqliteDriver } from "../../drivers/sqlite.ts";
+import { pgliteDriver } from "../../drivers/pglite.ts";
 import { oke } from "../../kernel/app.ts";
 import { resetFlowSeq } from "../../kernel/flow.ts";
 import { on, resetBindings } from "../../kernel/on.ts";
@@ -26,7 +25,7 @@ afterEach(() => {
 });
 
 describe("mapRowToJs — declared keys only", () => {
-  const posts = sqliteTable("posts", {
+  const posts = pgTable("posts", {
     id: text("id").primaryKey(),
     createdAt: integer("created_at").notNull(),
   });
@@ -48,15 +47,15 @@ describe("mapRowToJs — declared keys only", () => {
 });
 
 describe("SqlStoreHandle exit — list/get/create return JS keys only", () => {
-  const posts = sqliteTable("posts", {
+  const posts = pgTable("posts", {
     id: text("id").primaryKey(),
     title: text("title").notNull(),
     createdAt: integer("created_at").notNull(),
   });
 
   test("select / findById / insert.returning never emit created_at", async () => {
-    const conn = await sqliteDriver.connect({
-      client: new Database(":memory:"),
+    const conn = await pgliteDriver.connect({
+      url: "memory://",
       role: "primary",
     });
     const handle = createSqlStoreHandle("sql:app", {
@@ -87,7 +86,7 @@ describe("SqlStoreHandle exit — list/get/create return JS keys only", () => {
 
 describe("resource HTTP — exact keys + PII with differing TS/SQL names", () => {
   // TS `email` ↔ SQL `email_addr`; TS `createdAt` ↔ SQL `created_at`.
-  const contacts = sqliteTable("contacts", {
+  const contacts = pgTable("contacts", {
     id: text("id").primaryKey().$defaultFn(id),
     email: text("email_addr").notNull(),
     createdAt: integer("created_at").notNull().$defaultFn(now),
@@ -122,7 +121,11 @@ describe("resource HTTP — exact keys + PII with differing TS/SQL names", () =>
 
     const mounted = on(http.resource("/contacts", contactsR.all()));
     const app = oke({ name: "contacts-resource-test" }).adopt({ contacts: mounted });
-    Object.assign(app.$options, { env: "test", stores: [db] });
+    Object.assign(app.$options, {
+      env: "test",
+      stores: [db],
+      config: { drivers: { store: { sql: { test: "pglite" } } } },
+    });
     return app;
   }
 
@@ -229,7 +232,11 @@ describe("resource HTTP — exact keys + PII with differing TS/SQL names", () =>
 
     const mounted = on(http.resource("/people", peopleR.all()));
     const app = oke({ name: "people-pii-test" }).adopt({ people: mounted });
-    Object.assign(app.$options, { env: "test", stores: [db] });
+    Object.assign(app.$options, {
+      env: "test",
+      stores: [db],
+      config: { drivers: { store: { sql: { test: "pglite" } } } },
+    });
 
     const t = await createTestApp(app);
     const created = await app.fetch(

package/src/elements/store/runtime.ts

@@ -158,7 +158,7 @@ export interface FilesStoreFxHandle {
 /** Vector index handle on `fx.store`. */
 export interface VectorIndexStoreFxHandle {
   readonly ref: `index:${string}`;
-  readonly driverId: "memory" | "pgvector" | "libsql";
+  readonly driverId: "memory" | "pgvector";
   upsert(id: string, vector: readonly number[], meta?: Record<string, unknown>): Promise<void>;
   search(
     vector: readonly number[],
@@ -290,7 +290,10 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
   async function openSql(decl: SqlStoreDecl, ctx: StoreInvokeContext): Promise<SqlStoreHandle> {
     const binding = options.sql?.[decl.name] ?? {
       name: decl.name,
-      primary: { url: ":memory:" },
+      // PGlite / postgres-shaped drivers persist under `.oke/`; the in-process
+      // `memory` SQL driver ignores `url`. Never use SQLite's `:memory:` here —
+      // PGlite treats that string as a filesystem path and creates `./:memory:`.
+      primary: { url: ".oke/pgdata" },
     };
     const target = resolveSqlTarget(binding, ctx.effects);
     const driver = options.drivers.sql;
@@ -327,7 +330,7 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
 
   /** SQL-backed index drivers borrow the sql facet's connection. */
   async function sqlConnForIndex(
-    driver: VectorIndexDriver & { id: "pgvector" | "libsql" },
+    driver: VectorIndexDriver & { id: "pgvector" },
     url: string | undefined,
   ): Promise<SqlConnection> {
     const sqlDriver = options.drivers.sql;
@@ -336,16 +339,10 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
         `oke store: index driver "${driver.id}" needs a configured sql driver to share its connection`,
       );
     }
-    const compatible =
-      driver.id === "pgvector"
-        ? sqlDriver.id === "postgres" || sqlDriver.id === "pglite"
-        : sqlDriver.id === "libsql";
-    if (!compatible) {
+    if (sqlDriver.id !== "postgres" && sqlDriver.id !== "pglite") {
       throw new Error(
-        `oke store: index driver "${driver.id}" cannot share sql driver "${sqlDriver.id}" — ` +
-          (driver.id === "pgvector"
-            ? `pgvector needs store.sql on "postgres" or "pglite"`
-            : `libsql index needs store.sql on "libsql"`),
+        `oke store: index driver "pgvector" cannot share sql driver "${sqlDriver.id}" — ` +
+          `pgvector needs store.sql on "postgres" or "pglite"`,
       );
     }
     return sharedSqlConn(sqlDriver, "primary", { url });

package/src/elements/store/schema-decl.test.ts

@@ -56,7 +56,7 @@ describe("store.schema.table + field.*", () => {
     const decl = store.sql("notes", { schema: { notes } });
     const runtime = createStoreRuntime({
       drivers: {},
-      sql: { notes: { name: "notes", primary: { url: ":memory:" } } },
+      sql: { notes: { name: "notes", primary: {} } },
     });
     // Register so classificationsFor merges table columns.
     runtime.register(decl);
@@ -68,10 +68,10 @@ describe("store.schema.table + field.*", () => {
     expect(masked[0]!.email).toBe(PII_MASK);
 
     // Runtime path: open handle and query — ensure classificationsFromTable feeds mask.
-    const { sqliteDriver } = await import("../../drivers/index.ts");
+    const { memorySqlDriver } = await import("../../drivers/index.ts");
     const rt = createStoreRuntime({
-      drivers: { sql: sqliteDriver },
-      sql: { notes: { name: "notes", primary: { url: ":memory:" } } },
+      drivers: { sql: memorySqlDriver },
+      sql: { notes: { name: "notes", primary: {} } },
     });
     rt.register(decl);
     const handle = (await rt.open(decl, {
@@ -84,7 +84,7 @@ describe("store.schema.table + field.*", () => {
   });
 });
 
-describe("emitDrizzleSource — both dialects from one declaration", () => {
+describe("emitDrizzleSource — postgres pgTable from one declaration", () => {
   const notes = store.schema.table("notes", {
     id: field.text().primaryKey().defaultFn(id),
     title: field.text().notNull(),
@@ -92,24 +92,17 @@ describe("emitDrizzleSource — both dialects from one declaration", () => {
     createdAt: field.integer().notNull().defaultFn(now),
   });
 
-  test("sqlite emits sqliteTable", () => {
-    const src = emitDrizzleSource([notes], "sqlite");
-    expect(src.startsWith(GENERATED_SCHEMA_HEADER)).toBe(true);
-    expect(src).toContain('from "drizzle-orm/sqlite-core"');
-    expect(src).toContain("sqliteTable");
-    expect(src).not.toContain("pgTable");
-    expect(src).toContain('text("id").primaryKey().$defaultFn(id)');
-    expect(src).toContain('integer("created_at").notNull().$defaultFn(now)');
-    expect(src).toContain('text("body").notNull()');
-  });
-
-  test("postgres emits pgTable from the same decl", () => {
+  test("postgres emits pgTable", () => {
     const src = emitDrizzleSource([notes], "postgres");
+    expect(src.startsWith(GENERATED_SCHEMA_HEADER)).toBe(true);
     expect(src).toContain('from "drizzle-orm/pg-core"');
     expect(src).toContain("pgTable");
     expect(src).not.toContain("sqliteTable");
+    expect(src).not.toContain("drizzle-orm/sqlite-core");
     expect(src).toContain('text("id").primaryKey().$defaultFn(id)');
-    expect(src).toContain('integer("created_at").notNull().$defaultFn(now)');
+    // Postgres INTEGER is 32-bit — abstract integer maps to bigint for ms clocks.
+    expect(src).toContain('bigint("created_at", { mode: "number" }).notNull().$defaultFn(now)');
+    expect(src).toContain('text("body").notNull()');
   });
 });
 
@@ -142,9 +135,9 @@ describe("plugin table columns in generated schema", () => {
     expect(pluginTables[0]!.columns.actorId!.classification?.pii).toBe(true);
 
     const merged = mergeSchemaTables([notes], pluginTables);
-    const src = emitDrizzleSource(merged, "sqlite");
-    expect(src).toContain('sqliteTable("notes"');
-    expect(src).toContain('sqliteTable("audit_events"');
+    const src = emitDrizzleSource(merged, "postgres");
+    expect(src).toContain('pgTable("notes"');
+    expect(src).toContain('pgTable("audit_events"');
     expect(src).toContain('text("actor_id").notNull()');
   });
 
@@ -195,21 +188,12 @@ describe("emitDrizzleSource — references + relations (Linkly-shaped)", () => {
     },
   }));
 
-  test("sqlite emit includes FK + defineRelations", () => {
-    const src = emitDrizzleSource([links, daily], "sqlite", { relations: [relations] });
-    expect(src).toContain("sqliteTable");
-    expect(src).toContain(".references(() => links.code)");
-    expect(src).toContain('import { defineRelations } from "drizzle-orm"');
-    expect(src).toContain("defineRelations({ links, daily }");
-    expect(src).toContain("r.many.daily({ from: r.links.code, to: r.daily.code })");
-    expect(src).toContain("r.one.links({ from: r.daily.code, to: r.links.code, optional: false })");
-  });
-
-  test("postgres emit includes same FK + defineRelations from one decl", () => {
+  test("postgres emit includes FK + defineRelations", () => {
     const src = emitDrizzleSource([links, daily], "postgres", { relations: [relations] });
     expect(src).toContain("pgTable");
     expect(src).not.toContain("sqliteTable");
     expect(src).toContain(".references(() => links.code)");
+    expect(src).toContain('import { defineRelations } from "drizzle-orm"');
     expect(src).toContain("defineRelations({ links, daily }");
     expect(src).toContain("r.many.daily({ from: r.links.code, to: r.daily.code })");
     expect(src).toContain("r.one.links({ from: r.daily.code, to: r.links.code, optional: false })");

package/src/elements/store/seed.test.ts

@@ -19,8 +19,7 @@ describe("defineSeed / resolveSeedCategory", () => {
   });
 
   test("resolveSeedCategory matches the env matrix", () => {
-    expect(resolveSeedCategory("local")).toBe("dev");
-    expect(resolveSeedCategory("docker")).toBe("dev");
+    expect(resolveSeedCategory("dev")).toBe("dev");
     expect(resolveSeedCategory("prod")).toBe("prod");
     expect(resolveSeedCategory("test")).toBe(null);
   });

package/src/elements/store/seed.ts

@@ -17,7 +17,7 @@ export type SeedFns = SeedFn | readonly SeedFn[];
  * Seed categories for {@link defineSeed}.
  *
  * - `essential` — every environment, always
- * - `dev` — `local` or `docker` only
+ * - `dev` — `dev` ConfigEnv only (Docker Compose laptop)
  * - `prod` — `prod` only
  */
 export interface SeedDef {
@@ -52,17 +52,16 @@ export function normalizeSeedFns(fns?: SeedFns): SeedFn[] {
 /**
  * Which optional category runs for `env` (single source of truth).
  *
- * | env    | category |
- * | ------ | -------- |
- * | local  | dev      |
- * | docker | dev      |
- * | test   | (none)   |
- * | prod   | prod     |
+ * | env  | category |
+ * | ---- | -------- |
+ * | dev  | dev      |
+ * | test | (none)   |
+ * | prod | prod     |
  *
  * @param env - Resolved {@link ConfigEnv}
  */
 export function resolveSeedCategory(env: ConfigEnv): SeedCategory | null {
-  if (env === "local" || env === "docker") return "dev";
+  if (env === "dev") return "dev";
   if (env === "prod") return "prod";
   return null;
 }

package/src/elements/store/sql-condition.test.ts

@@ -20,10 +20,10 @@ import {
   or,
   sql,
 } from "drizzle-orm";
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
 import { compileOrderBy, compileWhere } from "./sql-condition.ts";
 
-const notes = sqliteTable("notes", {
+const notes = pgTable("notes", {
   id: text("id").primaryKey(),
   title: text("title").notNull(),
   createdAt: integer("created_at").notNull(),

package/src/elements/store/sql-session.test.ts

@@ -7,22 +7,21 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { Database } from "bun:sqlite";
 import { and, desc, eq, like, lt, or } from "drizzle-orm";
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import { sqliteDriver } from "../../drivers/sqlite.ts";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { pgliteDriver } from "../../drivers/pglite.ts";
 import type { SqlConnection } from "../../drivers/types.ts";
 import { createSqlStoreHandle, type SqlStoreHandle } from "./sql-session.ts";
 
-const posts = sqliteTable("posts", {
+const posts = pgTable("posts", {
   id: text("id").primaryKey(),
   title: text("title").notNull(),
   createdAt: integer("created_at").notNull(),
 });
 
 async function openHandle(): Promise<{ handle: SqlStoreHandle; conn: SqlConnection }> {
-  const conn = await sqliteDriver.connect({
-    client: new Database(":memory:"),
+  const conn = await pgliteDriver.connect({
+    url: "memory://",
     role: "primary",
   });
   const handle = createSqlStoreHandle("sql:app", {
@@ -36,8 +35,7 @@ async function openHandle(): Promise<{ handle: SqlStoreHandle; conn: SqlConnecti
 
 describe("SqlStoreHandle — no relational query surface (path b)", () => {
   test("created handle exposes exactly the single-table surface", async () => {
-    const db = new Database(":memory:");
-    const conn = await sqliteDriver.connect({ client: db, role: "primary" });
+    const conn = await pgliteDriver.connect({ url: "memory://", role: "primary" });
     const handle = createSqlStoreHandle("sql:app", {
       connection: conn,
       classifications: new Map(),
@@ -124,12 +122,12 @@ describe("SqlStoreHandle — orderBy / limit select chain", () => {
     await conn.close();
   });
 
-  test("like filters rows through the session (sqlite ASCII-insensitive)", async () => {
+  test("like filters rows through the session (postgres case-sensitive)", async () => {
     const { handle, conn } = await openHandle();
     await handle.insert(posts).values({ id: "p1", title: "alpha", createdAt: 100 });
     await handle.insert(posts).values({ id: "p2", title: "bravo", createdAt: 200 });
 
-    const rows = await handle.select().from(posts).where(like(posts.title, "A%"));
+    const rows = await handle.select().from(posts).where(like(posts.title, "a%"));
     expect(rows.map((r) => r.id)).toEqual(["p1"]);
     await conn.close();
   });

package/src/elements/store/sql-session.ts

@@ -363,9 +363,13 @@ export function createSqlStoreHandle(
     if (cols.length === 0) return;
     const name = resolveTableName(table);
     const pk = cols.find((c) => c.primary)?.sqlName;
+    // Postgres/PGLite INTEGER is 32-bit — abstract `integer` (ms timestamps via
+    // `now`) must map to BIGINT. SQLite INTEGER is flexible up to 64-bit.
+    const pgWideInt = connection.driverId === "postgres" || connection.driverId === "pglite";
     const colSql = cols
       .map((c) => {
-        const typ = pk && c.sqlName === pk ? `${c.sqlType} PRIMARY KEY` : c.sqlType;
+        const base = pgWideInt && c.sqlType === "INTEGER" ? "BIGINT" : c.sqlType;
+        const typ = pk && c.sqlName === pk ? `${base} PRIMARY KEY` : base;
         return `${quoteIdent(c.sqlName)} ${typ}`;
       })
       .join(", ");
@@ -734,6 +738,10 @@ export function createSqlStoreHandle(
     async ensureTable(table) {
       const cols = Object.values(table.columns);
       const pk = resolvePkColumn(table);
+      const intType =
+        connection.driverId === "postgres" || connection.driverId === "pglite"
+          ? "BIGINT"
+          : "INTEGER";
       const colSql = cols
         .map((c) => {
           const typ =
@@ -743,7 +751,7 @@ export function createSqlStoreHandle(
                   c.name === "qty" ||
                   c.name === "createdAt" ||
                   c.name === "created_at"
-                ? "INTEGER"
+                ? intType
                 : "TEXT";
           return `${quoteIdent(c.name)} ${typ}`;
         })

package/src/elements/store.test.ts

@@ -1,13 +1,13 @@
 /**
  * Store element acceptance:
- * - same flow runs unchanged against sqlite and postgres
+ * - same flow runs unchanged against memory and postgres
  * - read-only flow provably hits a replica
  * - auto-invalidation fires on exactly the writes touching the read's keys
  * - SELECT * masks classified columns
  */
 
 import { describe, expect, test } from "bun:test";
-import { createPostgresFakeClient, postgresDriver, sqliteDriver } from "../drivers/index.ts";
+import { createPostgresFakeClient, memorySqlDriver, postgresDriver } from "../drivers/index.ts";
 import type { Effects } from "../manifest/types.ts";
 import {
   classify,
@@ -73,7 +73,7 @@ describe("store facets", () => {
   });
 });
 
-describe("same flow against sqlite and postgres", () => {
+describe("same flow against memory and postgres", () => {
   test("insert / select / findById unchanged across drivers", async () => {
     const decl = store.sql("notes", {
       schema: { notes },
@@ -81,7 +81,7 @@ describe("same flow against sqlite and postgres", () => {
     });
 
     for (const [label, driver, client] of [
-      ["sqlite", sqliteDriver, undefined],
+      ["memory", memorySqlDriver, undefined],
       ["postgres", postgresDriver, createPostgresFakeClient()],
     ] as const) {
       const runtime = createStoreRuntime({
@@ -89,7 +89,7 @@ describe("same flow against sqlite and postgres", () => {
         sql: {
           notes: {
             name: "notes",
-            primary: { url: ":memory:", client },
+            primary: { client },
           },
         },
       });
@@ -218,8 +218,8 @@ describe("tier-1 cache invalidation from effects", () => {
 
   test("runtime putTier1 + onWriteEffects", async () => {
     const runtime = createStoreRuntime({
-      drivers: { sql: sqliteDriver },
-      sql: { notes: { name: "notes", primary: { url: ":memory:" } } },
+      drivers: { sql: memorySqlDriver },
+      sql: { notes: { name: "notes", primary: {} } },
     });
     const keys = runtime.putTier1({ reads: ["sql:notes"] }, ["cached"]);
     expect(runtime.cache.get<string[]>(keys[0]!)).toEqual(["cached"]);
@@ -237,7 +237,7 @@ describe("exists and increment helpers", () => {
 
   test("exists returns correctly for present / absent rows across sqlite and postgres", async () => {
     for (const [label, driver, client] of [
-      ["sqlite", sqliteDriver, undefined],
+      ["memory", memorySqlDriver, undefined],
       ["postgres", postgresDriver, createPostgresFakeClient()],
     ] as const) {
       const decl = store.sql("counters");
@@ -246,7 +246,7 @@ describe("exists and increment helpers", () => {
         sql: {
           counters: {
             name: "counters",
-            primary: { url: ":memory:", client },
+            primary: { client },
           },
         },
       });
@@ -267,7 +267,7 @@ describe("exists and increment helpers", () => {
 
   test("increment under 100 concurrent callers lands on the correct final value", async () => {
     for (const [label, driver, client] of [
-      ["sqlite", sqliteDriver, undefined],
+      ["memory", memorySqlDriver, undefined],
       ["postgres", postgresDriver, createPostgresFakeClient()],
     ] as const) {
       const decl = store.sql("counters");
@@ -276,7 +276,7 @@ describe("exists and increment helpers", () => {
         sql: {
           counters: {
             name: "counters",
-            primary: { url: ":memory:", client },
+            primary: { client },
           },
         },
       });
@@ -308,8 +308,8 @@ describe("PII masking at the driver boundary", () => {
       classify: { notes: { email: classify({ pii: true }) } },
     });
     const runtime = createStoreRuntime({
-      drivers: { sql: sqliteDriver },
-      sql: { notes: { name: "notes", primary: { url: ":memory:" } } },
+      drivers: { sql: memorySqlDriver },
+      sql: { notes: { name: "notes", primary: {} } },
     });
     runtime.register(decl);
     const handle = asSql(