schematic-pg 0.1.7 → 0.1.10

package/dist/api/hooks/registry.js

@@ -0,0 +1,94 @@
+const HOOK_CANCELLED_STATUS = 409;
+const HOOK_CANCELLED_MESSAGE = 'Operation cancelled by lifecycle hook';
+const BEFORE_HOOK_KEYS = {
+    create: 'beforeCreate',
+    update: 'beforeUpdate',
+    delete: 'beforeDelete',
+};
+const AFTER_HOOK_KEYS = {
+    create: 'afterCreate',
+    update: 'afterUpdate',
+    delete: 'afterDelete',
+};
+let hooks = {};
+export function configureHooks(next) {
+    hooks = next;
+}
+export function createHookContext(init) {
+    return {
+        model: init.model,
+        operation: init.operation,
+        auth: init.auth,
+        params: init.params,
+        db: init.db,
+        c: init.c,
+        data: init.data ?? {},
+        result: init.result,
+        abort(status, message) {
+            return init.c.json({ error: message }, status);
+        },
+        json(body, status = 200) {
+            return init.c.json(body, status);
+        },
+    };
+}
+export function cancelledResponse(c) {
+    return c.json({ error: HOOK_CANCELLED_MESSAGE }, HOOK_CANCELLED_STATUS);
+}
+export async function runBeforeHooks(model, operation, ctx) {
+    const modelHooks = hooks[model];
+    if (!modelHooks) {
+        return { proceed: true };
+    }
+    const hookDef = modelHooks[BEFORE_HOOK_KEYS[operation]];
+    if (!hookDef) {
+        return { proceed: true };
+    }
+    const hookList = normalizeHookList(hookDef);
+    let index = -1;
+    return dispatchBeforeHooks(hookList, ctx, 0, () => index, (nextIndex) => {
+        index = nextIndex;
+    });
+}
+export async function runAfterHooks(model, operation, ctx) {
+    const modelHooks = hooks[model];
+    if (!modelHooks) {
+        return;
+    }
+    const hookDef = modelHooks[AFTER_HOOK_KEYS[operation]];
+    if (!hookDef) {
+        return;
+    }
+    const hookList = normalizeHookList(hookDef);
+    for (const hook of hookList) {
+        await hook(ctx);
+    }
+}
+function normalizeHookList(hookDef) {
+    return Array.isArray(hookDef) ? hookDef : [hookDef];
+}
+async function dispatchBeforeHooks(hookList, ctx, currentIndex, getDispatchedIndex, setDispatchedIndex) {
+    if (currentIndex <= getDispatchedIndex()) {
+        throw new Error('next() called multiple times');
+    }
+    setDispatchedIndex(currentIndex);
+    if (currentIndex === hookList.length) {
+        return { proceed: true };
+    }
+    const hook = hookList[currentIndex];
+    let innerResult = { proceed: false };
+    let nextCalled = false;
+    const next = async () => {
+        nextCalled = true;
+        innerResult = await dispatchBeforeHooks(hookList, ctx, currentIndex + 1, getDispatchedIndex, setDispatchedIndex);
+        return innerResult;
+    };
+    const result = await hook(ctx, next);
+    if (result instanceof Response) {
+        return { proceed: false, response: result };
+    }
+    if (!nextCalled) {
+        return { proceed: false };
+    }
+    return innerResult;
+}

package/dist/api/hooks/types.d.ts

@@ -0,0 +1,48 @@
+import type { Context } from 'hono';
+import type { DbClient } from 'generated/db.js';
+import type { AuthContext } from '../auth/types.js';
+import type { AppEnv } from '../types.js';
+export type HookOperation = 'create' | 'update' | 'delete';
+export interface HookContextBase {
+    model: string;
+    operation: HookOperation;
+    auth: AuthContext;
+    params?: Record<string, unknown>;
+    db: DbClient;
+    c: Context<AppEnv>;
+    abort: (status: number, message: string) => Response;
+    json: (body: unknown, status?: number) => Response;
+}
+export interface BeforeHookContext<TData = Record<string, unknown>> extends HookContextBase {
+    data: TData;
+    result?: unknown;
+}
+export interface AfterHookContext<TRow = Record<string, unknown>> extends HookContextBase {
+    result: TRow;
+}
+export type BeforeHookNext = () => Promise<BeforeHookResult>;
+export type BeforeHook = (ctx: BeforeHookContext, next: BeforeHookNext) => Promise<Response | void>;
+export type AfterHook = (ctx: AfterHookContext) => Promise<void>;
+export interface ModelHooks {
+    beforeCreate?: BeforeHook | BeforeHook[];
+    afterCreate?: AfterHook | AfterHook[];
+    beforeUpdate?: BeforeHook | BeforeHook[];
+    afterUpdate?: AfterHook | AfterHook[];
+    beforeDelete?: BeforeHook | BeforeHook[];
+    afterDelete?: AfterHook | AfterHook[];
+}
+export type HookRegistry = Record<string, ModelHooks>;
+export interface BeforeHookResult {
+    proceed: boolean;
+    response?: Response;
+}
+export interface CreateHookContextInput {
+    c: Context<AppEnv>;
+    db: DbClient;
+    auth: AuthContext;
+    model: string;
+    operation: HookOperation;
+    data?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+    result?: unknown;
+}

