schematic-pg 0.1.7 → 0.1.8

package/dist/api-generator/route-generator.js

@@ -7,9 +7,11 @@ import { hasPolicies } from './utils/policy.js';
 export class RouteGenerator {
     model;
     schema;
-    constructor(model, schema) {
+    modelsWithHooks;
+    constructor(model, schema, modelsWithHooks = new Set()) {
         this.model = model;
         this.schema = schema;
+        this.modelsWithHooks = modelsWithHooks;
     }
     generate() {
         const clientKey = getClientExportName(this.model.name);
@@ -23,6 +25,7 @@ export class RouteGenerator {
         const listQuerySchemaName = `${this.model.name}ListQuerySchema`;
         const getQuerySchemaName = `${this.model.name}GetQuerySchema`;
         const modelHasPolicies = hasPolicies(this.model);
+        const modelHasHooks = this.modelsWithHooks.has(this.model.name);
         const constantPrefix = toModelConstantPrefix(this.model.name);
         return [
             '// Auto-generated by RouteGenerator. Do not edit manually.',
@@ -39,6 +42,11 @@ export class RouteGenerator {
                     `import { assertPolicy, mergeWhere, resolvePolicyWhere } from '${PACKAGE_NAME}/api/auth/policy';`,
                 ]
                 : []),
+            ...(modelHasHooks
+                ? [
+                    `import { cancelledResponse, createHookContext, runAfterHooks, runBeforeHooks } from '${PACKAGE_NAME}/api/hooks';`,
+                ]
+                : []),
             `import {`,
             `  ${this.model.name}CreateSchema,`,
             `  ${this.model.name}UpdateSchema,`,
@@ -59,11 +67,11 @@ export class RouteGenerator {
             '',
             ...this.generateGetRoute(clientKey, pathParams, paramSchemaName, getQuerySchemaName, whereFromParams, modelHasPolicies, constantPrefix),
             '',
-            ...this.generateCreateRoute(clientKey, modelHasPolicies, constantPrefix),
+            ...this.generateCreateRoute(clientKey, modelHasPolicies, modelHasHooks, constantPrefix),
             '',
-            ...this.generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
+            ...this.generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, modelHasHooks, constantPrefix),
             '',
-            ...this.generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
+            ...this.generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, modelHasHooks, constantPrefix),
             '',
             'export default router;',
             '',
@@ -166,75 +174,88 @@ export class RouteGenerator {
             '});',
         ];
     }
-    generateCreateRoute(clientKey, modelHasPolicies, constantPrefix) {
-        if (!modelHasPolicies) {
-            return [
-                `router.post('/', validateJson(${this.model.name}CreateSchema), async (c) => {`,
-                '  const db = c.get(\'db\');',
-                '  const body = c.req.valid(\'json\');',
-                `  const row = await db.${clientKey}.create(body);`,
-                `  return ${this.mutationJsonRow('row', constantPrefix, 201)};`,
-                '});',
-            ];
-        }
-        return [
+    generateCreateRoute(clientKey, modelHasPolicies, modelHasHooks, constantPrefix) {
+        const lines = [
             `router.post('/', validateJson(${this.model.name}CreateSchema), async (c) => {`,
             '  const db = c.get(\'db\');',
-            '  const auth = c.get(\'auth\');',
-            `  assertPolicy('${this.model.name}', auth.role, 'insert');`,
-            '  const body = c.req.valid(\'json\');',
-            `  const row = await db.${clientKey}.create(body);`,
-            `  return ${this.mutationJsonRow('row', constantPrefix, 201)};`,
-            '});',
         ];
-    }
-    generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
-        if (!modelHasPolicies) {
-            return [
-                `router.put('/${pathParams}', validateParam(${paramSchemaName}), validateJson(${this.model.name}UpdateSchema), async (c) => {`,
-                '  const db = c.get(\'db\');',
-                '  const params = c.req.valid(\'param\');',
-                '  const body = c.req.valid(\'json\');',
-                `  const row = await db.${clientKey}.update({ where: { ${whereFromParams} }, data: body });`,
-                `  return ${this.mutationJsonRow('row', constantPrefix)};`,
-                '});',
-            ];
+        if (modelHasPolicies || modelHasHooks) {
+            lines.push('  const auth = c.get(\'auth\');');
         }
-        return [
+        if (modelHasPolicies) {
+            lines.push(`  assertPolicy('${this.model.name}', auth.role, 'insert');`);
+        }
+        lines.push('  const body = c.req.valid(\'json\');');
+        if (modelHasHooks) {
+            lines.push(`  const hookCtx = createHookContext({ c, db, auth, model: '${this.model.name}', operation: 'create', data: body });`, `  const gate = await runBeforeHooks('${this.model.name}', 'create', hookCtx);`, '  if (!gate.proceed) return gate.response ?? cancelledResponse(c);', `  const row = await db.${clientKey}.create(hookCtx.data);`, '  hookCtx.result = row;', `  await runAfterHooks('${this.model.name}', 'create', hookCtx);`, `  return ${this.mutationJsonRow('hookCtx.result', constantPrefix, 201)};`);
+        }
+        else {
+            lines.push(`  const row = await db.${clientKey}.create(body);`, `  return ${this.mutationJsonRow('row', constantPrefix, 201)};`);
+        }
+        lines.push('});');
+        return lines;
+    }
+    generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, modelHasHooks, constantPrefix) {
+        const lines = [
             `router.put('/${pathParams}', validateParam(${paramSchemaName}), validateJson(${this.model.name}UpdateSchema), async (c) => {`,
             '  const db = c.get(\'db\');',
-            '  const auth = c.get(\'auth\');',
-            `  const policy = assertPolicy('${this.model.name}', auth.role, 'update');`,
-            '  const policyWhere = resolvePolicyWhere(policy, auth);',
-            '  const params = c.req.valid(\'param\');',
-            '  const body = c.req.valid(\'json\');',
-            `  const row = await db.${clientKey}.update({ where: mergeWhere({ ${whereFromParams} }, policyWhere), data: body });`,
-            `  return ${this.mutationJsonRow('row', constantPrefix)};`,
-            '});',
         ];
-    }
-    generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
-        if (!modelHasPolicies) {
-            return [
-                `router.delete('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
-                '  const db = c.get(\'db\');',
-                '  const params = c.req.valid(\'param\');',
-                `  const row = await db.${clientKey}.delete({ ${whereFromParams} });`,
-                `  return ${this.mutationJsonRow('row', constantPrefix)};`,
-                '});',
-            ];
+        if (modelHasPolicies || modelHasHooks) {
+            lines.push('  const auth = c.get(\'auth\');');
         }
-        return [
+        if (modelHasPolicies) {
+            lines.push(`  const policy = assertPolicy('${this.model.name}', auth.role, 'update');`, '  const policyWhere = resolvePolicyWhere(policy, auth);');
+        }
+        lines.push('  const params = c.req.valid(\'param\');', '  const body = c.req.valid(\'json\');');
+        if (modelHasHooks) {
+            lines.push(`  const hookCtx = createHookContext({ c, db, auth, model: '${this.model.name}', operation: 'update', data: body, params });`, `  const gate = await runBeforeHooks('${this.model.name}', 'update', hookCtx);`, '  if (!gate.proceed) return gate.response ?? cancelledResponse(c);');
+            if (modelHasPolicies) {
+                lines.push(`  const row = await db.${clientKey}.update({ where: mergeWhere({ ${whereFromParams} }, policyWhere), data: hookCtx.data });`);
+            }
+            else {
+                lines.push(`  const row = await db.${clientKey}.update({ where: { ${whereFromParams} }, data: hookCtx.data });`);
+            }
+            lines.push('  hookCtx.result = row;', `  await runAfterHooks('${this.model.name}', 'update', hookCtx);`, `  return ${this.mutationJsonRow('hookCtx.result', constantPrefix)};`);
+        }
+        else if (modelHasPolicies) {
+            lines.push(`  const row = await db.${clientKey}.update({ where: mergeWhere({ ${whereFromParams} }, policyWhere), data: body });`, `  return ${this.mutationJsonRow('row', constantPrefix)};`);
+        }
+        else {
+            lines.push(`  const row = await db.${clientKey}.update({ where: { ${whereFromParams} }, data: body });`, `  return ${this.mutationJsonRow('row', constantPrefix)};`);
+        }
+        lines.push('});');
+        return lines;
+    }
+    generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, modelHasHooks, constantPrefix) {
+        const lines = [
             `router.delete('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
             '  const db = c.get(\'db\');',
-            '  const auth = c.get(\'auth\');',
-            `  const policy = assertPolicy('${this.model.name}', auth.role, 'delete');`,
-            '  const policyWhere = resolvePolicyWhere(policy, auth);',
-            '  const params = c.req.valid(\'param\');',
-            `  const row = await db.${clientKey}.delete(mergeWhere({ ${whereFromParams} }, policyWhere));`,
-            `  return ${this.mutationJsonRow('row', constantPrefix)};`,
-            '});',
         ];
+        if (modelHasPolicies || modelHasHooks) {
+            lines.push('  const auth = c.get(\'auth\');');
+        }
+        if (modelHasPolicies) {
+            lines.push(`  const policy = assertPolicy('${this.model.name}', auth.role, 'delete');`, '  const policyWhere = resolvePolicyWhere(policy, auth);');
+        }
+        lines.push('  const params = c.req.valid(\'param\');');
+        if (modelHasHooks) {
+            lines.push(`  const hookCtx = createHookContext({ c, db, auth, model: '${this.model.name}', operation: 'delete', params });`, `  const gate = await runBeforeHooks('${this.model.name}', 'delete', hookCtx);`, '  if (!gate.proceed) return gate.response ?? cancelledResponse(c);');
+            if (modelHasPolicies) {
+                lines.push(`  const row = await db.${clientKey}.delete(mergeWhere({ ${whereFromParams} }, policyWhere));`);
+            }
+            else {
+                lines.push(`  const row = await db.${clientKey}.delete({ ${whereFromParams} });`);
+            }
+            lines.push('  hookCtx.result = row;', `  await runAfterHooks('${this.model.name}', 'delete', hookCtx);`, `  return ${this.mutationJsonRow('hookCtx.result', constantPrefix)};`);
+        }
+        else if (modelHasPolicies) {
+            lines.push(`  const row = await db.${clientKey}.delete(mergeWhere({ ${whereFromParams} }, policyWhere));`, `  return ${this.mutationJsonRow('row', constantPrefix)};`);
+        }
+        else {
+            lines.push(`  const row = await db.${clientKey}.delete({ ${whereFromParams} });`, `  return ${this.mutationJsonRow('row', constantPrefix)};`);
+        }
+        lines.push('});');
+        return lines;
     }
     getRouteFileName() {
         return toRouteFileName(this.model.name);
@@ -243,10 +264,10 @@ export class RouteGenerator {
         return toRouteBasePath(this.model.name);
     }
 }
-export function generateRouteFiles(schema) {
+export function generateRouteFiles(schema, modelsWithHooks = new Set()) {
     const files = new Map();
     for (const model of schema.models) {
-        const generator = new RouteGenerator(model, schema);
+        const generator = new RouteGenerator(model, schema, modelsWithHooks);
         files.set(generator.getRouteFileName(), generator.generate());
     }
     return files;

package/dist/cli/dev.js

@@ -1,11 +1,10 @@
-import { spawn } from 'node:child_process';
 import { watch } from 'node:fs';
 import path from 'node:path';
 import { runDbBootstrap } from './db.js';
 import { generateAll } from './generate.js';
 import { DEFAULT_OUTPUT_DIR, resolveSchemaPath } from './paths.js';
+import { startAppServer, stopAppServer, waitForAppServerExit } from './server.js';
 const WATCH_DEBOUNCE_MS = 300;
-const SERVER_STOP_TIMEOUT_MS = 5000;
 function parseDevArgs(args) {
     let schemaPath = resolveSchemaPath();
     let watchSchema = true;
@@ -29,36 +28,6 @@ function createDebouncer(fn, ms) {
         }, ms);
     };
 }
-function startServer(appPath) {
-    return spawn(process.execPath, ['--import', 'tsx', appPath], {
-        stdio: 'inherit',
-        cwd: process.cwd(),
-    });
-}
-function stopServer(serverProcess) {
-    if (!serverProcess || serverProcess.exitCode !== null || serverProcess.killed) {
-        return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-        serverProcess.once('exit', () => resolve());
-        if (process.platform === 'win32') {
-            serverProcess.kill();
-        }
-        else {
-            serverProcess.kill('SIGTERM');
-        }
-        setTimeout(() => {
-            if (serverProcess.exitCode === null && !serverProcess.killed) {
-                serverProcess.kill('SIGKILL');
-            }
-        }, SERVER_STOP_TIMEOUT_MS);
-    });
-}
-function waitForServerExit(serverProcess) {
-    return new Promise((resolve) => {
-        serverProcess.once('exit', () => resolve());
-    });
-}
 export async function runDev(args = []) {
     const { schemaPath, watchSchema } = parseDevArgs(args);
     const appPath = path.resolve(DEFAULT_OUTPUT_DIR, 'app.ts');
@@ -74,8 +43,8 @@ export async function runDev(args = []) {
         try {
             await generateAll(schemaPath);
             await runDbBootstrap(schemaPath);
-            await stopServer(serverProcess);
-            serverProcess = startServer(appPath);
+            await stopAppServer(serverProcess);
+            serverProcess = startAppServer(appPath);
             serverProcess.on('exit', (code, signal) => {
                 if (restarting || shuttingDown) {
                     return;
@@ -119,7 +88,7 @@ export async function runDev(args = []) {
             return;
         }
         shuttingDown = true;
-        await stopServer(serverProcess);
+        await stopAppServer(serverProcess);
     }
     process.once('SIGINT', () => {
         void shutdown().finally(() => {
@@ -134,7 +103,7 @@ export async function runDev(args = []) {
     await syncAndServe();
     if (!watchSchema) {
         if (serverProcess) {
-            await waitForServerExit(serverProcess);
+            await waitForAppServerExit(serverProcess);
         }
         return;
     }

package/dist/cli/generate.js

@@ -34,6 +34,7 @@ export async function generateApi(schemaPath) {
     await mkdir(schemasDir, { recursive: true });
     await writeFile(path.join(outputDir, 'app.ts'), files.app, 'utf8');
     await writeFile(path.join(outputDir, 'policies.ts'), files.policies, 'utf8');
+    await writeFile(path.join(outputDir, 'hooks.ts'), files.hooks, 'utf8');
     await writeFile(path.join(schemasDir, 'validation.ts'), files.validation, 'utf8');
     for (const [fileName, content] of files.routes) {
         await writeFile(path.join(routesDir, fileName), content, 'utf8');

package/dist/cli/hooks.d.ts

@@ -0,0 +1,6 @@
+export interface RunHooksAddOptions {
+    schemaPath?: string;
+    modelName?: string;
+    hooksDir?: string;
+}
+export declare function runHooksAdd(args: string[], options?: RunHooksAddOptions): Promise<string>;

package/dist/cli/hooks.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { select } from '@inquirer/prompts';
+import { discoverHooks } from '../api-generator/hook-scanner.js';
+import { PACKAGE_NAME } from '../constants.js';
+import { parse } from '../schema-dsl/index.js';
+import { DEFAULT_HOOKS_DIR, resolveSchemaPath } from './paths.js';
+import { createHookFileTemplate } from './templates.js';
+function parseModelFlag(args) {
+    const modelIndex = args.indexOf('--model');
+    if (modelIndex === -1) {
+        return undefined;
+    }
+    const modelName = args[modelIndex + 1];
+    if (!modelName || modelName.startsWith('--')) {
+        throw new Error('Missing value for --model');
+    }
+    return modelName;
+}
+function resolveSchemaArg(args) {
+    const positional = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--model') {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+        }
+    }
+    return positional[0];
+}
+function getHookFilePath(hooksDir, modelName) {
+    return path.join(hooksDir, `${modelName}.ts`);
+}
+function assertModelExists(schema, modelName) {
+    const model = schema.models.find((entry) => entry.name === modelName);
+    if (!model) {
+        throw new Error(`Model "${modelName}" was not found in schema`);
+    }
+    return model;
+}
+function assertHookFileDoesNotExist(hooksDir, modelName) {
+    const hookFilePath = getHookFilePath(hooksDir, modelName);
+    if (existsSync(hookFilePath)) {
+        throw new Error(`Hook file already exists: ${hookFilePath}`);
+    }
+}
+async function promptForModel(models, hooksDir, schema) {
+    const { modelsWithHooks } = discoverHooks(hooksDir, schema);
+    const availableModels = models
+        .map((model) => model.name)
+        .filter((modelName) => !modelsWithHooks.has(modelName))
+        .sort((left, right) => left.localeCompare(right));
+    if (availableModels.length === 0) {
+        throw new Error('All schema models already have hook files in src/hooks/');
+    }
+    return select({
+        message: 'Select a model to scaffold lifecycle hooks',
+        choices: availableModels.map((modelName) => ({
+            name: modelName,
+            value: modelName,
+        })),
+    });
+}
+export async function runHooksAdd(args, options = {}) {
+    const schemaPath = resolveSchemaPath(options.schemaPath ?? resolveSchemaArg(args));
+    const hooksDir = options.hooksDir ?? DEFAULT_HOOKS_DIR;
+    const source = await readFile(schemaPath, 'utf8');
+    const schema = parse(source);
+    if (schema.models.length === 0) {
+        throw new Error('Schema has no models');
+    }
+    const modelName = options.modelName ?? parseModelFlag(args) ?? (await promptForModel(schema.models, hooksDir, schema));
+    assertModelExists(schema, modelName);
+    assertHookFileDoesNotExist(hooksDir, modelName);
+    await mkdir(hooksDir, { recursive: true });
+    const hookFilePath = getHookFilePath(hooksDir, modelName);
+    await writeFile(hookFilePath, createHookFileTemplate(modelName), 'utf8');
+    console.log(`Created ${path.relative(process.cwd(), hookFilePath)}`);
+    console.log(`\nNext step: run \`${PACKAGE_NAME} generate:api\` to wire hooks into generated routes.`);
+    return hookFilePath;
+}

package/dist/cli/init.js

@@ -66,6 +66,7 @@ export async function runInit(args) {
     }
     await mkdir(targetDir, { recursive: true });
     await mkdir(path.join(targetDir, 'src/routes'), { recursive: true });
+    await mkdir(path.join(targetDir, 'src/hooks'), { recursive: true });
     for (const file of INIT_FILES) {
         const filePath = path.join(targetDir, file.relativePath);
         if (existsSync(filePath)) {
@@ -108,7 +109,11 @@ export async function runInit(args) {
     console.log('  docker compose up -d --wait');
     console.log(`  npx ${PACKAGE_NAME} dev   # generate + bootstrap + server + schema watch`);
     console.log('');
-    console.log('  # split steps (dev already includes generate, bootstrap, and watch):');
+    console.log('  # production:');
+    console.log(`  npx ${PACKAGE_NAME} generate`);
+    console.log(`  npx ${PACKAGE_NAME} start   # migrate DB + run server`);
+    console.log('');
+    console.log('  # split dev steps (dev already includes generate, bootstrap, and watch):');
     console.log(`  npx ${PACKAGE_NAME} generate`);
     console.log(`  npx ${PACKAGE_NAME} db:bootstrap`);
     console.log(`  npx ${PACKAGE_NAME} dev --no-watch`);

package/dist/cli/paths.d.ts

@@ -1,5 +1,6 @@
 export declare const DEFAULT_SCHEMA_FILE = "app.schema";
 export declare const DEFAULT_OUTPUT_DIR = "generated";
 export declare const DEFAULT_CUSTOM_ROUTES_DIR: string;
+export declare const DEFAULT_HOOKS_DIR: string;
 export declare function resolveSchemaPath(schemaArg?: string): string;
 export declare function resolveOutputDir(): string;

package/dist/cli/paths.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 export const DEFAULT_SCHEMA_FILE = 'app.schema';
 export const DEFAULT_OUTPUT_DIR = 'generated';
 export const DEFAULT_CUSTOM_ROUTES_DIR = path.resolve('src/routes');
+export const DEFAULT_HOOKS_DIR = path.resolve('src/hooks');
 export function resolveSchemaPath(schemaArg) {
     return path.resolve(schemaArg ?? DEFAULT_SCHEMA_FILE);
 }

package/dist/cli/server.d.ts

@@ -0,0 +1,5 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function startAppServer(appPath: string, env?: NodeJS.ProcessEnv): ChildProcess;
+export declare function stopAppServer(serverProcess: ChildProcess | null): Promise<void>;
+export declare function waitForAppServerExit(serverProcess: ChildProcess): Promise<void>;
+export declare function runAppServerUntilExit(appPath: string, env?: NodeJS.ProcessEnv): Promise<number | null>;

package/dist/cli/server.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+const SERVER_STOP_TIMEOUT_MS = 5000;
+export function startAppServer(appPath, env) {
+    return spawn(process.execPath, ['--import', 'tsx', appPath], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: env ? { ...process.env, ...env } : process.env,
+    });
+}
+export function stopAppServer(serverProcess) {
+    if (!serverProcess || serverProcess.exitCode !== null || serverProcess.killed) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        serverProcess.once('exit', () => resolve());
+        if (process.platform === 'win32') {
+            serverProcess.kill();
+        }
+        else {
+            serverProcess.kill('SIGTERM');
+        }
+        setTimeout(() => {
+            if (serverProcess.exitCode === null && !serverProcess.killed) {
+                serverProcess.kill('SIGKILL');
+            }
+        }, SERVER_STOP_TIMEOUT_MS);
+    });
+}
+export function waitForAppServerExit(serverProcess) {
+    return new Promise((resolve) => {
+        serverProcess.once('exit', () => resolve());
+    });
+}
+export async function runAppServerUntilExit(appPath, env) {
+    let serverProcess = null;
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        await stopAppServer(serverProcess);
+    }
+    process.once('SIGINT', () => {
+        void shutdown().finally(() => {
+            process.exit(process.exitCode ?? 0);
+        });
+    });
+    process.once('SIGTERM', () => {
+        void shutdown().finally(() => {
+            process.exit(process.exitCode ?? 0);
+        });
+    });
+    serverProcess = startAppServer(appPath, env);
+    return new Promise((resolve) => {
+        serverProcess.once('exit', (code) => {
+            resolve(code);
+        });
+    });
+}

package/dist/cli/start.d.ts

@@ -0,0 +1,7 @@
+type StartOptions = {
+    schemaPath: string;
+    migrate: boolean;
+};
+export declare function parseStartArgs(args: string[]): StartOptions;
+export declare function runStart(args?: string[]): Promise<void>;
+export {};

package/dist/cli/start.js

@@ -0,0 +1,35 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { runDbMigrate } from './db.js';
+import { DEFAULT_OUTPUT_DIR, resolveSchemaPath } from './paths.js';
+import { runAppServerUntilExit } from './server.js';
+import { waitForDatabase } from './wait-for-database.js';
+export function parseStartArgs(args) {
+    let schemaPath = resolveSchemaPath();
+    let migrate = true;
+    for (const arg of args) {
+        if (arg === '--no-migrate') {
+            migrate = false;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            schemaPath = resolveSchemaPath(arg);
+        }
+    }
+    return { schemaPath, migrate };
+}
+export async function runStart(args = []) {
+    const { schemaPath, migrate } = parseStartArgs(args);
+    const appPath = path.resolve(DEFAULT_OUTPUT_DIR, 'app.ts');
+    if (!existsSync(appPath)) {
+        throw new Error(`Missing ${appPath}. Run "schematic-pg generate" first to create the app entry point.`);
+    }
+    await waitForDatabase();
+    if (migrate) {
+        await runDbMigrate([schemaPath]);
+    }
+    const exitCode = await runAppServerUntilExit(appPath, { NODE_ENV: 'production' });
+    if (exitCode !== 0 && exitCode !== null) {
+        process.exitCode = exitCode;
+    }
+}

package/dist/cli/templates.d.ts

@@ -6,3 +6,4 @@ export declare const TSCONFIG_TEMPLATE = "{\n  \"compilerOptions\": {\n    \"tar
 export declare const MAKEFILE_TEMPLATE = ".PHONY: dev\n\ndev:\n\tdocker compose up -d --wait\n\tnpx schematic-pg dev\n";
 export declare const HEALTH_ROUTE_TEMPLATE = "import { Hono } from 'hono';\nimport type { AppEnv } from 'schematic-pg/api/types';\n\nconst router = new Hono<AppEnv>();\nrouter.get('/', (c) => c.json({ ok: true }));\nexport default router;\n";
 export declare function createPackageJsonTemplate(projectName: string): string;
+export declare function createHookFileTemplate(modelName: string): string;

package/dist/cli/templates.js

@@ -83,6 +83,7 @@ export function createPackageJsonTemplate(projectName) {
         type: 'module',
         scripts: {
             dev: `${PACKAGE_NAME} dev`,
+            start: `${PACKAGE_NAME} start`,
             generate: `${PACKAGE_NAME} generate`,
             'db:bootstrap': `${PACKAGE_NAME} db:bootstrap`,
             'db:migrate': `${PACKAGE_NAME} db:migrate`,
@@ -101,3 +102,38 @@ export function createPackageJsonTemplate(projectName) {
         },
     }, null, 2);
 }
+export function createHookFileTemplate(modelName) {
+    return `import { defineHooks } from '${PACKAGE_NAME}/api/hooks';
+import type { ${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput } from '../../generated/db-types.js';
+
+export default defineHooks<${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput>({
+  async beforeCreate(ctx, next) {
+    // ctx.data is the create payload (mutable). Call await next() to proceed.
+    // Cancel without calling next(): return ctx.abort(422, 'reason');
+    await next();
+  },
+
+  async afterCreate(ctx) {
+    // ctx.result is the created row. Use ctx.db / ctx.auth for side effects.
+  },
+
+  async beforeUpdate(ctx, next) {
+    // ctx.params — route params (e.g. id). ctx.data — update payload (mutable).
+    await next();
+  },
+
+  async afterUpdate(ctx) {
+    // ctx.result is the updated row.
+  },
+
+  async beforeDelete(ctx, next) {
+    // ctx.params — route params. No ctx.data on delete.
+    await next();
+  },
+
+  async afterDelete(ctx) {
+    // ctx.result is the deleted row.
+  },
+});
+`;
+}

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { runDbBootstrap, runDbDiff, runDbMigrate, runDbPing } from './cli/db.js';
 import { runDev } from './cli/dev.js';
+import { runStart } from './cli/start.js';
 import { generateAll, generateApi, generateClient, generateSql } from './cli/generate.js';
+import { runHooksAdd } from './cli/hooks.js';
 import { runInit } from './cli/init.js';
 import { PACKAGE_NAME } from './constants.js';
 const USAGE = `Usage: ${PACKAGE_NAME} <command> [options]
@@ -12,7 +14,9 @@ Commands:
   generate:sql [schema]      Generate SQL DDL to stdout
   generate:client [schema]   Generate db client files
   generate:api [schema]      Generate API files
+  hooks:add [schema] [--model ModelName]  Scaffold lifecycle hooks for a model
   dev [schema] [--no-watch]  Generate, bootstrap DB, start server, watch schema
+  start [schema] [--no-migrate]  Run production server (migrate DB, no generate/watch)
   db:ping                    Test database connection
   db:bootstrap [schema]      Apply DDL and snapshot schema state
   db:diff [schema]           Show schema diff (--name <name> to write migration)
@@ -49,9 +53,15 @@ async function main() {
             case 'generate:api':
                 await generateApi(schemaPath);
                 break;
+            case 'hooks:add':
+                await runHooksAdd(args);
+                break;
             case 'dev':
                 await runDev(args);
                 break;
+            case 'start':
+                await runStart(args);
+                break;
             case 'db:ping':
                 await runDbPing();
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematic-pg",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Single-file backend framework for PostgreSQL and Node.js",
   "type": "module",
   "license": "MIT",
@@ -34,6 +34,10 @@
       "types": "./dist/schema-dsl/index.d.ts",
       "import": "./dist/schema-dsl/index.js"
     },
+    "./api/hooks": {
+      "types": "./dist/api/hooks/index.d.ts",
+      "import": "./dist/api/hooks/index.js"
+    },
     "./api/*": {
       "types": "./dist/api/*.d.ts",
       "import": "./dist/api/*.js"
@@ -51,6 +55,7 @@
     "generate:client": "tsx src/cli.ts generate:client",
     "generate:api": "tsx src/cli.ts generate:api",
     "dev:api": "tsx src/cli.ts dev",
+    "start": "tsx src/cli.ts start",
     "setup:env": "test -f .env || cp .env.example .env",
     "db:ping": "tsx src/cli.ts db:ping",
     "db:bootstrap": "tsx src/cli.ts db:bootstrap",
@@ -69,6 +74,7 @@
   "dependencies": {
     "@hono/node-server": "^2.0.6",
     "@hono/zod-validator": "^0.8.0",
+    "@inquirer/prompts": "^8.5.2",
     "hono": "^4.12.27",
     "pg": "^8.22.0",
     "tsx": "^4.19.4",