schematic-pg 0.1.6 → 0.1.8

package/dist/api-generator/zod-schema-generator.js

@@ -1,5 +1,6 @@
+import { PACKAGE_NAME } from '../constants.js';
 import { fieldHasAttribute, getFieldAttribute, getModelNames, getOptionalKvPair, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
-import { getFilterableFields, getOmittedFields, getSortableFieldNames, toModelConstantPrefix, } from './utils/api-fields.js';
+import { buildIncludableRelationTree, buildRelationTargets, getFilterableFields, getOmittedFields, getSortableFieldNames, toModelConstantPrefix, } from './utils/api-fields.js';
 import { buildFilterFieldMeta, queryParamKey, toFilterZodType, } from './utils/filter-operators.js';
 export class ZodSchemaGenerator {
     schema;
@@ -12,9 +13,26 @@ export class ZodSchemaGenerator {
         return [
             '// Auto-generated by ZodSchemaGenerator. Do not edit manually.',
             "import { z } from 'zod';",
+            `import { validateIncludePaths } from '${PACKAGE_NAME}/api/utils/include-query';`,
             `import type {\n  ${typeImports},\n} from '../db-types.js';`,
             '',
             ...modelBlocks,
+            this.generateGlobalMetadata(),
+        ].join('\n');
+    }
+    generateGlobalMetadata() {
+        const omitByModel = Object.fromEntries(this.schema.models.map((model) => [
+            model.name,
+            getOmittedFields(model, this.schema).map((field) => field.name),
+        ]));
+        const relationTargets = Object.fromEntries(this.schema.models.map((model) => [
+            model.name,
+            buildRelationTargets(model, this.schema),
+        ]));
+        return [
+            `export const API_OMIT_FIELDS_BY_MODEL = ${JSON.stringify(omitByModel, null, 2)} as const;`,
+            `export const API_RELATION_TARGETS = ${JSON.stringify(relationTargets, null, 2)} as const;`,
+            '',
         ].join('\n');
     }
     generateModelSchemas(model) {
@@ -49,39 +67,79 @@ export class ZodSchemaGenerator {
         const omittedFields = getOmittedFields(model, this.schema);
         const filterFieldMeta = filterableFields.map((field) => buildFilterFieldMeta(field, this.schema));
         const queryLines = filterableFields.flatMap((field) => this.generateListQueryFieldLines(field, filterFieldMeta.find((meta) => meta.name === field.name)));
-        queryLines.push('limit: z.coerce.number().int().min(1).max(100).optional(),', 'offset: z.coerce.number().int().min(0).optional(),', 'sort: z.string().optional(),');
+        queryLines.push('limit: z.coerce.number().int().min(1).max(100).optional(),', 'offset: z.coerce.number().int().min(0).optional(),', 'sort: z.string().optional(),', 'include: z.string().optional(),');
         const sortableLiteral = sortableFields.map((field) => `'${field}'`).join(', ');
         const listQueryFieldsJson = JSON.stringify(filterFieldMeta, null, 2);
         const omitFieldNames = omittedFields.map((field) => field.name);
         const omitFieldsJson = JSON.stringify(omitFieldNames);
+        const includableRelationsJson = JSON.stringify(buildIncludableRelationTree(model, this.schema), null, 2);
         const responseType = omittedFields.length === 0
             ? `export type ${model.name}Response = ${model.name};`
             : `export type ${model.name}Response = Omit<${model.name}, ${omitFieldNames.map((name) => `'${name}'`).join(' | ')}>;`;
         return [
             `export const ${prefix}_SORTABLE_FIELDS = [${sortableLiteral}] as const;`,
             `export const ${prefix}_LIST_QUERY_FIELDS = ${listQueryFieldsJson} as const;`,
+            `export const ${prefix}_INCLUDABLE_RELATIONS = ${includableRelationsJson} as const;`,
             `export const ${prefix}_OMIT_FIELDS = ${omitFieldsJson} as const;`,
             responseType + '\n',
+            `export const ${model.name}GetQuerySchema = z`,
+            '  .object({',
+            '    include: z.string().optional(),',
+            '  })',
+            ...this.generateIncludeRefinement(prefix),
+            '\n',
             `export const ${model.name}ListQuerySchema = z`,
             '  .object({',
             ...queryLines.map((line) => `    ${line}`),
             '  })',
+            ...this.generateReadQueryRefinement(prefix),
+            '\n',
+        ];
+    }
+    generateIncludeRefinement(prefix) {
+        return [
             '  .superRefine((data, ctx) => {',
-            '    if (data.sort === undefined) {',
+            '    if (data.include === undefined) {',
             '      return;',
             '    }',
-            '    const descending = data.sort.startsWith(\'-\');',
-            '    const field = descending ? data.sort.slice(1) : data.sort;',
-            `    if (!(${prefix}_SORTABLE_FIELDS as readonly string[]).includes(field)) {`,
+            `    const includeError = validateIncludePaths(data.include, ${prefix}_INCLUDABLE_RELATIONS);`,
+            '    if (includeError) {',
             '      ctx.addIssue({',
             '        code: \'custom\',',
-            '        message: `Invalid sort field "${field}"`,',
-            '        path: [\'sort\'],',
+            '        message: includeError,',
+            '        path: [\'include\'],',
             '      });',
             '    }',
             '  });\n',
         ];
     }
+    generateReadQueryRefinement(prefix) {
+        return [
+            '  .superRefine((data, ctx) => {',
+            '    if (data.sort !== undefined) {',
+            '      const descending = data.sort.startsWith(\'-\');',
+            '      const field = descending ? data.sort.slice(1) : data.sort;',
+            `      if (!(${prefix}_SORTABLE_FIELDS as readonly string[]).includes(field)) {`,
+            '        ctx.addIssue({',
+            '          code: \'custom\',',
+            '          message: `Invalid sort field "${field}"`,',
+            '          path: [\'sort\'],',
+            '        });',
+            '      }',
+            '    }',
+            '    if (data.include !== undefined) {',
+            `      const includeError = validateIncludePaths(data.include, ${prefix}_INCLUDABLE_RELATIONS);`,
+            '      if (includeError) {',
+            '        ctx.addIssue({',
+            '          code: \'custom\',',
+            '          message: includeError,',
+            '          path: [\'include\'],',
+            '        });',
+            '      }',
+            '    }',
+            '  });\n',
+        ];
+    }
     generateListQueryFieldLines(field, meta) {
         const lines = [];
         for (const operator of meta.operators) {

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

@@ -1,8 +1,9 @@
 export declare const APP_SCHEMA_TEMPLATE = "extensions {\n\n}\n\nenums {\n\n}\n\nmodels {\n  model User {\n    id:        UUID        @id @default(gen_random_uuid())\n    email:     VARCHAR(255) @unique\n    name:      VARCHAR(150)\n    createdAt: TIMESTAMP   @default(now())\n  }\n}\n";
 export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\n";
 export declare const GITIGNORE_TEMPLATE = "node_modules/\ndist/\n.env\ndocker_data/\n.DS_Store\n*.log\nnpm-debug.log*\n";
-export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgis/postgis:16-3.4\n    container_name: schematic-pg-postgres\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
+export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgis/postgis:16-3.4\n    container_name: schematic-pg\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
 export declare const TSCONFIG_TEMPLATE = "{\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"strict\": true,\n    \"esModuleInterop\": true,\n    \"skipLibCheck\": true,\n    \"outDir\": \"dist\",\n    \"rootDir\": \".\"\n  },\n  \"include\": [\"generated/**/*\", \"src/**/*\"]\n}\n";
 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

@@ -32,7 +32,7 @@ npm-debug.log*
 export const DOCKER_COMPOSE_TEMPLATE = `services:
   postgres:
     image: postgis/postgis:16-3.4
-    container_name: schematic-pg-postgres
+    container_name: schematic-pg
     restart: unless-stopped
     ports:
       - "5432:5432"
@@ -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/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const PACKAGE_NAME = "schematic-pg";
 export declare const PACKAGE_VERSION: string;
 export declare const MAX_INCLUDE_DEPTH = 10;
+export declare const MAX_INCLUDE_PATHS = 10;

package/dist/constants.js

@@ -4,3 +4,4 @@ const { version } = require('../package.json');
 export const PACKAGE_NAME = 'schematic-pg';
 export const PACKAGE_VERSION = version;
 export const MAX_INCLUDE_DEPTH = 10;
+export const MAX_INCLUDE_PATHS = 10;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematic-pg",
-  "version": "0.1.6",
+  "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",