@solcreek/adapter-creek 0.1.1 → 0.1.3

package/dist/cache-handler.d.ts

@@ -1,32 +1,2 @@
-/**
- * Cache handler for Next.js ISR on Cloudflare Workers.
- *
- * Implements the cacheHandler interface (get/set/revalidateTag/resetRequestCache).
- * Uses in-memory Map for single-instance caching.
- *
- * TODO: Phase 2 — migrate to Durable Objects for persistent, multi-instance cache
- * with tag-based invalidation via DOShardedTagCache.
- */
-export default class CacheHandler {
-    constructor(_ctx?: unknown);
-    get(key: string, _ctx?: {
-        kind?: string;
-    }): Promise<{
-        value: unknown;
-        lastModified: number;
-        age: number;
-        cacheState: "stale";
-    } | {
-        value: unknown;
-        lastModified: number;
-        age: number;
-        cacheState: "fresh";
-    } | null>;
-    set(key: string, data: unknown | null, ctx?: {
-        tags?: string[];
-        revalidate?: number | false;
-    }): Promise<void>;
-    revalidateTag(tag: string | string[]): Promise<void>;
-    resetRequestCache(): void;
-}
+export { default } from "@solcreek/adapter-core/cache-handler";
 //# sourceMappingURL=cache-handler.d.ts.map

package/dist/cache-handler.js

@@ -1,100 +1,10 @@
-/**
- * Cache handler for Next.js ISR on Cloudflare Workers.
- *
- * Implements the cacheHandler interface (get/set/revalidateTag/resetRequestCache).
- * Uses in-memory Map for single-instance caching.
- *
- * TODO: Phase 2 — migrate to Durable Objects for persistent, multi-instance cache
- * with tag-based invalidation via DOShardedTagCache.
- */
-const cache = new Map();
-const tagToKeys = new Map();
-// When a tag is invalidated via revalidateTag(), we record the wall-clock
-// timestamp here. Subsequent get() calls compare this against the entry's
-// lastModified — if the tag was invalidated AFTER the entry was written,
-// the entry is treated as stale (cacheState: "stale") rather than missing.
+// Re-export the shared in-memory Next.js ISR cache handler from
+// @solcreek/adapter-core. The implementation now lives there so both
+// adapter-creek and adapter-creekd can share a single tested copy.
 //
-// This implements stale-while-revalidate semantics: Next.js receives the
-// old value plus the stale signal and decides to serve it while triggering
-// a background re-render. Aligned with opennextjs-cloudflare#1168.
-const tagInvalidatedAt = new Map();
-function isStaleByTags(entry) {
-    for (const tag of entry.tags) {
-        const invalidatedAt = tagInvalidatedAt.get(tag);
-        if (invalidatedAt !== undefined && invalidatedAt > entry.lastModified) {
-            return true;
-        }
-    }
-    return false;
-}
-export default class CacheHandler {
-    constructor(_ctx) {
-        // Context includes serverDistDir, dev, etc.
-        // Not needed for in-memory implementation.
-    }
-    async get(key, _ctx) {
-        const entry = cache.get(key);
-        if (!entry)
-            return null;
-        const age = (Date.now() - entry.lastModified) / 1000;
-        // Stale if either (a) any of its tags was invalidated since write, or
-        // (b) time-based revalidate has elapsed.
-        const staleByTag = isStaleByTags(entry);
-        const staleByTime = entry.revalidate !== undefined &&
-            entry.revalidate !== false &&
-            (entry.revalidate === 0 || age > entry.revalidate);
-        if (staleByTag || staleByTime) {
-            return {
-                value: entry.value,
-                lastModified: entry.lastModified,
-                age: Math.floor(age),
-                cacheState: "stale",
-            };
-        }
-        return {
-            value: entry.value,
-            lastModified: entry.lastModified,
-            age: Math.floor(age),
-            cacheState: "fresh",
-        };
-    }
-    async set(key, data, ctx) {
-        if (data === null) {
-            cache.delete(key);
-            return;
-        }
-        const tags = ctx?.tags ?? [];
-        const revalidate = typeof ctx?.revalidate === "number" ? ctx.revalidate : undefined;
-        cache.set(key, {
-            value: data,
-            lastModified: Date.now(),
-            tags,
-            revalidate,
-        });
-        // Index by tags for revalidateTag()
-        for (const tag of tags) {
-            let keys = tagToKeys.get(tag);
-            if (!keys) {
-                keys = new Set();
-                tagToKeys.set(tag, keys);
-            }
-            keys.add(key);
-        }
-    }
-    async revalidateTag(tag) {
-        const tags = Array.isArray(tag) ? tag : [tag];
-        const now = Date.now();
-        // Mark each tag as invalidated NOW. Existing entries become stale on
-        // the next get(); fresh writes (lastModified > now) are unaffected.
-        // We do NOT delete entries — Next.js wants to serve them as stale
-        // while it re-renders in the background.
-        for (const t of tags) {
-            tagInvalidatedAt.set(t, now);
-        }
-    }
-    resetRequestCache() {
-        // No per-request cache to reset in this implementation.
-    }
-}
-;
+// This file exists for backwards compatibility: users who set
+// `cacheHandler: require.resolve("@solcreek/adapter-creek/cache-handler")`
+// in their next.config continue to work without changes. New users
+// can wire either path; both resolve to the same module at runtime.
+export { default } from "@solcreek/adapter-core/cache-handler";
 //# sourceMappingURL=cache-handler.js.map

