cloudflare-next-intl 0.8.9 → 0.8.10

package/README.md

@@ -778,6 +778,15 @@ them and fails naming the first one that is stale.
 npx cfni-db-codegen --out-dir=src/shared/db/generated --out-dir=../other-app/src/db/generated
 ```
 
+If no `--db-url`/`CODEGEN_DATABASE_URL` is set and nothing is reachable at the
+local Supabase default, `cfni-db-codegen` falls back to a throwaway,
+local-only Postgres started via the optional `embedded-postgres` package (a
+prebuilt binary, no Docker required): install it once with
+`npm install --save-dev embedded-postgres`, and no local DB setup is needed —
+the DDL in `--ddl-dir` is loaded into it, introspected, and it's torn down
+after. Passing an explicit `--db-url`/`CODEGEN_DATABASE_URL` skips this
+fallback entirely and fails loudly if that target is unreachable.
+
 ##### Keeping `cfni_exec.sql` in sync (`--rpc-dir`/`--rpc-file-name`/`--tests-dir`/`--tests-file-name`/`--force`/`--skip-exec`)
 
 After a successful (non-`--check`) run, `cfni-db-codegen` also copies

package/bin/db_codegen.mjs

@@ -37,26 +37,33 @@ import { join, relative } from 'node:path';
 import { Client } from 'pg';
 import resolveCodegenPaths from '../dist/src/db/codegen_paths.js';
 import { runInstallExecStep } from './install_exec_step.mjs';
+import { startEphemeralPostgres } from './ephemeral_pg.mjs';
 
 const paths = resolveCodegenPaths(process.argv.slice(2), process.env, process.cwd());
 
-async function assertReachable(url) {
+async function isReachable(url) {
     const client = new Client({ connectionString: url, connectionTimeoutMillis: paths.timeoutMs });
     try {
         await client.connect();
         await client.end();
-    } catch (error) {
+        return true;
+    } catch {
         await client.end().catch(() => { /* already failed to connect */ });
-        console.error(`❌ Could not reach Postgres at ${url}\n   (${error.message})`);
-        console.error("\n   drizzle-kit pull needs a live Postgres to introspect — any one works, this script has no Docker dependency of its own. Pick one:");
-        console.error("   - Local Supabase (needs Docker running):  ./supabase/scripts/db_start.sh --reset");
-        console.error("   - A native Postgres you already have:     CODEGEN_DATABASE_URL=postgresql://... npm run db:codegen");
-        console.error("   - A remote/staging database:              CODEGEN_DATABASE_URL=postgresql://... npm run db:codegen");
-        console.error(`   Slow/cold-starting target? Raise the timeout: CODEGEN_CONNECT_TIMEOUT_MS=15000 npm run db:codegen`);
-        process.exit(1);
+        return false;
     }
 }
 
+function failUnreachable(url) {
+    console.error(`❌ Could not reach Postgres at ${url}`);
+    console.error("\n   drizzle-kit pull needs a live Postgres to introspect — any one works, this script has no Docker dependency of its own. Pick one:");
+    console.error("   - Local Supabase (needs Docker running):  ./supabase/scripts/db_start.sh --reset");
+    console.error("   - A native Postgres you already have:     CODEGEN_DATABASE_URL=postgresql://... npm run db:codegen");
+    console.error("   - A remote/staging database:              CODEGEN_DATABASE_URL=postgresql://... npm run db:codegen");
+    console.error("   - Zero setup (no Docker/Postgres at all):  npm install --save-dev embedded-postgres  (auto-used as a fallback)");
+    console.error(`   Slow/cold-starting target? Raise the timeout: CODEGEN_CONNECT_TIMEOUT_MS=15000 npm run db:codegen`);
+    process.exit(1);
+}
+
 function sqlFiles(dir) {
     return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
         const path = join(dir, entry.name);
@@ -87,10 +94,24 @@ if (paths.check) {
     process.exit(0);
 }
 
-await assertReachable(paths.dbUrl);
+let effectiveDbUrl = paths.dbUrl;
+let ephemeral = null;
+if (!(await isReachable(paths.dbUrl))) {
+    if (paths.dbUrlExplicit) failUnreachable(paths.dbUrl);
+    ephemeral = await startEphemeralPostgres(paths.ephemeralDir, sqlFiles(paths.ddlDir));
+    if (!ephemeral) failUnreachable(paths.dbUrl);
+    effectiveDbUrl = ephemeral.url;
+}
 
 rmSync(paths.pullDir, { recursive: true, force: true });
-execFileSync('npx', ['drizzle-kit', 'pull', ...(paths.drizzleConfig ? [`--config=${paths.drizzleConfig}`] : [])], { stdio: 'inherit' });
+try {
+    execFileSync('npx', ['drizzle-kit', 'pull', ...(paths.drizzleConfig ? [`--config=${paths.drizzleConfig}`] : [])], {
+        stdio: 'inherit',
+        env: { ...process.env, CODEGEN_DATABASE_URL: effectiveDbUrl },
+    });
+} finally {
+    if (ephemeral) await ephemeral.stop();
+}
 
 const pulled = join(paths.pullDir, "schema.ts");
 if (!existsSync(pulled)) {

package/bin/ephemeral_pg.mjs

@@ -0,0 +1,54 @@
+// Spins up a throwaway, local-only Postgres (via `embedded-postgres`, a
+// prebuilt binary — no Docker) so `cfni-db-codegen` can introspect DDL
+// without any live Postgres already running. Used only as a fallback when
+// no --db-url/CODEGEN_DATABASE_URL was given and nothing is reachable at the
+// local Supabase default.
+import { readFileSync, rmSync } from 'node:fs';
+import { Client } from 'pg';
+
+const EPHEMERAL_PORT = 54329;
+const EPHEMERAL_URL = `postgresql://postgres:postgres@127.0.0.1:${EPHEMERAL_PORT}/postgres`;
+
+/** Starts an ephemeral Postgres, loads every file in `sqlFiles` into it, and
+ *  returns { url, stop() }. Caller must call stop() when done, even on error. */
+export async function startEphemeralPostgres(dataDir, sqlFiles) {
+    let EmbeddedPostgres;
+    try {
+        ({ default: EmbeddedPostgres } = await import('embedded-postgres'));
+    } catch {
+        return null; // optional dep not installed — caller falls back to its normal error message
+    }
+
+    rmSync(dataDir, { recursive: true, force: true });
+    const pg = new EmbeddedPostgres({
+        databaseDir: dataDir,
+        port: EPHEMERAL_PORT,
+        user: 'postgres',
+        password: 'postgres',
+        persistent: false,
+    });
+
+    console.log('ℹ️  No reachable Postgres found — starting an ephemeral one (embedded-postgres, no Docker needed)…');
+    await pg.initialise();
+    await pg.start();
+
+    const client = new Client({ connectionString: EPHEMERAL_URL });
+    await client.connect();
+    try {
+        for (const file of sqlFiles) {
+            const sql = readFileSync(file, 'utf8');
+            if (sql.trim().length === 0) continue;
+            await client.query(sql);
+        }
+    } finally {
+        await client.end();
+    }
+
+    return {
+        url: EPHEMERAL_URL,
+        async stop() {
+            await pg.stop().catch(() => { /* best-effort */ });
+            rmSync(dataDir, { recursive: true, force: true });
+        },
+    };
+}

