cloudflare-next-intl 0.8.10 → 0.8.12

package/bin/db_codegen.mjs

@@ -38,7 +38,9 @@ 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 PACKAGE_ROOT = new URL('..', import.meta.url).pathname;
 const paths = resolveCodegenPaths(process.argv.slice(2), process.env, process.cwd());
 
 async function isReachable(url) {
@@ -96,21 +98,48 @@ if (paths.check) {
 
 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 });
+// drizzle-kit's own default config resolution looks for `drizzle.config.json`
+// in the cwd and errors out if it's missing — a project has no reason to
+// keep one around just for this script when --db-url/CODEGEN_DATABASE_URL
+// (or the ephemeral fallback) already says everything drizzle-kit needs. So
+// when the caller didn't pass --drizzle-config, generate one on the fly.
+let generatedConfigPath = null;
 try {
-    execFileSync('npx', ['drizzle-kit', 'pull', ...(paths.drizzleConfig ? [`--config=${paths.drizzleConfig}`] : [])], {
+    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;
+    }
+
+    let configPath = paths.drizzleConfig;
+    if (!configPath) {
+        generatedConfigPath = join(paths.pullDir, '..', '.drizzle-config.json');
+        mkdirSync(join(paths.pullDir, '..'), { recursive: true });
+        writeFileSync(generatedConfigPath, JSON.stringify({
+            out: paths.pullDir,
+            dialect: 'postgresql',
+            dbCredentials: { url: effectiveDbUrl },
+        }, null, 2));
+        configPath = generatedConfigPath;
+    }
+
+    rmSync(paths.pullDir, { recursive: true, force: true });
+    // drizzle-kit itself requires `drizzle-orm` at runtime. This package
+    // depends on drizzle-orm, but npm doesn't guarantee that dependency gets
+    // hoisted to the consuming project's own node_modules (it commonly stays
+    // nested under node_modules/cloudflare-next-intl/node_modules) — so
+    // running from *this* package's own directory, where it's guaranteed
+    // resolvable, avoids "please install required packages: drizzle-orm"
+    // when a consumer doesn't happen to have it hoisted.
+    execFileSync('npx', ['drizzle-kit', 'pull', `--config=${configPath}`], {
         stdio: 'inherit',
+        cwd: PACKAGE_ROOT,
         env: { ...process.env, CODEGEN_DATABASE_URL: effectiveDbUrl },
     });
 } finally {
     if (ephemeral) await ephemeral.stop();
+    if (generatedConfigPath) rmSync(generatedConfigPath, { force: true });
 }
 
 const pulled = join(paths.pullDir, "schema.ts");

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

@@ -4,14 +4,30 @@
 // 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(dataDir, sqlFiles) {
+export async function startEphemeralPostgres(sqlFiles) {
+    const dataDir = DATA_DIR;
     let EmbeddedPostgres;
     try {
         ({ default: EmbeddedPostgres } = await import('embedded-postgres'));
@@ -29,19 +45,33 @@ export async function startEphemeralPostgres(dataDir, sqlFiles) {
     });
 
     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);
+        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();
         }
-    } finally {
-        await client.end();
+    } catch (error) {
+        await pg.stop().catch(() => { /* best-effort */ });
+        rmSync(dataDir, { recursive: true, force: true });
+        throw error;
     }
 
     return {

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

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

package/dist/src/db/codegen_paths.js

@@ -53,7 +53,6 @@ export default function resolveCodegenPaths(argv, env, cwd) {
         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.10",
+	"version": "0.8.12",
 	"description": "Optimized Next Intl Package Special for App Router and Cloudflare",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",