package/dist/index.js

@@ -1,221 +1,33 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { applyBaseModifyConfig } from "@solcreek/adapter-core";
 import { handleBuild } from "./build.js";
-/**
- * Detect the monorepo root by walking up looking for workspace markers.
- */
-function findRepoRoot(startDir) {
-    let dir = startDir;
-    while (true) {
-        if (existsSync(path.join(dir, "pnpm-workspace.yaml")) ||
-            existsSync(path.join(dir, "turbo.json"))) {
-            return dir;
-        }
-        const pkgPath = path.join(dir, "package.json");
-        if (existsSync(pkgPath)) {
-            try {
-                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-                if (pkg.workspaces)
-                    return dir;
-            }
-            catch { }
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return startDir;
-}
-/**
- * Detect direct dependencies whose `.js` entry files contain JSX.
- *
- * Turbopack at the pinned Next.js canary has a regression where it fails
- * to parse JSX inside `.js` files shipped by a workspace-linked / third-
- * party package (exit message: `Expected ';', got 'ident'`). The
- * documented fix is to add the package to `transpilePackages` so Next.js
- * runs SWC over it. Vanilla `next build` fails identically on these
- * fixtures without our adapter — but user apps don't get to edit their
- * own `next.config.js` just because we say so, so we auto-inject.
- *
- * Scope: only DIRECT deps. Transitive deps are either already transpiled
- * by their publisher (the common case) or reachable through the direct
- * dep we pick up. Walking all of node_modules would be slow and catch
- * unrelated packages.
- *
- * Detection: we resolve each dep's entry file (`package.json#exports["."]`
- * or `main`) and heuristically look for JSX with strong React hints.
- * False positives cost a little build time (Next.js transpiles an
- * already-ES-code package); false negatives are the status quo. The
- * heuristic is conservative — we require BOTH a JSX construct AND a
- * React signal ('use client' / react import / createElement) to claim
- * a package needs transpile.
- */
-function detectPackagesNeedingTranspile(projectDir) {
-    let projectPkg;
-    try {
-        projectPkg = JSON.parse(readFileSync(path.join(projectDir, "package.json"), "utf-8"));
-    }
-    catch {
-        return [];
-    }
-    const directDeps = new Set();
-    for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
-        const map = projectPkg[field];
-        if (map && typeof map === "object") {
-            for (const name of Object.keys(map))
-                directDeps.add(name);
-        }
-    }
-    if (directDeps.size === 0)
-        return [];
-    // Don't ever try to transpile Next.js itself or the React runtimes —
-    // they're pre-bundled and transpilePackages on them would be an
-    // expensive no-op at best, a breakage at worst.
-    const SKIP = new Set([
-        "next", "react", "react-dom", "react-server-dom-webpack",
-        "react-dom/server", "scheduler", "@next/routing", "@next/swc",
-        "@solcreek/adapter-creek",
-    ]);
-    const needsTranspile = [];
-    for (const dep of directDeps) {
-        if (SKIP.has(dep))
-            continue;
-        // Ignore subpath-qualified entries that aren't real packages (shouldn't
-        // show up in dependencies, but be defensive).
-        if (dep.includes("/") && !dep.startsWith("@"))
-            continue;
-        // Locate the package root via direct node_modules path. Can't use
-        // `require.resolve(dep + '/package.json')` — Node's resolver honors
-        // the `exports` field and most packages don't expose `./package.json`.
-        // pnpm's flat node_modules layout hoists a symlink at
-        // `node_modules/<dep>` for every direct + hoisted dep, so this works
-        // across npm, yarn, pnpm.
-        const pkgRoot = path.join(projectDir, "node_modules", dep);
-        const pkgJsonPath = path.join(pkgRoot, "package.json");
-        let pkgJson;
-        try {
-            pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-        }
-        catch {
-            continue;
-        }
-        // Skip packages that declare themselves ES (module field points at
-        // .mjs) AND ship no .js siblings — transpile wouldn't kick in for
-        // them anyway. We still process packages whose `main` is a .js.
-        const entryCandidates = collectEntryFiles(pkgJson, pkgRoot);
-        if (entryCandidates.length === 0)
-            continue;
-        for (const entry of entryCandidates) {
-            try {
-                const content = readFileSync(entry, "utf-8");
-                if (looksLikeJsxInJs(content, entry)) {
-                    needsTranspile.push(dep);
-                    break; // one hit is enough; move to next package
-                }
-            }
-            catch { }
-        }
-    }
-    return needsTranspile;
-}
-/**
- * Pick the `.js` entry file(s) for a package. Only files that end in `.js`
- * (and not `.mjs` / `.cjs`) are eligible — the others are either module-
- * specific formats (where Turbopack's JSX-in-JS bug doesn't apply) or
- * already indicate transpilation happened upstream.
- */
-function collectEntryFiles(pkgJson, pkgRoot) {
-    const candidates = [];
-    const tryAdd = (rel) => {
-        if (typeof rel !== "string")
-            return;
-        if (!rel.endsWith(".js"))
-            return;
-        const abs = path.join(pkgRoot, rel.startsWith("./") ? rel.slice(2) : rel);
-        try {
-            if (statSync(abs).isFile())
-                candidates.push(abs);
-        }
-        catch { }
-    };
-    tryAdd(pkgJson.main);
-    // `exports` can be a string, or a nested conditional object. We walk
-    // the "." entry's import/require/default branches.
-    const exports_ = pkgJson.exports;
-    if (typeof exports_ === "string") {
-        tryAdd(exports_);
-    }
-    else if (exports_ && typeof exports_ === "object") {
-        const rootExport = exports_["."] ?? exports_;
-        if (typeof rootExport === "string") {
-            tryAdd(rootExport);
-        }
-        else if (rootExport && typeof rootExport === "object") {
-            for (const cond of ["default", "import", "require", "node", "browser"]) {
-                tryAdd(rootExport[cond]);
-            }
-        }
-    }
-    return [...new Set(candidates)];
-}
-/**
- * Heuristic: a `.js` file looks like it contains JSX if it has at least
- * one JSX-ish token AND at least one React signal. Both conditions keeps
- * false positives low (e.g. plain TS generics `function f<T>()` without
- * React imports won't trigger).
- */
-function looksLikeJsxInJs(content, filePath) {
-    if (!filePath.endsWith(".js"))
-        return false;
-    const head = content.slice(0, 20_000); // cap scan cost
-    const JSX_HINTS = [
-        /return\s*\(\s*</, // return (<...
-        /return\s+<[A-Za-z]/, // return <Tag or <Component
-        /=>\s*<[A-Za-z]/, // arrow => <...
-        /\bcreateElement\s*\(/, // raw createElement
-    ];
-    const hasJsxHint = JSX_HINTS.some((re) => re.test(head));
-    if (!hasJsxHint)
-        return false;
-    const REACT_HINTS = [
-        /['"]use client['"]/,
-        /from\s+['"]react['"]/,
-        /require\s*\(\s*['"]react['"]\s*\)/,
-        /\bReact\.createElement\b/,
-    ];
-    return REACT_HINTS.some((re) => re.test(head));
-}
-const cacheHandlerPath = fileURLToPath(new URL("./cache-handler.js", import.meta.url));
+// Dev-fallback path to the cache handler shipped by @solcreek/adapter-core.
+// applyBaseModifyConfig prefers the node_modules-installed copy when one
+// exists (the production path); this resolves the package's own bundled
+// copy as a last resort for the rare case where the adapter is used
+// without `npm install`ing it.
+const coreEntryUrl = new URL("../node_modules/@solcreek/adapter-core/dist/cache-handler.js", import.meta.url);
+const fallbackCacheHandlerPath = existsSync(fileURLToPath(coreEntryUrl))
+    ? fileURLToPath(coreEntryUrl)
+    : path.join(process.cwd(), "node_modules", "@solcreek", "adapter-core", "dist", "cache-handler.js");
 const adapter = {
     name: "adapter-creek",
-    modifyConfig(config, { phase }) {
-        if (phase !== "phase-production-build")
-            return config;
-        const projectDir = process.cwd();
-        const repoRoot = findRepoRoot(projectDir);
-        const isMonorepo = repoRoot !== projectDir;
-        const installedCacheHandlerPath = path.join(projectDir, "node_modules", "@solcreek", "adapter-creek", "dist", "cache-handler.js");
-        const resolvedCacheHandlerPath = existsSync(installedCacheHandlerPath)
-            ? installedCacheHandlerPath
-            : cacheHandlerPath;
-        // Auto-add any direct dep that ships JSX in `.js` to transpilePackages.
-        // Works around a Turbopack regression where JSX inside `.js` files from
-        // a workspace-linked / third-party package fails to parse with
-        // `Expected ';', got 'ident'`. The documented upstream fix is exactly
-        // `transpilePackages: [pkg]`; doing this here means user apps don't
-        // have to know about it.
-        const detected = detectPackagesNeedingTranspile(projectDir);
-        const existing = Array.isArray(config.transpilePackages) ? config.transpilePackages : [];
-        const transpilePackages = detected.length > 0
-            ? [...new Set([...existing, ...detected])]
-            : existing;
-        if (detected.length > 0) {
-            console.log(`  [Creek Adapter] auto-transpile: ${JSON.stringify(detected)} (JSX in .js entry)`);
-        }
+    modifyConfig(config, ctx) {
+        // First apply the shared base — auto-transpile, monorepo tracing
+        // root, TS error suppression, cache handler wiring.
+        const baseConfig = applyBaseModifyConfig(config, ctx, {
+            logLabel: "Creek Adapter",
+            cacheHandlerPath: fallbackCacheHandlerPath,
+        });
+        // Then layer CF-Workers-specific knobs on top. These only apply at
+        // production build phase; applyBaseModifyConfig is a passthrough
+        // for other phases, so guarding here matches its behaviour.
+        if (ctx.phase !== "phase-production-build")
+            return baseConfig;
         return {
-            ...config,
+            ...baseConfig,
             // Disable memory cache — CF Workers doesn't have persistent fs.
             // The runtime cache handler is inlined in the worker entry (CreekCacheHandler).
             cacheMaxMemorySize: 0,
@@ -225,18 +37,9 @@ const adapter = {
             // → safely under limit. Real PPR fallback shells are typically ≤ a few
             // KB anyway, so this cap is purely defensive.
             experimental: {
-                ...(config.experimental ?? {}),
+                ...(baseConfig.experimental ?? {}),
                 maxPostponedStateSize: "20mb",
             },
-            // Skip TypeScript type checking during build — CF Workers adapter
-            // builds run `next build` where TS errors block the build. Type
-            // checking should happen before deployment, not during bundling.
-            typescript: { ...config.typescript, ignoreBuildErrors: true },
-            ...(transpilePackages.length > 0 && { transpilePackages }),
-            // Monorepo: set tracing root so Next.js traces deps from repo root
-            ...(isMonorepo && {
-                outputFileTracingRoot: repoRoot,
-            }),
         };
     },
     async onBuildComplete(ctx) {

package/dist/worker-entry.js

@@ -333,8 +333,17 @@ if (typeof process !== "undefined") {
     }, { bigint: () => BigInt(Math.floor(performance.now() * 1e6)) });
   }
   if (!process.on) process.on = () => process;
-  if (!process.removeListener) process.removeListener = () => process;
   if (!process.off) process.off = () => process;
+  if (!process.removeListener) process.removeListener = () => process;
+  if (!process.removeAllListeners) process.removeAllListeners = () => process;
+  if (!process.listeners) process.listeners = () => [];
+  if (!process.listenerCount) process.listenerCount = () => 0;
+  if (!process.rawListeners) process.rawListeners = () => [];
+  if (!process.emit) process.emit = () => false;
+  if (!process.prependListener) process.prependListener = () => process;
+  if (!process.prependOnceListener) process.prependOnceListener = () => process;
+  if (!process.once) process.once = () => process;
+  if (!process.addListener) process.addListener = () => process;
 }
 
 import { resolveRoutes, responseToMiddlewareResult } from "@next/routing";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/adapter-creek",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Next.js deployment adapter for Creek (Cloudflare Workers)",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@next/routing": "16.2.3",
-    "@node-rs/xxhash": "^1.7.6",
+    "@solcreek/adapter-core": "^0.1.0",
     "sql.js": "^1.14.1",
     "wrangler": "^4.82.2"
   },
@@ -53,6 +53,7 @@
     "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/net.js

@@ -0,0 +1,44 @@
+// Minimal node:net shim for CF Workers.
+// Only Socket is needed — Next.js passes it to the http shim's
+// IncomingMessage as `socket` but never actually connects.
+
+import { EventEmitter } from "node:events";
+
+export class Socket extends EventEmitter {
+  constructor() {
+    super();
+    this.writable = true;
+    this.readable = true;
+    this.encrypted = false;
+    this.remoteAddress = "127.0.0.1";
+    this.remotePort = 0;
+    this.localAddress = "127.0.0.1";
+    this.localPort = 0;
+  }
+  address() { return { address: "127.0.0.1", family: "IPv4", port: 443 }; }
+  connect() { return this; }
+  write() { return true; }
+  end() { this.emit("close"); return this; }
+  destroy() { this.emit("close"); return this; }
+  setTimeout() { return this; }
+  setNoDelay() { return this; }
+  setKeepAlive() { return this; }
+  ref() { return this; }
+  unref() { return this; }
+}
+
+export class Server extends EventEmitter {
+  constructor() { super(); }
+  listen() { return this; }
+  close() { return this; }
+  address() { return null; }
+}
+
+export function createServer() { return new Server(); }
+export function createConnection() { return new Socket(); }
+export function connect() { return new Socket(); }
+export function isIP() { return 0; }
+export function isIPv4() { return false; }
+export function isIPv6() { return false; }
+
+export default { Socket, Server, createServer, createConnection, connect, isIP, isIPv4, isIPv6 };