@pikku/cli 0.12.34 → 0.12.36

package/dist/src/functions/db/local-db.js

@@ -1,9 +1,10 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, readdirSync, } from 'node:fs';
 import { resolve, isAbsolute, relative, dirname, join } from 'node:path';
-import { execSync } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
+import { runInNewContext } from 'node:vm';
+import { transformSync } from 'esbuild';
 import { migrate } from './db-migrator.js';
+import { loadAuthOptions, getAuthMigrations } from './better-auth-schema.js';
 import { generateSchemaTypes } from './db-codegen.js';
 import { generateZodTypes } from './zod-codegen.js';
 import { createCoercionPlugin } from './coercion-plugin.js';
@@ -42,7 +43,11 @@ export function resolveDb(userConfig, rootDir, outDir, runtimeDir) {
         classificationMapFile: join(outDir, 'db', 'classification-map.gen.d.ts'),
         schemaJsonFile: join(outDir, 'db', 'pikku-db-schema.gen.json'),
         classificationsFile: join(rootDir, 'db', 'annotations.ts'),
-        classificationsGenJsonFile: join(outDir, 'db', 'annotations.gen.json'),
+        // Compiled sidecar lives beside the authored annotations.ts in db/ — this is
+        // where both consumers read it: the codegen's loadAnnotations() and the
+        // pikku-console addon (db/annotations.gen.json). Writing it into outDir
+        // (.pikku) would leave both readers looking at a file that never appears.
+        classificationsGenJsonFile: join(rootDir, 'db', 'annotations.gen.json'),
         zodFile: join(outDir, 'db', 'zod.gen.ts'),
         camelCase: true,
     });