package/dist/src/db/codegen_paths.d.ts

@@ -11,6 +11,8 @@ export interface CodegenPaths {
     pullDir: string;
     manifest: string;
     dbUrl: string;
+    dbUrlExplicit: boolean;
+    ephemeralDir: string;
     check: boolean;
     timeoutMs: number;
     drizzleConfig: string | null;

package/dist/src/db/codegen_paths.js

@@ -52,6 +52,8 @@ export default function resolveCodegenPaths(argv, env, cwd) {
         pullDir: resolve(outDir, '..', '.drizzle-pull'),
         manifest: join(outDir, 'manifest.json'),
         dbUrl: flag(argv, 'db-url') ?? env.CODEGEN_DATABASE_URL ?? DEFAULT_DB_URL,
+        dbUrlExplicit: flag(argv, 'db-url') !== undefined || env.CODEGEN_DATABASE_URL !== undefined,
+        ephemeralDir: resolve(outDir, '..', '.drizzle-ephemeral-pg'),
         check: argv.includes('--check'),
         timeoutMs: Number(env.CODEGEN_CONNECT_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS,
         drizzleConfig: drizzleConfig === null ? null : abs(cwd, drizzleConfig),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cloudflare-next-intl",
-	"version": "0.8.9",
+	"version": "0.8.10",
 	"description": "Optimized Next Intl Package Special for App Router and Cloudflare",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -243,6 +243,7 @@
 		"@microsoft/clarity": "^1.0.2",
 		"@supabase/supabase-js": "^2.112.3",
 		"drizzle-orm": "^0.45.2",
+		"embedded-postgres": "^18.4.0-beta.17",
 		"firebase": "^12.17.0",
 		"jose": "^6.2.8",
 		"pg": "^8.23.0"