@solcreek/cli 0.4.29 → 0.4.31

package/dist/commands/deploy.js

@@ -8,6 +8,7 @@ import { CreekClient, CreekAuthError, detectFramework, resolveConfig, formatDete
 import { buildDoctorContext } from "../utils/doctor-context.js";
 import { getToken, getApiUrl } from "../utils/config.js";
 import { collectAssets } from "../utils/bundle.js";
+import { runDatabasePreflight, makePreflightIO, readProjectDeps } from "../utils/db-preflight.js";
 import { sandboxDeploy, pollSandboxStatus, printSandboxSuccess, expiresInMinutes } from "../utils/sandbox.js";
 import { prepareDeployBundle } from "../utils/prepare-bundle.js";
 import { BuildLogEmitter } from "../utils/build-log.js";
@@ -345,6 +346,19 @@ export const deployCommand = defineCommand({
                 throw err;
         }
         if (resolved) {
+            // Database deploy preflight: when the app uses Prisma/Drizzle on SQLite
+            // but creek.toml hasn't declared a database, confirm provisioning a D1
+            // (a cloud instance, separate from the local file) and re-resolve so the
+            // binding is included in this deploy. Confirm-first; no-op when already
+            // decided or non-interactive without --yes.
+            const dbPreflight = await runDatabasePreflight({
+                deps: readProjectDeps(cwd),
+                projectName: resolved.projectName,
+                tty: isTTY && !jsonMode,
+                autoYes: shouldAutoConfirm(args),
+            }, makePreflightIO(cwd));
+            if (dbPreflight.wroteToml)
+                resolved = resolveConfig(cwd);
             if (!jsonMode) {
                 consola.info(`  Detected: ${formatDetectionSummary(resolved)}`);
                 for (const ub of resolved.unsupportedBindings) {

package/dist/utils/db-preflight.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Database deploy preflight: detect → confirm helpers.
+ *
+ * An app that uses Prisma or Drizzle on local SQLite runs on a Cloudflare D1
+ * database on Creek (a separate cloud instance from the local file). Getting
+ * there needs `database = true` under `[resources]` in creek.toml and, for
+ * Prisma, a generated client. These pure helpers detect that situation and
+ * patch creek.toml; the actual prompts, file writes, and `creek db migrate`
+ * are wired by the deploy command so the consequential steps stay behind
+ * explicit consent (see the deploy flow).
+ *
+ * Design split by risk: client generation is safe to automate; provisioning a
+ * (billed) database is confirm-first; applying migrations is never silent.
+ *
+ * Pure functions are exported for testing.
+ */
+export type SqliteOrm = "prisma" | "drizzle";
+/**
+ * Detect an ORM configured against local SQLite — the case Creek swaps onto
+ * D1. The signal is the presence of the better-sqlite3 driver/adapter the
+ * adapter-creek build-time swap targets:
+ *  - Prisma: `@prisma/adapter-better-sqlite3`
+ *  - Drizzle: `drizzle-orm` + `better-sqlite3`
+ *
+ * Returns null when neither is present (e.g. an app on an external DB, or
+ * Drizzle pointed straight at `drizzle-orm/d1`), so we never guess a database
+ * the project didn't ask for.
+ */
+export declare function detectSqliteOrm(deps: Record<string, string | undefined>): SqliteOrm | null;
+export type DatabaseDirective = "enabled" | "disabled" | "absent";
+/**
+ * Read the `[resources].database` directive from raw creek.toml text — NOT the
+ * SDK-parsed config, because the parser defaults `database` to `false` and so
+ * can't tell "explicitly opted out" from "never decided". The distinction
+ * drives whether we may prompt:
+ *  - "enabled"  → already on, nothing to do
+ *  - "disabled" → explicit opt-out, never prompt
+ *  - "absent"   → undecided, eligible to prompt
+ */
+export declare function databaseDirectiveState(rawToml: string | null): DatabaseDirective;
+/**
+ * Patch raw creek.toml to enable the database resource, preserving existing
+ * content (so the file stays reviewable). Only called when the directive is
+ * "absent". Handles: no file, `[resources]` present (insert the key), and
+ * `[resources]` missing (append the section, prepending `[project]` when the
+ * file has none so the result is a valid creek.toml).
+ */
+export declare function enableDatabaseResource(rawToml: string | null, projectName: string): string;
+/**
+ * Whether the project uses Prisma and its client hasn't been generated yet.
+ * Safe to act on automatically (generation is idempotent, no external effect).
+ * Conservative: only true when a schema exists, declares an `output`, and that
+ * directory is missing — otherwise we leave the user's setup untouched.
+ */
+export declare function prismaNeedsGenerate(cwd: string): boolean;
+/**
+ * Side-effect surface for the database preflight, injected so the decision flow
+ * is testable without a real terminal or filesystem. `confirm` resolves the
+ * interactive yes/no; `readToml`/`writeToml` are the raw creek.toml.
+ */
+export interface PreflightIO {
+    readToml(): string | null;
+    writeToml(content: string): void;
+    confirm(message: string): Promise<boolean>;
+    log(message: string): void;
+    warn(message: string): void;
+}
+export interface PreflightOptions {
+    deps: Record<string, string | undefined>;
+    projectName: string;
+    /** Interactive terminal — may prompt. */
+    tty: boolean;
+    /** `--yes`: auto-accept the (low-risk) DB-resource provisioning. */
+    autoYes: boolean;
+}
+export interface PreflightResult {
+    /** creek.toml was patched — the caller must re-resolve config before deploy. */
+    wroteToml: boolean;
+}
+/**
+ * Confirm-first database provisioning. When the project uses an ORM on SQLite
+ * but creek.toml hasn't decided on a database resource, prompt (or auto-accept
+ * under --yes) to add `database = true`. Never overrides an explicit opt-out,
+ * never prompts in non-interactive contexts (warns and continues — the deploy
+ * still succeeds and DB routes return a self-documenting hint at runtime).
+ */
+export declare function runDatabasePreflight(opts: PreflightOptions, io: PreflightIO): Promise<PreflightResult>;
+/**
+ * What to do about a detected migration directory after the database exists.
+ * Migrations can be destructive, so this is never silent:
+ *  - "run"     → explicit opt-in (`--migrate`)
+ *  - "prompt"  → interactive (ask, default no)
+ *  - "suggest" → non-interactive (print the command, don't run)
+ *  - "none"    → no migrations to apply
+ */
+export declare function migrationOfferPlan(opts: {
+    migrationDir: string | null;
+    tty: boolean;
+    autoMigrate: boolean;
+}): "run" | "prompt" | "suggest" | "none";
+/** Merged dependencies + devDependencies from the project's package.json. */
+export declare function readProjectDeps(cwd: string): Record<string, string | undefined>;
+/** Real (consola + filesystem) PreflightIO for the deploy command. */
+export declare function makePreflightIO(cwd: string): PreflightIO;
+//# sourceMappingURL=db-preflight.d.ts.map

package/dist/utils/db-preflight.js

@@ -0,0 +1,199 @@
+/**
+ * Database deploy preflight: detect → confirm helpers.
+ *
+ * An app that uses Prisma or Drizzle on local SQLite runs on a Cloudflare D1
+ * database on Creek (a separate cloud instance from the local file). Getting
+ * there needs `database = true` under `[resources]` in creek.toml and, for
+ * Prisma, a generated client. These pure helpers detect that situation and
+ * patch creek.toml; the actual prompts, file writes, and `creek db migrate`
+ * are wired by the deploy command so the consequential steps stay behind
+ * explicit consent (see the deploy flow).
+ *
+ * Design split by risk: client generation is safe to automate; provisioning a
+ * (billed) database is confirm-first; applying migrations is never silent.
+ *
+ * Pure functions are exported for testing.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import consola from "consola";
+/**
+ * Detect an ORM configured against local SQLite — the case Creek swaps onto
+ * D1. The signal is the presence of the better-sqlite3 driver/adapter the
+ * adapter-creek build-time swap targets:
+ *  - Prisma: `@prisma/adapter-better-sqlite3`
+ *  - Drizzle: `drizzle-orm` + `better-sqlite3`
+ *
+ * Returns null when neither is present (e.g. an app on an external DB, or
+ * Drizzle pointed straight at `drizzle-orm/d1`), so we never guess a database
+ * the project didn't ask for.
+ */
+export function detectSqliteOrm(deps) {
+    if (deps["@prisma/adapter-better-sqlite3"])
+        return "prisma";
+    if (deps["drizzle-orm"] && deps["better-sqlite3"])
+        return "drizzle";
+    return null;
+}
+/**
+ * Read the `[resources].database` directive from raw creek.toml text — NOT the
+ * SDK-parsed config, because the parser defaults `database` to `false` and so
+ * can't tell "explicitly opted out" from "never decided". The distinction
+ * drives whether we may prompt:
+ *  - "enabled"  → already on, nothing to do
+ *  - "disabled" → explicit opt-out, never prompt
+ *  - "absent"   → undecided, eligible to prompt
+ */
+export function databaseDirectiveState(rawToml) {
+    if (!rawToml)
+        return "absent";
+    let inResources = false;
+    for (const rawLine of rawToml.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line.startsWith("[")) {
+            // A new table header. `[resources]` exactly; `[resources.x]` is a
+            // different (sub)table and doesn't carry the boolean directive.
+            inResources = line === "[resources]";
+            continue;
+        }
+        if (!inResources)
+            continue;
+        const m = line.match(/^database\s*=\s*(true|false)\b/);
+        if (m)
+            return m[1] === "true" ? "enabled" : "disabled";
+    }
+    return "absent";
+}
+/**
+ * Patch raw creek.toml to enable the database resource, preserving existing
+ * content (so the file stays reviewable). Only called when the directive is
+ * "absent". Handles: no file, `[resources]` present (insert the key), and
+ * `[resources]` missing (append the section, prepending `[project]` when the
+ * file has none so the result is a valid creek.toml).
+ */
+export function enableDatabaseResource(rawToml, projectName) {
+    const resourcesBlock = "[resources]\ndatabase = true\n";
+    if (rawToml === null || rawToml.trim() === "") {
+        return `[project]\nname = "${projectName}"\n\n${resourcesBlock}`;
+    }
+    const lines = rawToml.split(/\r?\n/);
+    const resourcesIdx = lines.findIndex((l) => l.trim() === "[resources]");
+    if (resourcesIdx !== -1) {
+        // Insert the key directly under the existing header.
+        lines.splice(resourcesIdx + 1, 0, "database = true");
+        return lines.join("\n");
+    }
+    // No [resources] table — append one, ensuring a [project] table exists.
+    const hasProject = lines.some((l) => l.trim() === "[project]");
+    const trimmed = rawToml.replace(/\s*$/, "");
+    const prefix = hasProject ? "" : `[project]\nname = "${projectName}"\n\n`;
+    const sep = trimmed === "" ? "" : "\n\n";
+    return `${prefix}${trimmed}${sep}${resourcesBlock}`;
+}
+/**
+ * Read the generator `output` path from a Prisma schema (Prisma 7's
+ * `prisma-client` generator requires one). Returns an absolute path or null.
+ */
+function prismaClientOutput(cwd, schemaPath) {
+    let schema;
+    try {
+        schema = readFileSync(schemaPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const m = schema.match(/\boutput\s*=\s*"([^"]+)"/);
+    if (!m)
+        return null;
+    const out = m[1];
+    return out.startsWith("/") ? out : join(cwd, "prisma", out);
+}
+/**
+ * Whether the project uses Prisma and its client hasn't been generated yet.
+ * Safe to act on automatically (generation is idempotent, no external effect).
+ * Conservative: only true when a schema exists, declares an `output`, and that
+ * directory is missing — otherwise we leave the user's setup untouched.
+ */
+export function prismaNeedsGenerate(cwd) {
+    const schemaPath = join(cwd, "prisma", "schema.prisma");
+    if (!existsSync(schemaPath))
+        return false;
+    const out = prismaClientOutput(cwd, schemaPath);
+    if (!out)
+        return false;
+    return !existsSync(out);
+}
+const ORM_LABEL = {
+    prisma: "Prisma",
+    drizzle: "Drizzle",
+};
+/**
+ * Confirm-first database provisioning. When the project uses an ORM on SQLite
+ * but creek.toml hasn't decided on a database resource, prompt (or auto-accept
+ * under --yes) to add `database = true`. Never overrides an explicit opt-out,
+ * never prompts in non-interactive contexts (warns and continues — the deploy
+ * still succeeds and DB routes return a self-documenting hint at runtime).
+ */
+export async function runDatabasePreflight(opts, io) {
+    const orm = detectSqliteOrm(opts.deps);
+    if (!orm)
+        return { wroteToml: false };
+    const state = databaseDirectiveState(io.readToml());
+    if (state !== "absent")
+        return { wroteToml: false }; // already enabled or opted out
+    if (!opts.tty && !opts.autoYes) {
+        io.warn(`Detected ${ORM_LABEL[orm]} on better-sqlite3 but creek.toml has no [resources] database. ` +
+            "Database routes will fail until you add `database = true` (run deploy in a terminal, or pass --yes).");
+        return { wroteToml: false };
+    }
+    const accepted = opts.autoYes
+        ? true
+        : await io.confirm(`Detected ${ORM_LABEL[orm]} on better-sqlite3. On Creek this runs on a Cloudflare D1 ` +
+            "database in the cloud — a separate instance from your local file (local data is not " +
+            "copied). Add `database = true` under [resources] to creek.toml?");
+    if (!accepted) {
+        io.log("Skipped. Database routes will return a setup hint until you add `database = true` to creek.toml.");
+        return { wroteToml: false };
+    }
+    io.writeToml(enableDatabaseResource(io.readToml(), opts.projectName));
+    io.log("Enabled [resources] database in creek.toml (cloud D1 — separate from your local file).");
+    return { wroteToml: true };
+}
+/**
+ * What to do about a detected migration directory after the database exists.
+ * Migrations can be destructive, so this is never silent:
+ *  - "run"     → explicit opt-in (`--migrate`)
+ *  - "prompt"  → interactive (ask, default no)
+ *  - "suggest" → non-interactive (print the command, don't run)
+ *  - "none"    → no migrations to apply
+ */
+export function migrationOfferPlan(opts) {
+    if (!opts.migrationDir)
+        return "none";
+    if (opts.autoMigrate)
+        return "run";
+    return opts.tty ? "prompt" : "suggest";
+}
+/** Merged dependencies + devDependencies from the project's package.json. */
+export function readProjectDeps(cwd) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+        return { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    }
+    catch {
+        return {};
+    }
+}
+/** Real (consola + filesystem) PreflightIO for the deploy command. */
+export function makePreflightIO(cwd) {
+    const tomlPath = join(cwd, "creek.toml");
+    return {
+        readToml: () => (existsSync(tomlPath) ? readFileSync(tomlPath, "utf-8") : null),
+        writeToml: (content) => writeFileSync(tomlPath, content),
+        // DB provisioning is low-risk → default to yes.
+        confirm: async (message) => (await consola.prompt(message, { type: "confirm", initial: true })),
+        log: (message) => consola.success(`  ${message}`),
+        warn: (message) => consola.warn(`  ${message}`),
+    };
+}
+//# sourceMappingURL=db-preflight.js.map

package/dist/utils/nextjs.js

@@ -15,6 +15,7 @@ import { join, dirname, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { execSync, execFileSync } from "node:child_process";
 import consola from "consola";
+import { prismaNeedsGenerate } from "./db-preflight.js";
 // ---------------------------------------------------------------------------
 // Version detection + unified entry point
 // ---------------------------------------------------------------------------
@@ -128,6 +129,7 @@ export function buildNextjs(cwd, isMonorepo, projectName) {
     if (version && semverGte(version, "16.2.3")) {
         const adapterPath = ensureAdapter(cwd);
         if (adapterPath) {
+            ensurePrismaClient(cwd);
             ensurePrismaD1(cwd);
             buildWithAdapter(cwd, adapterPath);
             return;
@@ -210,12 +212,17 @@ const ADAPTER_VERSION = "^0.2.2";
 // adapter and imports @prisma/adapter-d1 (an optional peer it doesn't ship).
 const PRISMA_BSQLITE_PKG = "@prisma/adapter-better-sqlite3";
 const PRISMA_D1_PKG = "@prisma/adapter-d1";
-// Adapter < 0.2.2 resolves its dependencies against paths that don't exist
-// under the .creek lazy install (0.2.0: the cache handler; 0.2.1: the
-// wrangler bin) — npm hoists them to the top of the tree, so the adapter's
-// guessed nested paths fail every Next.js build. Installs below this are
-// re-installed, not reused.
-const ADAPTER_MIN_VERSION = "0.2.2";
+// Minimum adapter the CLI will REUSE from a prior .creek install; older
+// cached copies are force-reinstalled. Each bump tracks a deploy-critical
+// adapter fix that a stale cache would silently miss:
+//   0.2.2 — wrangler resolved via module resolution (not a nested .bin guess)
+//   0.2.6 — better-sqlite3 stubbed (else the native module inlines → a ~200MB
+//           worker that only fails at upload with "Payload Too Large")
+//   0.2.7 — zero-change Prisma-on-D1 swap
+//   0.2.10 — oversized-bundle fail-fast
+// Kept at the latest because the reinstall cost is trivial and a cached copy
+// in the 0.2.2–0.2.5 window builds successfully but produces a broken worker.
+const ADAPTER_MIN_VERSION = "0.2.10";
 /**
  * Merge a dependency into .creek/package.json without clobbering deps that
  * a previous install (adapter or opennext) may have already written.
@@ -288,6 +295,29 @@ function ensureAdapter(cwd) {
         consola.success(`  ${ADAPTER_PKG} installed`);
     return resolved;
 }
+/**
+ * Generate the Prisma client before the Next build when it's missing.
+ * Prisma 7's `prisma-client` generator emits to a configured `output` dir that
+ * the app imports; without it the build fails. Safe to run automatically —
+ * generation is idempotent and has no external/persistent effect. No-op unless
+ * a Prisma schema exists and its output dir is absent (see prismaNeedsGenerate).
+ */
+function ensurePrismaClient(cwd) {
+    if (!prismaNeedsGenerate(cwd))
+        return;
+    consola.start("  Generating Prisma client (prisma generate)...");
+    try {
+        // `--no-install` uses the project's own prisma (a dependency) rather than
+        // fetching one; the schema's datasource needs no URL to generate.
+        execSync("npx --no-install prisma generate", { cwd, stdio: "pipe" });
+        consola.success("  Prisma client generated");
+    }
+    catch (err) {
+        // Non-fatal: the build will surface a clearer "client not found" error if
+        // generation was genuinely required.
+        consola.warn(`  prisma generate failed (${err instanceof Error ? err.message : String(err)}); continuing`);
+    }
+}
 /**
  * Ensure @prisma/adapter-d1 is resolvable at build time for the zero-change
  * Prisma-on-D1 swap. adapter-creek aliases `@prisma/adapter-better-sqlite3` to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.29",
+  "version": "0.4.31",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",