@@ -87,6 +92,9 @@ function resolveAgainst(root, p) {
 export async function migrateAndCodegen(resolved) {
     let migrateResult;
     let codegenResult;
+    // Compile any authored db/annotations.ts → sidecar BEFORE codegen so edits
+    // reflect in a single `db migrate` (codegen reads the sidecar).
+    compileClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile);
     if (resolved.dialect === 'sqlite') {
         mkdirSync(dirname(resolved.dbFile), { recursive: true });
         const runtime = await loadSqliteRuntime();
@@ -103,7 +111,7 @@ export async function migrateAndCodegen(resolved) {
                 schemaJsonFile: resolved.schemaJsonFile,
                 camelCase: resolved.camelCase,
                 rootDir: resolved.rootDir,
-                migrationsDir: resolved.migrationsDir,
+                dialect: 'sqlite',
             });
         }
         finally {
@@ -129,7 +137,7 @@ export async function migrateAndCodegen(resolved) {
                     schemaJsonFile: resolved.schemaJsonFile,
                     camelCase: resolved.camelCase,
                     rootDir: resolved.rootDir,
-                    migrationsDir: resolved.migrationsDir,
+                    dialect: 'postgres',
                 });
             }
             finally {
@@ -143,9 +151,13 @@ export async function migrateAndCodegen(resolved) {
     const zodResult = generateZodTypes({
         schemaFile: resolved.schemaFile,
         outFile: resolved.zodFile,
+        formats: codegenResult.zodFormats,
     });
     // ── Classifications step ──────────────────────────────────────────────────
-    const { scaffolded, jsonWritten } = syncClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile, codegenResult.tables);
+    // Scaffold the authored file if missing (needs the table list), then compile
+    // it to the sidecar so a freshly-scaffolded file is captured too.
+    const scaffolded = scaffoldClassificationsFile(resolved.classificationsFile, codegenResult.tables);
+    const jsonWritten = compileClassifications(resolved.classificationsFile, resolved.classificationsGenJsonFile);
     return {
         migrate: migrateResult,
         codegen: codegenResult,
@@ -179,86 +191,93 @@ export function reset(resolved, rootDir) {
 }
 // ── Classification sync ───────────────────────────────────────────────────────
 /**
- * Loads `db/classifications.ts` via tsx, serialises it to
- * `.pikku/db/classifications.gen.json` for runtime consumption (console, etc.).
- *
- * If `db/classifications.ts` doesn't exist yet, writes a scaffold with every
- * table defaulting to `private` so the developer has a starting point.
+ * If `db/annotations.ts` doesn't exist yet, write a scaffold listing every
+ * table/column so the developer has a typed starting point. Every field of
+ * `ColumnEntry` is optional, so the empty-per-table scaffold is valid and means
+ * "everything default `private`". Returns whether a scaffold was written.
  */
-function syncClassifications(classificationsFile, genJsonFile, tableNames) {
-    let scaffolded = false;
-    if (!existsSync(classificationsFile)) {
-        const relMap = join(dirname(classificationsFile), '..', '.pikku', 'db', 'classification-map.gen.d.ts');
-        const relMapPosix = relMap.replace(/\\/g, '/');
-        const groups = new Map();
-        for (const name of tableNames) {
-            const dot = name.indexOf('.');
-            const schema = dot >= 0 ? name.slice(0, dot) : '';
-            const table = dot >= 0 ? name.slice(dot + 1) : name;
-            if (!groups.has(schema))
-                groups.set(schema, []);
-            groups.get(schema).push(table);
-        }
-        const bodyLines = [
-            `import type { DbClassificationMap } from '${relMapPosix}'`,
-            ``,
-            `export const classifications = {`,
-        ];
-        for (const [schema, tables] of groups) {
-            if (schema)
-                bodyLines.push(`  ${JSON.stringify(schema)}: {`);
-            for (const table of tables) {
-                bodyLines.push(schema
-                    ? `    ${JSON.stringify(table)}: {`
-                    : `  ${JSON.stringify(table)}: {`);
-                bodyLines.push(schema ? `    },` : `  },`);
-            }
-            if (schema)
-                bodyLines.push(`  },`);
+function scaffoldClassificationsFile(classificationsFile, tableNames) {
+    if (existsSync(classificationsFile))
+        return false;
+    const relMap = join(dirname(classificationsFile), '..', '.pikku', 'db', 'classification-map.gen.d.ts');
+    const relMapPosix = relMap.replace(/\\/g, '/');
+    const groups = new Map();
+    for (const name of tableNames) {
+        const dot = name.indexOf('.');
+        const schema = dot >= 0 ? name.slice(0, dot) : '';
+        const table = dot >= 0 ? name.slice(dot + 1) : name;
+        if (!groups.has(schema))
+            groups.set(schema, []);
+        groups.get(schema).push(table);
+    }
+    const bodyLines = [
+        `import type { DbClassificationMap } from '${relMapPosix}'`,
+        ``,
+        `export const classifications = {`,
+    ];
+    for (const [schema, tables] of groups) {
+        if (schema)
+            bodyLines.push(`  ${JSON.stringify(schema)}: {`);
+        for (const table of tables) {
+            bodyLines.push(schema
+                ? `    ${JSON.stringify(table)}: {`
+                : `  ${JSON.stringify(table)}: {`);
+            bodyLines.push(schema ? `    },` : `  },`);
         }
-        bodyLines.push(`} satisfies DbClassificationMap`, ``);
-        mkdirSync(dirname(classificationsFile), { recursive: true });
-        writeFileSync(classificationsFile, bodyLines.join('\n'), 'utf8');
-        scaffolded = true;
+        if (schema)
+            bodyLines.push(`  },`);
     }
-    // Resolve tsx from the CLI package's own node_modules so it works regardless
-    // of whether the user's project has tsx installed.
-    const _require = createRequire(fileURLToPath(import.meta.url));
-    let tsxEsmPath = null;
+    bodyLines.push(`} satisfies DbClassificationMap`, ``);
+    mkdirSync(dirname(classificationsFile), { recursive: true });
+    writeFileSync(classificationsFile, bodyLines.join('\n'), 'utf8');
+    return true;
+}
+/**
+ * Compile `db/annotations.ts` into the `annotations.gen.json` sidecar that the
+ * codegen and the pikku-console addon read. No-op if the authored file doesn't
+ * exist (nothing to compile yet). Returns whether the sidecar changed on disk.
+ *
+ * Uses esbuild (a CLI dependency) to transpile the TS in-process and a `vm`
+ * sandbox to evaluate it — no subprocess and no tsx. The previous `node --import
+ * tsx/esm` subprocess silently fails on Node ≥ 23 (ERR_REQUIRE_CYCLE_MODULE),
+ * which is why this sidecar never materialised before.
+ *
+ * Run BEFORE codegen so authored edits reflect in a single `db migrate` (and
+ * again after, to capture a freshly-scaffolded file).
+ */
+function compileClassifications(classificationsFile, genJsonFile) {
+    if (!existsSync(classificationsFile))
+        return false;
+    let value;
     try {
-        tsxEsmPath = _require.resolve('tsx/esm');
+        const src = readFileSync(classificationsFile, 'utf8');
+        const { code } = transformSync(src, {
+            loader: 'ts',
+            format: 'cjs',
+        });
+        const mod = { exports: {} };
+        runInNewContext(code, {
+            module: mod,
+            exports: mod.exports,
+            require: createRequire(classificationsFile),
+        });
+        value = Object.values(mod.exports)[0];
     }
     catch {
-        // tsx not bundled with this CLI install — skip JSON emit
+        return false; // syntax/transform error — skip JSON emit
     }
-    const script = [
-        `import * as mod from ${JSON.stringify(classificationsFile)}`,
-        `const val = Object.values(mod)[0]`,
-        `process.stdout.write(JSON.stringify(val))`,
-    ].join('\n');
-    let jsonWritten = false;
-    if (tsxEsmPath) {
-        try {
-            const json = execSync(`node --import ${JSON.stringify(tsxEsmPath)} --input-type=module`, {
-                input: script,
-                encoding: 'utf8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            const existing = existsSync(genJsonFile)
-                ? readFileSync(genJsonFile, 'utf8')
-                : null;
-            const next = JSON.stringify(JSON.parse(json), null, 2) + '\n';
-            if (existing !== next) {
-                mkdirSync(dirname(genJsonFile), { recursive: true });
-                writeFileSync(genJsonFile, next, 'utf8');
-                jsonWritten = true;
-            }
-        }
-        catch {
-            // annotations file has syntax errors — skip JSON emit
-        }
+    if (value === undefined)
+        return false;
+    const next = JSON.stringify(value, null, 2) + '\n';
+    const existing = existsSync(genJsonFile)
+        ? readFileSync(genJsonFile, 'utf8')
+        : null;
+    if (existing !== next) {
+        mkdirSync(dirname(genJsonFile), { recursive: true });
+        writeFileSync(genJsonFile, next, 'utf8');
+        return true;
     }
-    return { scaffolded, jsonWritten };
+    return false;
 }
 export async function createKysely(resolved) {
     mkdirSync(dirname(resolved.dbFile), { recursive: true });
@@ -277,3 +296,126 @@ export async function createKysely(resolved) {
         plugins: coercionMap ? [createCoercionPlugin({ map: coercionMap })] : [],
     });
 }
+async function introspectorToMap(intro) {
+    const map = new Map();
+    for (const table of await intro.listTables()) {
+        const cols = await intro.getColumns(table);
+        map.set(table, new Set(cols.map((c) => c.name)));
+    }
+    return map;
+}
+function diffSchemas(desired, actual) {
+    const missingTables = [];
+    const missingColumns = [];
+    for (const [table, cols] of desired) {
+        const actualCols = actual.get(table);
+        if (!actualCols) {
+            missingTables.push(table);
+            continue;
+        }
+        const missing = [...cols].filter((c) => !actualCols.has(c));
+        if (missing.length)
+            missingColumns.push({ table, columns: missing });
+    }
+    return { missingTables, missingColumns };
+}
+export async function desiredAuthSchema(rootDir, srcDirectories, logger) {
+    const runtime = await loadSqliteRuntime();
+    const db = runtime.open(':memory:');
+    try {
+        const kysely = createSqliteKysely({ db, camelCase: true });
+        const options = await loadAuthOptions({ rootDir, srcDirectories, kysely, logger });
+        if (!options)
+            return null;
+        const { runMigrations, compileMigrations } = await getAuthMigrations(options);
+        await runMigrations();
+        const tables = await introspectorToMap(new SqliteIntrospector(db));
+        const sql = await compileMigrations();
+        return { tables, sql };
+    }
+    finally {
+        db.close();
+    }
+}
+export async function introspectSchema(resolved) {
+    if (resolved.dialect === 'sqlite') {
+        const runtime = await loadSqliteRuntime();
+        const db = runtime.open(resolved.dbFile);
+        try {
+            return await introspectorToMap(new SqliteIntrospector(db));
+        }
+        finally {
+            db.close();
+        }
+    }
+    const intro = new PostgresIntrospector(resolved.connectionString);
+    await intro.connect();
+    try {
+        return await introspectorToMap(intro);
+    }
+    finally {
+        await intro.close();
+    }
+}
+async function coveredSqliteSchema(migrationsDir) {
+    const runtime = await loadSqliteRuntime();
+    const db = runtime.open(':memory:');
+    try {
+        await migrate(new SqliteMigrationExecutor(db), migrationsDir);
+        return await introspectorToMap(new SqliteIntrospector(db));
+    }
+    finally {
+        db.close();
+    }
+}
+export async function computeAuthDrift(resolved, rootDir, srcDirectories, logger) {
+    const desired = await desiredAuthSchema(rootDir, srcDirectories, logger);
+    if (!desired) {
+        return { hasAuth: false, inSync: true, missingTables: [], missingColumns: [] };
+    }
+    const actual = await introspectSchema(resolved);
+    const { missingTables, missingColumns } = diffSchemas(desired.tables, actual);
+    return {
+        hasAuth: true,
+        inSync: missingTables.length === 0 && missingColumns.length === 0,
+        missingTables,
+        missingColumns,
+    };
+}
+function nextMigrationFile(migrationsDir, label) {
+    mkdirSync(migrationsDir, { recursive: true });
+    let max = 0;
+    try {
+        for (const file of readdirSync(migrationsDir)) {
+            const m = /^(\d+)/.exec(file);
+            if (m)
+                max = Math.max(max, parseInt(m[1], 10));
+        }
+    }
+    catch {
+        max = 0;
+    }
+    const num = String(max + 1).padStart(4, '0');
+    return join(migrationsDir, `${num}-${label}.sql`);
+}
+export async function generateAuthMigration(resolved, rootDir, srcDirectories, logger) {
+    if (resolved.dialect !== 'sqlite')
+        return { status: 'unsupported-dialect' };
+    const desired = await desiredAuthSchema(rootDir, srcDirectories, logger);
+    if (!desired)
+        return { status: 'no-auth' };
+    const covered = await coveredSqliteSchema(resolved.migrationsDir);
+    const { missingTables, missingColumns } = diffSchemas(desired.tables, covered);
+    if (missingTables.length === 0 && missingColumns.length === 0) {
+        return { status: 'up-to-date' };
+    }
+    const coveredHasAnyAuthTable = [...desired.tables.keys()].some((t) => covered.has(t));
+    if (coveredHasAnyAuthTable) {
+        return { status: 'incremental-unsupported', missingTables, missingColumns };
+    }
+    const file = nextMigrationFile(resolved.migrationsDir, 'better-auth');
+    const header = '-- Generated by `pikku db generate` from pikkuBetterAuth (Better Auth).\n' +
+        '-- Re-run the command after changing the auth config.\n\n';
+    writeFileSync(file, header + desired.sql + '\n', 'utf8');
+    return { status: 'written', file, missingTables };
+}

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -33,6 +33,7 @@ export class PostgresIntrospector {
         const result = await this.client.query(`SELECT
          c.column_name,
          c.data_type,
+         c.udt_name,
          c.is_nullable,
          c.column_default,
          c.is_generated,
@@ -54,6 +55,7 @@ export class PostgresIntrospector {
         return result.rows.map((r) => ({
             name: r.column_name,
             type: r.data_type,
+            udtName: r.udt_name,
             notNull: r.is_nullable === 'NO',
             pk: Boolean(r.is_pk),
             defaultValue: r.column_default,

package/dist/src/functions/db/zod-codegen.d.ts

@@ -1,6 +1,44 @@
+/**
+ * Canonical map of `format` tokens (authored in `db/annotations.ts`) to the zod
+ * expression they emit. These are all *string* refinements — they do not change
+ * the column's TypeScript type (it stays `string`), only the runtime validator.
+ * This is the single source of truth: `annotation-parser` imports it to validate
+ * authored values and `db-codegen` imports the key list to emit the `format`
+ * union in `ColumnEntry`. All confirmed present in zod 4.
+ */
+export declare const ZOD_FORMATS: {
+    readonly email: "z.email()";
+    readonly url: "z.url()";
+    readonly emoji: "z.emoji()";
+    readonly e164: "z.e164()";
+    readonly jwt: "z.jwt()";
+    readonly cuid: "z.cuid()";
+    readonly cuid2: "z.cuid2()";
+    readonly ulid: "z.ulid()";
+    readonly nanoid: "z.nanoid()";
+    readonly base64: "z.base64()";
+    readonly base64url: "z.base64url()";
+    readonly ipv4: "z.ipv4()";
+    readonly ipv6: "z.ipv6()";
+    readonly cidrv4: "z.cidrv4()";
+    readonly cidrv6: "z.cidrv6()";
+    readonly isoDate: "z.iso.date()";
+    readonly isoTime: "z.iso.time()";
+    readonly isoDatetime: "z.iso.datetime()";
+    readonly isoDuration: "z.iso.duration()";
+};
+export type ZodFormat = keyof typeof ZOD_FORMATS;
 export interface ZodCodegenOptions {
     schemaFile: string;
     outFile: string;
+    /**
+     * Per-interface, per-field `format` overrides. Keyed by the *interface* name
+     * (PascalCase, as it appears in `schema.d.ts`) and the *field* name (camelCase),
+     * matching how `parseTables` reads the schema. Computed by `db-codegen` (which
+     * owns the snake→Pascal/camel name mapping) so this emitter stays a dumb
+     * string→zod translator.
+     */
+    formats?: Record<string, Record<string, ZodFormat>>;
 }
 export interface ZodCodegenResult {
     outFile: string;