package/dist/api/hooks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/api/middleware/errors.js

@@ -1,4 +1,6 @@
 import { ForbiddenError, UnauthorizedError } from '../auth/errors.js';
+import { InvalidPasswordInputError, MissingAuthPepperError, } from '../auth/password/errors.js';
+import { InvalidTokenTtlError, MissingJwtSecretError } from '../auth/token/errors.js';
 import { DatabaseError, ForeignKeyConstraintError, UniqueConstraintError, } from '../../db/errors.js';
 export const handleError = (error, c) => {
     if (error instanceof UnauthorizedError) {
@@ -13,6 +15,15 @@ export const handleError = (error, c) => {
     if (error instanceof ForeignKeyConstraintError) {
         return c.json({ error: error.message }, 400);
     }
+    if (error instanceof InvalidPasswordInputError) {
+        return c.json({ error: error.message }, 400);
+    }
+    if (error instanceof InvalidTokenTtlError) {
+        return c.json({ error: error.message }, 500);
+    }
+    if (error instanceof MissingAuthPepperError || error instanceof MissingJwtSecretError) {
+        return c.json({ error: error.message }, 500);
+    }
     if (error instanceof DatabaseError) {
         return c.json({ error: error.message }, 500);
     }

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

@@ -39,7 +39,9 @@ export class AppGenerator {
             routeImports,
             "import { createDbClient } from './db.js';",
             "import { POLICIES } from './policies.js';",
+            "import { HOOKS } from './hooks.js';",
             `import { configurePolicies } from '${PACKAGE_NAME}/api/auth/policy';`,
+            `import { configureHooks } from '${PACKAGE_NAME}/api/hooks';`,
             `import { createAuthMiddleware } from '${PACKAGE_NAME}/api/auth/middleware';`,
             `import { createJwtResolver } from '${PACKAGE_NAME}/api/auth/jwt-resolver';`,
             `import type { AuthResolver } from '${PACKAGE_NAME}/api/auth/types';`,
@@ -48,6 +50,7 @@ export class AppGenerator {
             `import type { AppEnv } from '${PACKAGE_NAME}/api/types';`,
             '',
             'configurePolicies(POLICIES);',
+            'configureHooks(HOOKS);',
             '',
             'export interface CreateAppOptions {',
             '  pool?: Pool;',

package/dist/api-generator/hook-scanner.d.ts

@@ -0,0 +1,11 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export interface HookMountEntry {
+    modelName: string;
+    importName: string;
+    importPath: string;
+}
+export interface HookDiscoveryResult {
+    entries: HookMountEntry[];
+    modelsWithHooks: Set<string>;
+}
+export declare function discoverHooks(hooksDir: string, schema: Schema): HookDiscoveryResult;

package/dist/api-generator/hook-scanner.js

@@ -0,0 +1,36 @@
+import { existsSync, readdirSync } from 'node:fs';
+function isHookFile(filename) {
+    return (filename.endsWith('.ts') &&
+        !filename.endsWith('.test.ts') &&
+        !filename.endsWith('.d.ts') &&
+        !filename.startsWith('_'));
+}
+function toHookImportName(modelName) {
+    return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}Hooks`;
+}
+export function discoverHooks(hooksDir, schema) {
+    if (!existsSync(hooksDir)) {
+        return { entries: [], modelsWithHooks: new Set() };
+    }
+    const modelNames = new Set(schema.models.map((model) => model.name));
+    const entries = [];
+    const modelsWithHooks = new Set();
+    for (const filename of readdirSync(hooksDir)) {
+        if (!isHookFile(filename)) {
+            continue;
+        }
+        const modelName = filename.replace(/\.ts$/, '');
+        if (!modelNames.has(modelName)) {
+            console.warn(`Skipping hook file "${filename}": no matching model in schema`);
+            continue;
+        }
+        entries.push({
+            modelName,
+            importName: toHookImportName(modelName),
+            importPath: `../src/hooks/${modelName}.js`,
+        });
+        modelsWithHooks.add(modelName);
+    }
+    entries.sort((left, right) => left.modelName.localeCompare(right.modelName));
+    return { entries, modelsWithHooks };
+}

package/dist/api-generator/hooks-generator.d.ts

@@ -0,0 +1,2 @@
+import type { HookMountEntry } from './hook-scanner.js';
+export declare function generateHooksFile(entries: HookMountEntry[]): string;

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

@@ -0,0 +1,25 @@
+export function generateHooksFile(entries) {
+    if (entries.length === 0) {
+        return [
+            '// Auto-generated by HooksGenerator. Do not edit manually.',
+            '',
+            'export const HOOKS = {};',
+            '',
+        ].join('\n');
+    }
+    const imports = entries
+        .map((entry) => `import ${entry.importName} from '${entry.importPath}';`)
+        .join('\n');
+    const registryEntries = entries
+        .map((entry) => `  ${entry.modelName}: ${entry.importName},`)
+        .join('\n');
+    return [
+        '// Auto-generated by HooksGenerator. Do not edit manually.',
+        imports,
+        '',
+        'export const HOOKS = {',
+        registryEntries,
+        '};',
+        '',
+    ].join('\n');
+}

package/dist/api-generator/index.d.ts

@@ -3,9 +3,11 @@ export interface GeneratedApiFiles {
     app: string;
     policies: string;
     validation: string;
+    hooks: string;
     routes: Map<string, string>;
 }
 export interface GenerateApiFilesOptions {
     customRoutesDir?: string;
+    hooksDir?: string;
 }
 export declare function generateApiFiles(schema: Schema, options?: GenerateApiFilesOptions): GeneratedApiFiles;

package/dist/api-generator/index.js

@@ -1,4 +1,7 @@
+import { DEFAULT_HOOKS_DIR } from '../cli/paths.js';
 import { generateAppFile } from './app-generator.js';
+import { discoverHooks } from './hook-scanner.js';
+import { generateHooksFile } from './hooks-generator.js';
 import { generatePoliciesFile } from './policy-generator.js';
 import { generateRouteFiles } from './route-generator.js';
 import { generateValidationSchemas } from './zod-schema-generator.js';
@@ -6,10 +9,13 @@ export function generateApiFiles(schema, options) {
     const appOptions = options?.customRoutesDir
         ? { customRoutesDir: options.customRoutesDir }
         : undefined;
+    const hooksDir = options?.hooksDir ?? DEFAULT_HOOKS_DIR;
+    const { entries: hookEntries, modelsWithHooks } = discoverHooks(hooksDir, schema);
     return {
         app: generateAppFile(schema, appOptions),
         policies: generatePoliciesFile(schema),
         validation: generateValidationSchemas(schema),
-        routes: generateRouteFiles(schema),
+        hooks: generateHooksFile(hookEntries),
+        routes: generateRouteFiles(schema, modelsWithHooks),
     };
 }

package/dist/api-generator/route-generator.d.ts

@@ -2,7 +2,8 @@ import type { Model, Schema } from '../schema-dsl/ast.js';
 export declare class RouteGenerator {
     private readonly model;
     private readonly schema;
-    constructor(model: Model, schema: Schema);
+    private readonly modelsWithHooks;
+    constructor(model: Model, schema: Schema, modelsWithHooks?: ReadonlySet<string>);
     generate(): string;
     private jsonRow;
     private jsonRows;
@@ -15,7 +16,7 @@ export declare class RouteGenerator {
     getRouteFileName(): string;
     getRouteBasePath(): string;
 }
-export declare function generateRouteFiles(schema: Schema): Map<string, string>;
+export declare function generateRouteFiles(schema: Schema, modelsWithHooks?: ReadonlySet<string>): Map<string, string>;
 export declare function getRouteMountEntries(schema: Schema): {
     basePath: string;
     fileName: string;

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>;