cloudflare-next-intl 0.8.9 → 0.8.11

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,34 @@ 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';
+import { orderedSqlFiles } from './ddl_order.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 +95,24 @@ if (paths.check) {
     process.exit(0);
 }
 
-await assertReachable(paths.dbUrl);
+let effectiveDbUrl = paths.dbUrl;
+let ephemeral = null;
+try {
+    if (!(await isReachable(paths.dbUrl))) {
+        if (paths.dbUrlExplicit) failUnreachable(paths.dbUrl);
+        ephemeral = await startEphemeralPostgres(orderedSqlFiles(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' });
+    rmSync(paths.pullDir, { recursive: true, force: true });
+    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/ddl_order.mjs

@@ -0,0 +1,46 @@
+// Mirrors supabase/scripts/db_start.sh's `process_path`: within each
+// directory, files/subdirectories listed in that directory's own `order.txt`
+// apply first (in the listed order, recursing into subdirectories the same
+// way), then everything else applies in alphabetical order. DDL is not
+// generally safe to apply purely alphabetically — e.g. a function that calls
+// another function must be created after it — so `order.txt` is how a
+// project expresses the real dependency order.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+function orderedEntries(dir) {
+    const orderFile = join(dir, 'order.txt');
+    const applied = new Set();
+    const ordered = [];
+
+    if (existsSync(orderFile)) {
+        for (const rawLine of readFileSync(orderFile, 'utf8').split('\n')) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#')) continue;
+            const path = join(dir, line);
+            if (existsSync(path)) {
+                ordered.push(path);
+                applied.add(line);
+            }
+        }
+    }
+
+    const rest = readdirSync(dir)
+        .filter((name) => name !== 'order.txt' && !applied.has(name))
+        .sort()
+        .map((name) => join(dir, name));
+
+    return [...ordered, ...rest];
+}
+
+/** Returns every `.sql` file under `dir`, in the order a project's own
+ *  `order.txt` files (one per directory) say they must be applied. */
+export function orderedSqlFiles(dir) {
+    const files = [];
+    for (const path of orderedEntries(dir)) {
+        const stat = statSync(path);
+        if (stat.isDirectory()) files.push(...orderedSqlFiles(path));
+        else if (path.endsWith('.sql')) files.push(path);
+    }
+    return files;
+}

package/bin/ephemeral_pg.mjs

@@ -0,0 +1,84 @@
+// 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 { relative } from 'node:path';
+import { Client } from 'pg';
+
+const EPHEMERAL_PORT = 54329;
+const EPHEMERAL_URL = `postgresql://postgres:postgres@127.0.0.1:${EPHEMERAL_PORT}/postgres`;
+// Lives under this package's own install dir, not the consuming project —
+// keeps a throwaway Postgres data directory out of the user's repo/tree.
+const DATA_DIR = new URL('../.drizzle-ephemeral-pg', import.meta.url).pathname;
+
+// A plain embedded-postgres cluster has none of the roles the real Supabase
+// Postgres image bootstraps into every project (`anon`/`authenticated`/
+// `service_role` for PostgREST, plus the admin roles some GRANT/ALTER
+// statements target) — DDL that GRANTs to them fails otherwise. These are
+// the standard local-dev role names Supabase itself creates; DDL never
+// creates them, so codegen must.
+const SUPABASE_ROLES = [
+    'anon', 'authenticated', 'service_role', 'authenticator',
+    'supabase_admin', 'supabase_auth_admin', 'supabase_storage_admin', 'supabase_realtime_admin',
+];
+
+/** 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(sqlFiles) {
+    const dataDir = DATA_DIR;
+    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)…');
+    try {
+        await pg.initialise();
+        await pg.start();
+
+        const client = new Client({ connectionString: EPHEMERAL_URL });
+        await client.connect();
+        try {
+            for (const role of SUPABASE_ROLES) {
+                await client.query(`CREATE ROLE ${role} NOLOGIN NOINHERIT;`);
+            }
+            for (const file of sqlFiles) {
+                const sql = readFileSync(file, 'utf8');
+                if (sql.trim().length === 0) continue;
+                try {
+                    await client.query(sql);
+                } catch (error) {
+                    error.message = `${relative(process.cwd(), file)}: ${error.message}`;
+                    throw error;
+                }
+            }
+        } finally {
+            await client.end();
+        }
+    } catch (error) {
+        await pg.stop().catch(() => { /* best-effort */ });
+        rmSync(dataDir, { recursive: true, force: true });
+        throw error;
+    }
+
+    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,7 @@ export interface CodegenPaths {
     pullDir: string;
     manifest: string;
     dbUrl: string;
+    dbUrlExplicit: boolean;
     check: boolean;
     timeoutMs: number;
     drizzleConfig: string | null;

package/dist/src/db/codegen_paths.js

@@ -52,6 +52,7 @@ 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,
         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.11",
 	"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"