@solcreek/adapter-creek 0.2.4 → 0.2.6

package/dist/bundler.js

@@ -711,6 +711,13 @@ export async function bundleForWorkers(opts) {
             // throws \`sharp is not a function\`. Aliasing to a shim whose default
             // is undefined makes \`@vercel/og\` fall back to its resvg.wasm path.
             "sharp": path.join(adapterDir, "src", "shims", "sharp.js"),
+            // better-sqlite3 is a native module that can't run on workerd. The DB
+            // driver swap (Drizzle/Prisma) ignores the local client and uses env.DB,
+            // so stub better-sqlite3 to keep its native .node out of the bundle.
+            // Aliased here (esbuild) because Next bundles its JS inline — the
+            // webpack-layer alias doesn't catch the already-resolved native require.
+            "better-sqlite3": path.join(adapterDir, "src", "shims", "better-sqlite3-stub.js"),
+            "node:better-sqlite3": path.join(adapterDir, "src", "shims", "better-sqlite3-stub.js"),
             // Some packages intentionally leave unreachable dynamic imports such as
             // `if (Math.random() < 0) import("fail")` in their ESM entry. Turbopack
             // externalizes the package and never resolves that branch, but wrangler

package/dist/index.js

@@ -1,8 +1,23 @@
 import * as path from "node:path";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { copyFileSync, existsSync } from "node:fs";
 import { applyBaseModifyConfig } from "@solcreek/adapter-next-core";
 import { handleBuild } from "./build.js";
+// Build-time DB driver swaps: in the Workers build only, redirect a local
+// SQLite driver import to a Creek shim that backs the same ORM with the
+// request's D1 binding (env.DB, resolved lazily). Local dev is untouched —
+// the adapter only runs under the Creek build. Aliases are harmless when the
+// module isn't imported, so they apply unconditionally.
+const SHIMS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "src", "shims");
+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"),
+    // 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.
+    "better-sqlite3$": path.join(SHIMS_DIR, "better-sqlite3-stub.js"),
+};
 // Path to the cache handler shipped by @solcreek/adapter-next-core, resolved
 // from THIS module's location — not from the consumer project. The adapter is
 // not always installed in the project's own node_modules: the Creek CLI
@@ -77,6 +92,16 @@ const adapter = {
                 ...(baseConfig.experimental ?? {}),
                 maxPostponedStateSize: "20mb",
             },
+            // Swap local SQLite ORM drivers → D1-backed shims (Workers build only).
+            // Compose with any webpack fn the base config already set.
+            webpack(webpackConfig, webpackCtx) {
+                const cfg = typeof baseConfig.webpack === "function"
+                    ? baseConfig.webpack(webpackConfig, webpackCtx)
+                    : webpackConfig;
+                cfg.resolve = cfg.resolve ?? {};
+                cfg.resolve.alias = { ...(cfg.resolve.alias ?? {}), ...DB_DRIVER_ALIASES };
+                return cfg;
+            },
         };
     },
     async onBuildComplete(ctx) {

package/dist/worker-entry.js

@@ -1973,6 +1973,14 @@ function __creekCurrentEnv() {
   }
 }
 
