@solcreek/adapter-creek 0.2.6 → 0.2.7

package/dist/build.js

@@ -11,10 +11,57 @@
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 import { generateWorkerEntry } from "./worker-entry.js";
 import { bundleForWorkers } from "./bundler.js";
 import { writeManifest } from "./manifest.js";
 const OUTPUT_DIR = ".creek/adapter-output";
+/**
+ * Decode Prisma 7's query-compiler WASM and stage it as a real `.wasm` file so
+ * it flows through the CompiledWasm pipeline (precompiled at bundle time,
+ * registered by byte length). Prisma's client instantiates the compiler via
+ * `new WebAssembly.Module(bytes)` from a base64-embedded `.mjs`, which workerd
+ * rejects at runtime ("Wasm code generation disallowed by embedder"); the
+ * worker-entry Module patch swaps the matching precompiled module in by length.
+ *
+ * Only the sqlite `fast` variant matters on D1: it is the generator default
+ * and the only base64 module the generated client imports (so the only byte
+ * length queried at runtime). Staging `small` too would just add an
+ * unreferenced CompiledWasm module to the bundle — dead weight — so we don't.
+ * A project that overrides `compilerBuild = "small"` is unsupported for now.
+ * No-op when @prisma/client isn't installed.
+ */
+async function collectPrismaCompilerWasm(projectDir, outputDir, wasmFiles) {
+    let runtimeDir;
+    try {
+        const req = createRequire(path.join(projectDir, "noop.js"));
+        runtimeDir = path.join(path.dirname(req.resolve("@prisma/client/package.json")), "runtime");
+    }
+    catch {
+        return; // Not a Prisma project.
+    }
+    const base = "query_compiler_fast_bg.sqlite";
+    const mjs = path.join(runtimeDir, `${base}.wasm-base64.mjs`);
+    try {
+        // Import the base64 module's `wasm` named export (no regex parsing).
+        const mod = (await import(pathToFileURL(mjs).href));
+        if (!mod.wasm)
+            return;
+        const bytes = Buffer.from(mod.wasm, "base64");
+        const stageDir = path.join(outputDir, ".prisma-wasm");
+        await fs.mkdir(stageDir, { recursive: true });
+        const dest = path.join(stageDir, `${base}.wasm`);
+        await fs.writeFile(dest, bytes);
+        wasmFiles.set(`${base}.wasm`, dest);
+        console.log(`  [Creek Adapter] Prisma compiler wasm staged: ${base} (${bytes.byteLength} bytes)`);
+    }
+    catch {
+        // Absent/unreadable (or not a sqlite Prisma project) — skip. A genuinely
+        // missing compiler surfaces as the original workerd error at runtime,
+        // which is the pre-existing behaviour.
+    }
+}
 export async function handleBuild(ctx) {
     const outputDir = path.join(ctx.projectDir, OUTPUT_DIR);
     const assetsDir = path.join(outputDir, "assets");
@@ -94,6 +141,10 @@ export async function handleBuild(ctx) {
             }
         }
     }
+    // Stage Prisma 7's query-compiler WASM (sqlite) so a Prisma app runs on D1
+    // unchanged: its base64-embedded compiler is precompiled here and swapped in
+    // at runtime by the worker-entry WebAssembly.Module patch. No-op otherwise.
+    await collectPrismaCompilerWasm(ctx.projectDir, outputDir, wasmFiles);
     // Step 3: Collect manifests from .next/ for embedding in the worker.
     // Next.js route modules call loadManifest() which uses fs.readFileSync().
     // CF Workers doesn't have fs, so we embed all manifests and shim the loader.

package/dist/bundler.js

