@pikku/cli 0.12.24 → 0.12.26

package/dist/src/fabric/functions/validate-core.js

@@ -0,0 +1,227 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { added, changed, dim, removed } from '../lib/output.js';
+import { WorkspaceValidateOutput, readJsonSafe, readTextSafe, runWorkspaceValidate, } from '../../functions/validate/workspace-validate.js';
+export const FabricValidateInput = z.object({});
+export const FabricValidateOutput = WorkspaceValidateOutput;
+const POSTGRES_SQL_PATTERNS = [
+    {
+        re: /\b(?:SMALL|BIG)?SERIAL\b/i,
+        label: 'SERIAL / BIGSERIAL / SMALLSERIAL',
+    },
+    { re: /\bJSONB\b/i, label: 'JSONB' },
+    { re: /\bCREATE\s+SEQUENCE\b/i, label: 'CREATE SEQUENCE' },
+    { re: /\bgen_random_uuid\s*\(\s*\)/i, label: 'gen_random_uuid()' },
+    { re: /::[a-z_]+/i, label: ':: type cast' },
+    { re: /\bTSVECTOR\b/i, label: 'TSVECTOR' },
+    { re: /\bARRAY\s*\[/i, label: 'ARRAY[…]' },
+];
+export async function runFabricValidate(startDir = process.cwd()) {
+    const workspaceResult = await runWorkspaceValidate(startDir);
+    const root = workspaceResult.root;
+    const findings = [...workspaceResult.findings];
+    const e = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'error', message, path, fixHint });
+    };
+    const w = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'warn', message, path, fixHint });
+    };
+    const info = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'info', message, path, fixHint });
+    };
+    const fabricConfigPath = join(root, 'fabric.config.json');
+    const fabricConfig = await readJsonSafe(fabricConfigPath);
+    if (!fabricConfig) {
+        info('fabric-config-missing', 'fabric.config.json not found — project has not been linked to fabric yet', fabricConfigPath, 'Run `pikku fabric link` to create it, or create manually: {"projectId": "__PROJECT_ID__"}');
+    }
+    else if (!fabricConfig.projectId) {
+        info('fabric-config-no-project-id', 'fabric.config.json is missing "projectId"', fabricConfigPath, 'Add "projectId": "<your-project-id>" to fabric.config.json, or run `pikku fabric link`');
+    }
+    else if (fabricConfig.projectId === '__PROJECT_ID__') {
+        info('fabric-config-placeholder-project-id', 'fabric.config.json has a placeholder projectId ("__PROJECT_ID__") — project is not linked', fabricConfigPath, 'Run `pikku fabric link` to replace the placeholder with a real project ID');
+    }
+    const rootPkgPath = join(root, 'package.json');
+    const rootPkg = await readJsonSafe(rootPkgPath);
+    if (rootPkg) {
+        const allDeps = {
+            ...rootPkg.dependencies,
+            ...rootPkg.devDependencies,
+        };
+        if (!allDeps['@pikku/fabric-cli']) {
+            info('missing-fabric-cli', '@pikku/fabric-cli not in devDependencies — fabric CLI commands (validate, deploy) will not be available', rootPkgPath, 'Add "@pikku/fabric-cli" to devDependencies: use "file:./vendor/pikku-fabric-cli.tgz" (bundled release) or "portal:/path/to/pikku/packages/fabric-cli" (local dev)');
+        }
+    }
+    const fnDir = join(root, 'packages', 'functions');
+    const functionsSdkPkgName = (await readJsonSafe(join(root, 'packages', 'functions-sdk', 'package.json')))?.name;
+    const themePkgName = (await readJsonSafe(join(root, 'packages', 'theme', 'package.json')))?.name;
+    const componentsPkgName = (await readJsonSafe(join(root, 'packages', 'components', 'package.json')))?.name;
+    if (existsSync(fnDir)) {
+        const fnPkgPath = join(fnDir, 'package.json');
+        const fnPkg = await readJsonSafe(fnPkgPath);
+        if (fnPkg) {
+            const fnAllDeps = {
+                ...fnPkg.dependencies,
+                ...fnPkg.devDependencies,
+                ...fnPkg.peerDependencies,
+            };
+            if (fnAllDeps['@pikku/kysely-postgres']) {
+                e('fn-pkg-postgres-dep', '@pikku/kysely-postgres is in packages/functions dependencies — Fabric uses SQLite/libSQL (Turso), not PostgreSQL', fnPkgPath, 'Remove @pikku/kysely-postgres and use @pikku/kysely-sqlite with LibsqlWebDialect instead');
+            }
+        }
+        const servicesPath = join(fnDir, 'src', 'services.ts');
+        const servicesText = await readTextSafe(servicesPath);
+        if (servicesText) {
+            const usesKysely = /\bKysely\b/.test(servicesText);
+            const usesLibsql = servicesText.includes('@pikku/kysely-sqlite') ||
+                servicesText.includes('LibsqlWebDialect');
+            const usesProcessEnv = /\bprocess\.env\.[A-Z_]/.test(servicesText);
+            if (usesKysely && !usesLibsql) {
+                e('services-wrong-db-adapter', 'services.ts uses Kysely but not LibsqlWebDialect — Fabric injects a Turso/libSQL DATABASE_URL at runtime, not a PostgreSQL URL', servicesPath, 'Import LibsqlWebDialect from @pikku/kysely-sqlite and replace the dialect: new Kysely({ dialect: new LibsqlWebDialect({ url: databaseUrl }) })');
+            }
+            if (usesProcessEnv) {
+                info('services-process-env', 'services.ts reads process.env directly — prefer variables.get() for portable secret/variable access', servicesPath, 'Replace process.env.SOME_VAR with await variables.get("SOME_VAR") — declare the binding with wireVariable/wireSecret; process.env is fine for optional/non-secret config');
+            }
+            if (usesLibsql &&
+                rootPkg &&
+                !rootPkg.dependencies?.['@pikku/kysely-sqlite'] &&
+                !rootPkg.devDependencies?.['@pikku/kysely-sqlite']) {
+                e('missing-kysely-sqlite', 'services.ts imports @pikku/kysely-sqlite but it is not in root package.json', rootPkgPath, 'Add "@pikku/kysely-sqlite": "file:./vendor/pikku-kysely-sqlite.tgz" to dependencies');
+            }
+        }
+        // db/migrations/ — presence, numbering and SQL dialect
+        const migrationsDir = join(fnDir, 'db', 'migrations');
+        if (!existsSync(migrationsDir)) {
+            e('migrations-dir-missing', 'packages/functions/db/migrations/ not found', migrationsDir, 'Create db/migrations/ and add numbered .sql files (e.g. 0001-init.sql) using SQLite-compatible syntax');
+        }
+        else {
+            try {
+                const files = (await readdir(migrationsDir)).filter((f) => f.endsWith('.sql'));
+                const nums = [];
+                for (const f of files) {
+                    const m = f.match(/^(\d+)/);
+                    if (m)
+                        nums.push(parseInt(m[1], 10));
+                }
+                for (let idx = 1; idx < nums.length; idx++) {
+                    if (nums[idx] !== nums[idx - 1] + 1) {
+                        const missing = `${nums[idx - 1] + 1}..${nums[idx] - 1}`;
+                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive. Add the missing .sql file or renumber if not yet applied.');
+                        break;
+                    }
+                }
+                for (const f of files) {
+                    const sql = await readTextSafe(join(migrationsDir, f));
+                    if (!sql)
+                        continue;
+                    const hits = POSTGRES_SQL_PATTERNS.filter(({ re }) => re.test(sql)).map(({ label }) => label);
+                    if (hits.length > 0) {
+                        e(`migration-postgres-sql-${f.replace(/[^a-z0-9]/gi, '-')}`, `${f} contains PostgreSQL syntax (${hits.join(', ')}) — Fabric uses SQLite/libSQL (Turso)`, join(migrationsDir, f), "Rewrite the migration using SQLite-compatible syntax: TEXT instead of JSONB, INTEGER PRIMARY KEY for auto-increment, datetime('now') instead of NOW(), no :: casts");
+                    }
+                }
+            }
+            catch {
+                // readdir failure — skip
+            }
+        }
+        // db/seed.sql
+        const seedPath = join(fnDir, 'db', 'seed.sql');
+        if (!existsSync(seedPath)) {
+            e('seed-sql-missing', 'packages/functions/db/seed.sql not found', seedPath, 'Create db/seed.sql with idempotent INSERT OR IGNORE statements for demo/test data');
+        }
+    }
+    const appsDir = join(root, 'apps');
+    if (existsSync(appsDir)) {
+        if (fabricConfig) {
+            const frontends = (fabricConfig.frontends ?? {});
+            for (const [slug, fe] of Object.entries(frontends)) {
+                const cwd = fe.cwd?.replace(/^\.\//, '');
+                if (cwd && !existsSync(join(root, cwd))) {
+                    e(`frontend-cwd-missing-${slug}`, `fabric.config.json frontend "${slug}" declares cwd "${cwd}" but that directory does not exist`, join(root, cwd), 'Create the directory or update the cwd in fabric.config.json');
+                }
+            }
+        }
+        let appEntries = [];
+        try {
+            appEntries = (await readdir(appsDir, { withFileTypes: true }))
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
+        }
+        catch {
+            // ignore
+        }
+        const declaredCwds = fabricConfig
+            ? new Set(Object.values((fabricConfig.frontends ?? {})).map((f) => f.cwd?.replace(/^\.\//, '') ?? ''))
+            : null;
+        for (const name of appEntries) {
+            const appPath = join(appsDir, name);
+            const cwd = `apps/${name}`;
+            if (declaredCwds && !declaredCwds.has(cwd)) {
+                w(`app-not-declared-${name}`, `apps/${name} is not declared in fabric.config.json frontends`, appPath, `Add an entry to fabric.config.json: { "frontends": { "${name}": { "cwd": "${cwd}", "kind": "ssr" } } }`);
+            }
+            const appPkg = await readJsonSafe(join(appPath, 'package.json'));
+            if (!appPkg)
+                continue;
+            const appDeps = { ...appPkg.dependencies };
+            if (functionsSdkPkgName && !appDeps[functionsSdkPkgName]) {
+                info(`app-missing-functions-sdk-${name}`, `apps/${name} does not depend on ${functionsSdkPkgName} — the generated RPC client and React Query hooks`, join(appPath, 'package.json'), `Add "${functionsSdkPkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+            if (themePkgName && !appDeps[themePkgName]) {
+                info(`app-missing-theme-${name}`, `apps/${name} does not depend on ${themePkgName}`, join(appPath, 'package.json'), `Add "${themePkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+            if (componentsPkgName && !appDeps[componentsPkgName]) {
+                info(`app-missing-components-${name}`, `apps/${name} does not depend on ${componentsPkgName}`, join(appPath, 'package.json'), `Add "${componentsPkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+        }
+    }
+    const designDocUrl = 'https://pikkufabric.dev/docs/design';
+    if (!existsSync(join(root, 'packages', 'theme'))) {
+        info('theme-missing', 'packages/theme/ not found — Fabric design features require a theme package', join(root, 'packages', 'theme'), `Create packages/theme/ with your Mantine theme tokens. See ${designDocUrl}`);
+    }
+    if (!existsSync(join(root, 'packages', 'components'))) {
+        info('components-missing', 'packages/components/ not found — Fabric design features require a components package', join(root, 'packages', 'components'), `Create packages/components/ with your shared UI components. See ${designDocUrl}`);
+    }
+    const ok = !findings.some((f) => f.severity === 'error');
+    return { ok, root, findings };
+}
+export const runValidate = runFabricValidate;
+export const renderValidate = (_s, { ok, root, findings }) => {
+    if (findings.length === 0) {
+        console.log(added('✓  All checks passed — project is fabric-compatible'));
+        return;
+    }
+    const relPath = (p) => p.startsWith(root + '/') || p.startsWith(root + '\\')
+        ? p.slice(root.length + 1)
+        : p;
+    const errors = findings.filter((f) => f.severity === 'error');
+    const warns = findings.filter((f) => f.severity === 'warn');
+    const infos = findings.filter((f) => f.severity === 'info');
+    for (const f of [...errors, ...warns, ...infos]) {
+        const icon = f.severity === 'error'
+            ? removed('✗')
+            : f.severity === 'warn'
+                ? changed('⚠')
+                : dim('ℹ');
+        console.log(`${icon}  ${f.message}`);
+        console.log(`   ${dim('path:')}   ${relPath(f.path)}`);
+        console.log(`   ${dim('fix:')}    ${f.fixHint}`);
+        console.log();
+    }
+    const counts = [];
+    if (errors.length) {
+        counts.push(removed(`${errors.length} error${errors.length !== 1 ? 's' : ''}`));
+    }
+    if (warns.length) {
+        counts.push(changed(`${warns.length} warning${warns.length !== 1 ? 's' : ''}`));
+    }
+    if (infos.length) {
+        counts.push(dim(`${infos.length} info${infos.length !== 1 ? 's' : ''}`));
+    }
+    console.log('─'.repeat(40));
+    console.log(counts.join('  '));
+    if (ok) {
+        console.log();
+        console.log(added('✓') + '  ' + dim('no errors — project can be linked to fabric'));
+    }
+};

package/dist/src/fabric/functions/validate.function.js

@@ -194,9 +194,12 @@ export async function runValidate(startDir = process.cwd()) {
                 e('missing-kysely-sqlite', 'services.ts imports @pikku/kysely-sqlite but it is not in root package.json', rootPkgPath, 'Add "@pikku/kysely-sqlite": "file:./vendor/pikku-kysely-sqlite.tgz" to dependencies');
             }
         }
-        // db/migrations/ — numbering and SQL dialect
+        // db/migrations/ — presence, numbering and SQL dialect
         const migrationsDir = join(fnDir, 'db', 'migrations');
-        if (existsSync(migrationsDir)) {
+        if (!existsSync(migrationsDir)) {
+            e('migrations-dir-missing', 'packages/functions/db/migrations/ not found', migrationsDir, 'Create db/migrations/ and add numbered .sql files (e.g. 0001-init.sql) using SQLite-compatible syntax');
+        }
+        else {
             try {
                 const files = (await readdir(migrationsDir))
                     .filter((f) => f.endsWith('.sql'))
@@ -210,7 +213,7 @@ export async function runValidate(startDir = process.cwd()) {
                 for (let idx = 1; idx < nums.length; idx++) {
                     if (nums[idx] !== nums[idx - 1] + 1) {
                         const missing = `${nums[idx - 1] + 1}..${nums[idx] - 1}`;
-                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive (postgres-migrations refuses gaps). Add the missing .sql file or renumber if not yet applied.');
+                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive. Add the missing .sql file or renumber if not yet applied.');
                         break;
                     }
                 }
@@ -229,6 +232,11 @@ export async function runValidate(startDir = process.cwd()) {
                 // readdir failure — skip
             }
         }
+        // db/seed.sql
+        const seedPath = join(fnDir, 'db', 'seed.sql');
+        if (!existsSync(seedPath)) {
+            e('seed-sql-missing', 'packages/functions/db/seed.sql not found', seedPath, 'Create db/seed.sql with idempotent INSERT OR IGNORE statements for demo/test data');
+        }
         // db.types.ts — should only re-export from .pikku
         const dbTypesPath = join(fnDir, 'src', 'types', 'db.types.ts');
         const dbTypesText = await readTextSafe(dbTypesPath);
@@ -248,7 +256,7 @@ export async function runValidate(startDir = process.cwd()) {
             info('wirings-dir-missing', 'packages/functions/src/wirings/ not found', join(fnDir, 'src', 'wirings'), 'Create src/wirings/ for transport bindings: *.http.ts, *.queue.ts, *.schedule.ts, *.channel.ts, *.cli.ts');
         }
         if (!existsSync(join(fnDir, 'src', 'config.ts'))) {
-            info('config-missing', 'packages/functions/src/config.ts not found', join(fnDir, 'src', 'config.ts'), 'Create src/config.ts: export const createConfig = pikkuConfig(async () => ({ dev: { db: true } }))');
+            info('config-missing', 'packages/functions/src/config.ts not found', join(fnDir, 'src', 'config.ts'), "Create src/config.ts: export const createConfig = pikkuConfig(async () => ({ sqliteDb: '.pikku-runtime/dev.db' }))");
         }
     }
     // ── apps/ vs fabric.config.json frontends ─────────────────────────────

package/dist/src/functions/commands/bootstrap.js

@@ -3,14 +3,14 @@ export const bootstrap = pikkuVoidFunc({
     remote: true,
     func: async ({ logger, getInspectorState }, _data, { rpc }) => {
         await getInspectorState(false, true, true);
-        await rpc.invoke('pikkuFunctionTypesSplit');
+        await rpc.invoke('pikkuFunctionTypesSplit', { bootstrap: true });
         await rpc.invoke('pikkuFunctionTypes');
         await rpc.invoke('pikkuHTTPTypes');
         await rpc.invoke('pikkuChannelTypes');
         await rpc.invoke('pikkuSchedulerTypes');
         await rpc.invoke('pikkuQueueTypes');
         await rpc.invoke('pikkuWorkflow', { bootstrap: true });
-        await rpc.invoke('pikkuTriggerTypes');
+        await rpc.invoke('pikkuTriggerTypes', { bootstrap: true });
         await rpc.invoke('pikkuMCPTypes');
         await rpc.invoke('pikkuAIAgentTypes');
         await rpc.invoke('pikkuNodeTypes');

package/dist/src/functions/commands/console.js

@@ -23,6 +23,9 @@ const MIME_TYPES = {
 export const consoleCommand = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config }, { port, open: openBrowser, hmr }, { rpc }) => {
+        const watchDirectories = [
+            ...new Set([config.emailTemplatesDir, ...config.srcDirectories].filter(Boolean)),
+        ];
         if (!config.scaffold?.console) {
             logger.error('Console is not enabled. Add { "scaffold": { "console": "no-auth" } } to your pikku.config.json');
             return;
@@ -68,19 +71,19 @@ export const consoleCommand = pikkuSessionlessFunc({
         });
         if (hmr) {
             await pikkuDevReloader({
-                srcDirectories: config.srcDirectories,
+                srcDirectories: watchDirectories,
                 logger,
             });
         }
-        const configWatcher = chokidar.watch(config.srcDirectories, {
+        const configWatcher = chokidar.watch(watchDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
         });
         let watcher = new chokidar.FSWatcher({});
         const generatorWatcher = () => {
             watcher.close();
-            logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
-            watcher = chokidar.watch(config.srcDirectories, {
+            logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(watchDirectories, {
                 ignoreInitial: true,
                 ignored: /.*\.gen\.ts/,
             });

package/dist/src/functions/commands/db-audit.d.ts

@@ -0,0 +1 @@
+export declare const dbAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/db-audit.js

@@ -0,0 +1,67 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { resolveDb } from '../db/local-db.js';
+import { loadUserConfigForDb } from './db-shared.js';
+export const dbAudit = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config }) => {
+        const userConfig = await loadUserConfigForDb({ config, logger });
+        if (!userConfig)
+            return;
+        const resolved = resolveDb(userConfig, config.rootDir, config.outDir, config.runtimeDir);
+        if (!resolved) {
+            logger.error('pikku db audit: no database configured — set sqliteDb or postgresUrl in your createConfig.');
+            throw new Error('no database configured');
+        }
+        let manifest;
+        try {
+            const mod = await import(resolved.manifestFile);
+            manifest = mod.classificationManifest;
+        }
+        catch {
+            logger.error(`pikku db audit: classification manifest not found at ${resolved.manifestFile}.\n` +
+                `  Run \`pikku db migrate\` to generate it.`);
+            throw new Error('classification manifest not found');
+        }
+        let publicCount = 0;
+        let privateCount = 0;
+        let secretCount = 0;
+        const noStrategyColumns = [];
+        const secretColumns = [];
+        logger.info('Classification audit:');
+        for (const [table, cols] of Object.entries(manifest.tables)) {
+            logger.info(`  ${table}:`);
+            for (const [col, info] of Object.entries(cols)) {
+                const { classification, anonymize_strategy } = info;
+                const strategyLabel = anonymize_strategy ?? '(null → will be nulled on clone)';
+                if (classification === 'public') {
+                    publicCount++;
+                    logger.info(`    ${col.padEnd(30)} public`);
+                }
+                else if (classification === 'secret') {
+                    secretCount++;
+                    secretColumns.push(`${table}.${col}`);
+                    if (!anonymize_strategy)
+                        noStrategyColumns.push(`${table}.${col}`);
+                    logger.info(`    ${col.padEnd(30)} secret   ${strategyLabel}`);
+                }
+                else {
+                    privateCount++;
+                    if (!anonymize_strategy)
+                        noStrategyColumns.push(`${table}.${col}`);
+                    logger.info(`    ${col.padEnd(30)} private  ${strategyLabel}`);
+                }
+            }
+        }
+        const total = publicCount + privateCount + secretCount;
+        logger.info('');
+        logger.info(`Summary: ${total} columns total — ` +
+            `${publicCount} public, ${privateCount} private, ${secretCount} secret`);
+        if (secretColumns.length > 0) {
+            logger.info(`Secret columns (extra-sensitive): ${secretColumns.join(', ')}`);
+        }
+        if (noStrategyColumns.length > 0) {
+            logger.warn(`${noStrategyColumns.length} private/secret column(s) have no anonymize strategy ` +
+                `and will be NULLed on clone: ${noStrategyColumns.join(', ')}`);
+        }
+    },
+});

package/dist/src/functions/commands/db-migrate.js

@@ -1,22 +1,18 @@
 import { pikkuSessionlessFunc } from '#pikku';
-import { resolveLocalDb, migrateAndCodegen } from '../db/local-db.js';
+import { resolveDb, migrateAndCodegen } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbMigrate = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
-        const userConfig = await loadUserConfigForDb({
-            config,
-            getInspectorState,
-            logger,
-        });
+    func: async ({ logger, config }) => {
+        const userConfig = await loadUserConfigForDb({ config, logger });
         if (!userConfig)
             return;
-        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        const resolved = resolveDb(userConfig, config.rootDir, config.outDir, config.runtimeDir);
         if (!resolved) {
-            logger.error('pikku db migrate: dev.db is not configured in your pikku config.');
-            throw new Error('dev.db not configured');
+            logger.error('pikku db migrate: no database configured — set sqliteDb or postgresUrl in your createConfig.');
+            throw new Error('no database configured');
         }
-        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        const { migrate, codegen, zod } = await migrateAndCodegen(resolved);
         if (migrate.applied.length === 0) {
             logger.info(`db migrate: no pending migrations (${migrate.skipped.length} already applied)`);
         }

package/dist/src/functions/commands/db-reset.js

@@ -1,24 +1,24 @@
 import { pikkuSessionlessFunc } from '#pikku';
-import { resolveLocalDb, reset, migrateAndCodegen, seed, } from '../db/local-db.js';
+import { resolveDb, reset, migrateAndCodegen, seed } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbReset = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
-        const userConfig = await loadUserConfigForDb({
-            config,
-            getInspectorState,
-            logger,
-        });
+    func: async ({ logger, config }) => {
+        const userConfig = await loadUserConfigForDb({ config, logger });
         if (!userConfig)
             return;
-        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        const resolved = resolveDb(userConfig, config.rootDir, config.outDir, config.runtimeDir);
         if (!resolved) {
-            logger.error('pikku db reset: dev.db is not configured in your pikku config.');
-            throw new Error('dev.db not configured');
+            logger.error('pikku db reset: no database configured — set sqliteDb in your createConfig.');
+            throw new Error('no database configured');
+        }
+        if (resolved.dialect !== 'sqlite') {
+            logger.error('pikku db reset: reset is only supported for SQLite databases.');
+            throw new Error('reset not supported for postgres');
         }
         reset(resolved, config.rootDir);
         logger.info(`db reset: removed ${resolved.dbFile}`);
-        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        const { migrate, codegen, zod } = await migrateAndCodegen(resolved);
         for (const name of migrate.applied) {
             logger.info(`db reset: applied ${name}`);
         }
@@ -28,7 +28,7 @@ export const dbReset = pikkuSessionlessFunc({
         logger.info(zod.written
             ? `db reset: regenerated ${zod.outFile} (${zod.tables.length} tables)`
             : `db reset: ${zod.outFile} unchanged`);
-        const seedResult = seed(resolved);
+        const seedResult = await seed(resolved);
         if (seedResult.applied) {
             logger.info(`db reset: seeded ${resolved.seedFile} (${seedResult.bytes} bytes)`);
         }

package/dist/src/functions/commands/db-seed.js

@@ -1,22 +1,22 @@
 import { pikkuSessionlessFunc } from '#pikku';
-import { resolveLocalDb, seed } from '../db/local-db.js';
+import { resolveDb, seed } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbSeed = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
-        const userConfig = await loadUserConfigForDb({
-            config,
-            getInspectorState,
-            logger,
-        });
+    func: async ({ logger, config }) => {
+        const userConfig = await loadUserConfigForDb({ config, logger });
         if (!userConfig)
             return;
-        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        const resolved = resolveDb(userConfig, config.rootDir, config.outDir, config.runtimeDir);
         if (!resolved) {
-            logger.error('pikku db seed: dev.db is not configured in your pikku config.');
-            throw new Error('dev.db not configured');
+            logger.error('pikku db seed: no database configured — set sqliteDb in your createConfig.');
+            throw new Error('no database configured');
         }
-        const result = seed(resolved);
+        if (resolved.dialect !== 'sqlite') {
+            logger.error('pikku db seed: seed is only supported for SQLite databases.');
+            throw new Error('seed not supported for postgres');
+        }
+        const result = await seed(resolved);
         if (!result.applied) {
             logger.info(`db seed: no ${resolved.seedFile} found, nothing to do`);
         }

package/dist/src/functions/commands/db-shared.d.ts

@@ -1,32 +1,17 @@
-import type { DevDbConfig } from '../db/local-db.js';
 export interface UserConfigShape {
-    dev?: {
-        db?: DevDbConfig;
-    };
+    sqliteDb?: string;
+    postgresUrl?: string;
     [key: string]: unknown;
 }
 interface LoadOptions {
     config: {
         rootDir: string;
-        outDir: string;
+        srcDirectories: string[];
     };
-    getInspectorState: (refresh: boolean) => Promise<{
-        filesAndMethods: {
-            pikkuConfigFactory?: {
-                file: string;
-                variable: string;
-            };
-        };
-    }>;
     logger: {
         error: (msg: string) => void;
+        warn: (msg: string) => void;
     };
 }
-/**
- * Load the user's pikkuConfig the same way `dev.ts` does — through the
- * inspector state, then by importing the user's config factory file.
- * Returns `null` (and logs the error) if the project hasn't defined a
- * pikkuConfigFactory, so the caller can early-exit.
- */
 export declare function loadUserConfigForDb(options: LoadOptions): Promise<UserConfigShape | null>;
 export {};

package/dist/src/functions/commands/db-shared.js

@@ -1,25 +1,61 @@
-import { resolve } from 'path';
-import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
-/**
- * Load the user's pikkuConfig the same way `dev.ts` does — through the
- * inspector state, then by importing the user's config factory file.
- * Returns `null` (and logs the error) if the project hasn't defined a
- * pikkuConfigFactory, so the caller can early-exit.
- */
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { loadUserModule } from './load-user-project.js';
+function findUserConfigFactoryFile(rootDir, srcDirectories) {
+    for (const srcDir of srcDirectories) {
+        for (const name of ['config.ts', 'config.js']) {
+            const candidate = resolve(rootDir, srcDir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    for (const name of ['config.ts', 'config.js']) {
+        const candidate = join(rootDir, name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 export async function loadUserConfigForDb(options) {
-    const { config, getInspectorState, logger } = options;
-    const inspectorState = await getInspectorState(true);
-    const { pikkuConfigFactory } = inspectorState.filesAndMethods;
-    if (!pikkuConfigFactory) {
+    const { config, logger } = options;
+    const hasSqliteDbAssets = existsSync(join(config.rootDir, 'db', 'sqlite'));
+    const hasPostgresDbAssets = existsSync(join(config.rootDir, 'db', 'postgres'));
+    const hasConventionalDbAssets = hasSqliteDbAssets || hasPostgresDbAssets;
+    const getFallbackConfig = () => {
+        if (hasSqliteDbAssets)
+            return { sqliteDb: '.pikku-runtime/dev.db' };
+        if (hasPostgresDbAssets) {
+            logger.error('Postgres assets detected but postgresUrl is not configured in createConfig.');
+            return null;
+        }
+        return null;
+    };
+    const configFactoryFile = findUserConfigFactoryFile(config.rootDir, config.srcDirectories);
+    if (!configFactoryFile) {
+        if (hasConventionalDbAssets) {
+            return getFallbackConfig();
+        }
         logger.error('createConfig must be defined in your project');
         return null;
     }
-    const pikkuDir = resolve(config.rootDir, config.outDir);
-    await loadUserBootstrap(pikkuDir);
-    const configModule = await loadUserModule(pikkuConfigFactory.file);
-    const userCreateConfig = configModule[pikkuConfigFactory.variable];
+    let configModule;
+    try {
+        configModule = await loadUserModule(configFactoryFile);
+    }
+    catch (error) {
+        if (hasConventionalDbAssets) {
+            logger.warn(`Falling back to default local db config because '${configFactoryFile}' could not be loaded: ${error.message}`);
+            return getFallbackConfig();
+        }
+        throw error;
+    }
+    const userCreateConfig = configModule.createConfig;
     if (typeof userCreateConfig !== 'function') {
-        logger.error(`Expected '${pikkuConfigFactory.variable}' in '${pikkuConfigFactory.file}' to be a function`);
+        if (hasConventionalDbAssets) {
+            logger.warn(`Falling back to default local db config because '${configFactoryFile}' does not export createConfig`);
+            return getFallbackConfig();
+        }
+        logger.error(`Expected 'createConfig' in '${configFactoryFile}' to be a function`);
         return null;
     }
     return (await userCreateConfig());