@solcreek/adapter-creek 0.1.2 → 0.1.4

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,56 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { copyFileSync, 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;
+// 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");
+function mirrorCacheHandlerIntoProject(cacheHandlerPath) {
+    if (!existsSync(cacheHandlerPath))
+        return cacheHandlerPath;
+    const localPath = path.join(process.cwd(), ".solcreek-cache-handler.mjs");
+    if (path.resolve(cacheHandlerPath) === path.resolve(localPath))
+        return localPath;
     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);
-        }
+        copyFileSync(cacheHandlerPath, localPath);
+        return localPath;
     }
-    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 { }
-        }
+    catch (err) {
+        console.warn(`  [Creek Adapter] Failed to mirror cache-handler into project (${err instanceof Error ? err.message : String(err)}); falling back to ${cacheHandlerPath}`);
+        return cacheHandlerPath;
     }
-    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));
 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;
+        const cacheHandlerPath = typeof baseConfig.cacheHandler === "string"
+            ? mirrorCacheHandlerIntoProject(baseConfig.cacheHandler)
+            : mirrorCacheHandlerIntoProject(fallbackCacheHandlerPath);
         return {
-            ...config,
+            ...baseConfig,
+            // Next may dynamically import this cache handler on error/404 render
+            // paths. Keep it as a project-local sentinel path instead of a pnpm
+            // node_modules realpath; the Workers bundler redirects that sentinel
+            // to the inline CreekCacheHandler.
+            cacheHandler: cacheHandlerPath,
             // 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 +60,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/manifest.d.ts

@@ -4,15 +4,8 @@
  * Written to .creek/adapter-output/manifest.json after build.
  * Creek CLI reads this to know how to upload and deploy.
  */
-export interface DeployManifest {
-    /** Manifest schema version */
-    version: 1;
-    /** Next.js build ID */
-    buildId: string;
-    /** Next.js version used */
-    nextVersion: string;
-    /** Framework identifier */
-    framework: "nextjs";
+import type { DeployManifestBase } from "@solcreek/adapter-core";
+export interface DeployManifest extends DeployManifestBase {
     /** Main worker entry file name (relative to server/) */
     entrypoint: string;
     /** All files in server/ directory */

package/dist/manifest.js

@@ -6,12 +6,19 @@
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const adapterPackage = require("../package.json");
 export async function writeManifest(outputDir, opts) {
     const manifest = {
         version: 1,
         buildId: opts.buildId,
         nextVersion: opts.nextVersion,
         framework: "nextjs",
+        adapter: {
+            name: adapterPackage.name ?? "@solcreek/adapter-creek",
+            version: adapterPackage.version ?? "0.0.0",
+        },
         entrypoint: opts.entrypoint,
         serverFiles: opts.serverFiles,
         assetDir: "assets",