@@ -13,6 +13,10 @@ import { execFileSync } from "node:child_process";
 import { builtinModules, createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { WORKER_COMPATIBILITY_DATE, WORKER_COMPATIBILITY_FLAGS } from "./compat.js";
+/** Escape a string for safe interpolation into a RegExp source. */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 /**
  * Resolve wrangler's CLI entry script through Node module resolution.
  *
@@ -1077,6 +1081,32 @@ export async function bundleForWorkers(opts) {
     await fs.rm(entryPath, { force: true });
     await fs.rm(configPath, { force: true });
     await fs.rm(bundleDir, { recursive: true, force: true });
+    // Prune orphaned plain wasm copies. We write each wasm under its plain name
+    // (above) so wrangler can resolve `import __wasm from "./<name>.wasm"`;
+    // wrangler then emits a content-hashed sibling `<hash>-<name>.wasm` and
+    // rewrites the import to it. The plain copy is left behind unreferenced —
+    // dead weight in the uploaded script (significant for large wasm like
+    // Prisma's ~3.5MB query compiler). Delete a plain copy only when a hashed
+    // sibling exists AND the bundled worker no longer imports the plain path, so
+    // wasm that wrangler kept un-hashed is never touched.
+    try {
+        const outFiles = await fs.readdir(opts.outputDir);
+        const workerCode = await fs.readFile(path.join(opts.outputDir, "worker.js"), "utf-8");
+        for (const [name] of opts.wasmFiles) {
+            const plain = name.endsWith(".wasm") ? name : name + ".wasm";
+            if (!outFiles.includes(plain))
+                continue;
+            const hashedSibling = new RegExp(`^[0-9a-f]{6,}-${escapeRegExp(plain)}$`);
+            const hasHashed = outFiles.some((f) => hashedSibling.test(f));
+            const stillImportsPlain = workerCode.includes(`./${plain}`);
+            if (hasHashed && !stillImportsPlain) {
+                await fs.rm(path.join(opts.outputDir, plain), { force: true });
+            }
+        }
+    }
+    catch {
+        // Best-effort: if worker.js is absent or readdir fails, keep all files.
+    }
     // List output files
     const files = await fs.readdir(opts.outputDir);
     return files.filter(f => !f.startsWith("__"));

package/dist/index.js

@@ -13,6 +13,10 @@ const SHIMS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..",
 const DB_DRIVER_ALIASES = {
     // Drizzle: `drizzle-orm/better-sqlite3` → D1-backed drizzle. No WASM.
     "drizzle-orm/better-sqlite3$": path.join(SHIMS_DIR, "drizzle-better-sqlite3.js"),
+    // Prisma 7: `@prisma/adapter-better-sqlite3` → D1-backed PrismaD1 adapter.
+    // The query-compiler WASM is precompiled in build.ts and swapped in by the
+    // worker-entry WebAssembly.Module patch.
+    "@prisma/adapter-better-sqlite3$": path.join(SHIMS_DIR, "prisma-adapter-better-sqlite3.js"),
     // The native better-sqlite3 client the user passes to drizzle() — stubbed,
     // since the swap ignores it and uses env.DB. Keeps the native .node out of
     // the Workers bundle.

package/dist/worker-entry.js

@@ -353,6 +353,31 @@ if (typeof WebAssembly !== "undefined" && typeof WebAssembly.instantiate === "fu
       return __origCompile(bytes);
     };
   }
+  // Prisma 7's query compiler instantiates its wasm synchronously via
+  // \`new WebAssembly.Module(bytes)\` (decoded from a base64 module), which
+  // workerd also rejects. Swap in the pre-compiled CompiledWasm module
+  // (registered by byte length at build time) when the bytes match; a
+  // constructor returning an object yields that object to the \`new\`
+  // expression. Falls back to the original elsewhere.
+  if (typeof WebAssembly.Module === "function") {
+    const __OrigModule = WebAssembly.Module;
+    const __ModulePatched = function(bytes) {
+      const precompiled = __findPrecompiled(bytes);
+      if (precompiled) return precompiled;
+      return Reflect.construct(__OrigModule, arguments, __ModulePatched);
+    };
+    __ModulePatched.prototype = __OrigModule.prototype;
+    if (typeof __OrigModule.imports === "function") {
+      __ModulePatched.imports = function(m) { return __OrigModule.imports(m); };
+    }
+    if (typeof __OrigModule.exports === "function") {
+      __ModulePatched.exports = function(m) { return __OrigModule.exports(m); };
+    }
+    if (typeof __OrigModule.customSections === "function") {
+      __ModulePatched.customSections = function(m, n) { return __OrigModule.customSections(m, n); };
+    }
+    WebAssembly.Module = __ModulePatched;
+  }
 }
 
 // Polyfill process methods and env that Next.js uses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/adapter-creek",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Next.js deployment adapter for Creek (Cloudflare Workers)",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,6 +46,7 @@
   "dependencies": {
     "@next/routing": "16.2.3",
     "@node-rs/xxhash": "^1.7.6",
+    "@prisma/adapter-d1": "^7.8.0",
     "@solcreek/adapter-core": "^0.2.0",
     "@solcreek/adapter-next-core": "^0.1.1",
     "sql.js": "^1.14.1",

package/src/shims/db-driver-swap.test.ts

@@ -12,6 +12,17 @@ vi.mock("drizzle-orm/d1", () => ({
   drizzle: (client: unknown, config: unknown) => ({ __d1Client: client, __config: config }),
 }));
 
+// The Prisma shim imports `@prisma/adapter-d1` (an adapter-creek dependency).
+// Mock PrismaD1 so connect() can be asserted without a live D1 binding.
+vi.mock("@prisma/adapter-d1", () => ({
+  PrismaD1: class {
+    db: unknown;
+    constructor(db: unknown) { this.db = db; }
+    connect() { return { kind: "d1-adapter", db: this.db }; }
+    connectToShadowDb() { return { kind: "d1-shadow", db: this.db }; }
+  },
+}));
+
 const SHIMS_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 afterEach(() => {
@@ -35,6 +46,9 @@ describe("DB driver-swap aliases (modifyConfig)", () => {
     expect(alias["drizzle-orm/better-sqlite3$"]).toBe(
       path.join(SHIMS_DIR, "drizzle-better-sqlite3.js"),
     );
+    expect(alias["@prisma/adapter-better-sqlite3$"]).toBe(
+      path.join(SHIMS_DIR, "prisma-adapter-better-sqlite3.js"),
+    );
     expect(alias["better-sqlite3$"]).toBe(
       path.join(SHIMS_DIR, "better-sqlite3-stub.js"),
     );
@@ -103,6 +117,38 @@ describe("drizzle-better-sqlite3 shim", () => {
   });
 });
 
+describe("prisma-adapter-better-sqlite3 shim", () => {
+  it("exposes provider synchronously and ignores the local config", async () => {
+    const { PrismaBetterSqlite3 } = await import("./prisma-adapter-better-sqlite3.js");
+    // Constructed at module scope, before any request env exists.
+    const adapter = new PrismaBetterSqlite3({ url: "file:./dev.db" });
+    expect(adapter.provider).toBe("sqlite");
+    expect(adapter.adapterName).toBe("@prisma/adapter-d1");
+  });
+
+  it("connects against env.DB lazily (at first query, not construction)", async () => {
+    const { PrismaBetterSqlite3 } = await import("./prisma-adapter-better-sqlite3.js");
+    const adapter = new PrismaBetterSqlite3({ url: "file:./dev.db" });
+
+    const fakeD1 = { tag: "d1" };
+    (globalThis as { __creekEnv?: () => unknown }).__creekEnv = () => ({ DB: fakeD1 });
+
+    const conn = adapter.connect() as { kind: string; db: unknown };
+    expect(conn.kind).toBe("d1-adapter");
+    expect(conn.db).toBe(fakeD1);
+
+    const shadow = adapter.connectToShadowDb() as { kind: string };
+    expect(shadow.kind).toBe("d1-shadow");
+  });
+
+  it("throws a helpful error when env.DB is unavailable at connect()", async () => {
+    const { PrismaBetterSqlite3 } = await import("./prisma-adapter-better-sqlite3.js");
+    const adapter = new PrismaBetterSqlite3({ url: "file:./dev.db" });
+    (globalThis as { __creekEnv?: () => unknown }).__creekEnv = () => ({});
+    expect(() => adapter.connect()).toThrow(/D1 binding `env\.DB` is unavailable/);
+  });
+});
+
 describe("better-sqlite3 stub", () => {
   it("constructs but refuses queries (swap uses D1 instead)", async () => {
     const { default: Database } = await import("./better-sqlite3-stub.js");

package/src/shims/prisma-adapter-better-sqlite3.js

@@ -0,0 +1,49 @@
+// Creek build-time swap for `@prisma/adapter-better-sqlite3` → Cloudflare D1.
+//
+// Only active in the Creek/Workers build (aliased by adapter-creek's
+// modifyConfig); local dev keeps the real better-sqlite3 adapter. Prisma 7
+// requires a driver adapter, so the user already passes
+// `new PrismaClient({ adapter: new PrismaBetterSqlite3(...) })`. The ONLY
+// env-specific difference on Workers is which adapter backs the client — the
+// schema, generated client, and queries are identical. We mirror the
+// better-sqlite3 factory's shape but back it with `@prisma/adapter-d1` over the
+// request's D1 binding.
+//
+// The user constructs the adapter at module scope, before env.DB exists.
+// Prisma reads `provider` synchronously at PrismaClient construction and only
+// calls `connect()` at the first query (request time), so D1 is resolved
+// lazily inside connect() — never at construction.
+import { PrismaD1 } from "@prisma/adapter-d1";
+
+function resolveD1() {
+  const env = (globalThis.__creekEnv && globalThis.__creekEnv()) || {};
+  const db = env.DB;
+  if (!db) {
+    throw new Error(
+      "[creek] D1 binding `env.DB` is unavailable. Add `database = true` under [resources] in creek.toml.",
+    );
+  }
+  return db;
+}
+
+class PrismaBetterSqlite3 {
+  constructor() {
+    // Read synchronously by @prisma/client at construction time.
+    this.provider = "sqlite";
+    this.adapterName = "@prisma/adapter-d1";
+  }
+
+  connect() {
+    return new PrismaD1(resolveD1()).connect();
+  }
+
+  connectToShadowDb() {
+    const factory = new PrismaD1(resolveD1());
+    return factory.connectToShadowDb
+      ? factory.connectToShadowDb()
+      : factory.connect();
+  }
+}
+
+export { PrismaBetterSqlite3 };
+export default PrismaBetterSqlite3;