+// Expose the current request's Cloudflare env (incl. bindings like DB) to
+// bundled user code and the build-time DB driver-swap shims (Drizzle/Prisma),
+// which resolve env.DB lazily at query time. AsyncLocalStorage-backed, so it
+// is request-safe under concurrency.
+if (typeof globalThis !== "undefined") {
+  globalThis.__creekEnv = __creekCurrentEnv;
+}
+
 // Group tags into {shardKey: tags[]} so we hit each DO instance at most
 // once per operation (avoids fan-out + 2x/3x RPC cost for entries that
 // carry many tags).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/adapter-creek",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Next.js deployment adapter for Creek (Cloudflare Workers)",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,6 +45,7 @@
   },
   "dependencies": {
     "@next/routing": "16.2.3",
+    "@node-rs/xxhash": "^1.7.6",
     "@solcreek/adapter-core": "^0.2.0",
     "@solcreek/adapter-next-core": "^0.1.1",
     "sql.js": "^1.14.1",
@@ -54,7 +55,6 @@
     "next": ">=16.2.3"
   },
   "devDependencies": {
-    "@node-rs/xxhash": "^1.7.6",
     "@types/node": "^22.13.10",
     "miniflare": "^4.20260410.0",
     "next": "16.2.3",

package/src/shims/better-sqlite3-stub.js

@@ -0,0 +1,14 @@
+// Creek: better-sqlite3 is a native module that cannot run on Cloudflare
+// Workers. The Drizzle/Prisma driver-swap shims ignore the local client and
+// use the D1 binding instead, so the actual better-sqlite3 instance is never
+// used on Workers — stub it to a harmless no-op so the bundle builds. Local
+// dev keeps the real better-sqlite3.
+class Database {
+  constructor() {}
+  prepare() { throw new Error("[creek] better-sqlite3 is not available on Workers; queries run on D1 via the driver swap."); }
+  exec() {}
+  close() {}
+  pragma() {}
+}
+export default Database;
+export { Database };

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

@@ -0,0 +1,116 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import adapter from "../index.js";
+
+// The drizzle shim imports `drizzle-orm/d1`, which is resolved from the user's
+// project at build time (drizzle-orm is not an adapter-creek dependency). Mock
+// it so the swap logic can be unit-tested in isolation: the mock drizzle()
+// just records the client + config it was handed.
+vi.mock("drizzle-orm/d1", () => ({
+  drizzle: (client: unknown, config: unknown) => ({ __d1Client: client, __config: config }),
+}));
+
+const SHIMS_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+afterEach(() => {
+  delete (globalThis as { __creekEnv?: unknown }).__creekEnv;
+});
+
+describe("DB driver-swap aliases (modifyConfig)", () => {
+  it("aliases the local SQLite drivers to Creek shims in the Workers build", () => {
+    const config = adapter.modifyConfig?.(
+      {},
+      { phase: "phase-production-build" } as never,
+    );
+
+    // The adapter exposes webpack(cfg, ctx); applying it surfaces the aliases.
+    const webpack = (config as { webpack?: (c: unknown, x: unknown) => any }).webpack;
+    expect(typeof webpack).toBe("function");
+
+    const built = webpack!({ resolve: {} }, {});
+    const alias = built.resolve.alias as Record<string, string>;
+
+    expect(alias["drizzle-orm/better-sqlite3$"]).toBe(
+      path.join(SHIMS_DIR, "drizzle-better-sqlite3.js"),
+    );
+    expect(alias["better-sqlite3$"]).toBe(
+      path.join(SHIMS_DIR, "better-sqlite3-stub.js"),
+    );
+  });
+
+  it("preserves a base webpack fn while adding the DB aliases", () => {
+    // modifyConfig composes its webpack on top of whatever the base set; verify
+    // a pre-existing alias survives alongside the swap aliases.
+    const config = adapter.modifyConfig?.(
+      {},
+      { phase: "phase-production-build" } as never,
+    );
+    const webpack = (config as { webpack?: (c: unknown, x: unknown) => any }).webpack;
+    const built = webpack!({ resolve: { alias: { "pre-existing": "/x" } } }, {});
+    const alias = built.resolve.alias as Record<string, string>;
+    expect(alias["pre-existing"]).toBe("/x");
+    expect(alias["drizzle-orm/better-sqlite3$"]).toContain("drizzle-better-sqlite3.js");
+  });
+
+  it("does not add the aliases outside the production build phase", () => {
+    const config = adapter.modifyConfig?.({}, { phase: "phase-development-server" } as never);
+    // Dev passthrough should not install the Workers-only webpack swap.
+    expect((config as { webpack?: unknown }).webpack).toBeUndefined();
+  });
+});
+
+describe("drizzle-better-sqlite3 shim", () => {
+  it("backs drizzle with env.DB (resolved lazily) and ignores the local client", async () => {
+    const { drizzle } = await import("./drizzle-better-sqlite3.js");
+
+    const fakeD1 = { __isD1: true, prepare: () => "stmt" };
+    (globalThis as { __creekEnv?: () => unknown }).__creekEnv = () => ({ DB: fakeD1 });
+
+    const localClient = { native: true };
+    const db = drizzle(localClient as never, { schema: {} }) as {
+      __d1Client: Record<string, unknown>;
+      __config: unknown;
+    };
+
+    // The user's local better-sqlite3 client is ignored; config flows through.
+    expect(db.__config).toEqual({ schema: {} });
+    // The D1 client is a lazy proxy that resolves env.DB per property access.
+    expect((db.__d1Client as { __isD1: boolean }).__isD1).toBe(true);
+    expect(typeof db.__d1Client.prepare).toBe("function");
+    expect((db.__d1Client.prepare as () => string)()).toBe("stmt");
+  });
+
+  it("throws a helpful error when env.DB is unavailable", async () => {
+    const { drizzle } = await import("./drizzle-better-sqlite3.js");
+    (globalThis as { __creekEnv?: () => unknown }).__creekEnv = () => ({});
+    const db = drizzle({} as never, {}) as { __d1Client: Record<string, unknown> };
+    expect(() => db.__d1Client.prepare).toThrow(/D1 binding `env\.DB` is unavailable/);
+  });
+
+  it("resolves env per access (request-scoped), not once at construction", async () => {
+    const { drizzle } = await import("./drizzle-better-sqlite3.js");
+    let current: { DB?: unknown } = {};
+    (globalThis as { __creekEnv?: () => unknown }).__creekEnv = () => current;
+    const db = drizzle({} as never, {}) as { __d1Client: Record<string, unknown> };
+
+    // No binding yet → throws.
+    expect(() => db.__d1Client.prepare).toThrow();
+    // Binding appears on a later request → resolves without rebuilding.
+    current = { DB: { tag: "req-2", prepare: () => "ok" } };
+    expect((db.__d1Client.prepare as () => string)()).toBe("ok");
+  });
+});
+
+describe("better-sqlite3 stub", () => {
+  it("constructs but refuses queries (swap uses D1 instead)", async () => {
+    const { default: Database } = await import("./better-sqlite3-stub.js");
+    const dbInst = new Database();
+    expect(dbInst).toBeInstanceOf(Database);
+    expect(() => dbInst.prepare()).toThrow(/not available on Workers/);
+    // Lifecycle no-ops don't throw.
+    expect(() => dbInst.exec()).not.toThrow();
+    expect(() => dbInst.close()).not.toThrow();
+  });
+});

package/src/shims/drizzle-better-sqlite3.js

@@ -0,0 +1,33 @@
+// Creek build-time swap for `drizzle-orm/better-sqlite3` → Cloudflare D1.
+//
+// Only active in the Creek/Workers build (aliased by adapter-creek's
+// modifyConfig); local dev keeps the real better-sqlite3 driver. The user's
+// `drizzle(new Database(...), config)` call is preserved verbatim — we ignore
+// the local client and back the same Drizzle instance with the request's D1
+// binding instead, resolved lazily so it works at module scope (env.DB is
+// only available per-request via AsyncLocalStorage).
+import { drizzle as drizzleD1 } from "drizzle-orm/d1";
+
+const lazyD1 = new Proxy(
+  {},
+  {
+    get(_t, prop) {
+      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.",
+        );
+      }
+      const v = db[prop];
+      return typeof v === "function" ? v.bind(db) : v;
+    },
+  },
+);
+
+export function drizzle(_client, config) {
+  // _client is the user's better-sqlite3 instance — ignored on Workers.
+  return drizzleD1(lazyD1, config);
+}
+
+export default drizzle;