schematic-pg 0.1.6 → 0.1.8

package/dist/api/utils/response-shape.d.ts

@@ -0,0 +1,2 @@
+export declare function shapeResponse<T extends Record<string, unknown>>(row: T, modelName: string, omitByModel: Readonly<Record<string, readonly string[]>>, relationTargets: Readonly<Record<string, Readonly<Record<string, string>>>>): T;
+export declare function shapeResponseMany<T extends Record<string, unknown>>(rows: T[], modelName: string, omitByModel: Readonly<Record<string, readonly string[]>>, relationTargets: Readonly<Record<string, Readonly<Record<string, string>>>>): T[];

package/dist/api/utils/response-shape.js

@@ -0,0 +1,28 @@
+export function shapeResponse(row, modelName, omitByModel, relationTargets) {
+    const omitted = omitByModel[modelName] ?? [];
+    const relations = relationTargets[modelName] ?? {};
+    const result = { ...row };
+    for (const field of omitted) {
+        delete result[field];
+    }
+    for (const [relationName, targetModel] of Object.entries(relations)) {
+        if (!(relationName in result)) {
+            continue;
+        }
+        const value = result[relationName];
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            result[relationName] = value.map((entry) => shapeResponse(entry, targetModel, omitByModel, relationTargets));
+            continue;
+        }
+        if (typeof value === 'object') {
+            result[relationName] = shapeResponse(value, targetModel, omitByModel, relationTargets);
+        }
+    }
+    return result;
+}
+export function shapeResponseMany(rows, modelName, omitByModel, relationTargets) {
+    return rows.map((row) => shapeResponse(row, modelName, omitByModel, relationTargets));
+}

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,10 +2,12 @@ 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;
+    private mutationJsonRow;
     private generateListRoute;
     private generateGetRoute;
     private generateCreateRoute;
@@ -14,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);
@@ -21,7 +23,9 @@ export class RouteGenerator {
         const whereFromParams = primaryKey.fields.map((field) => `${field}: params.${field}`).join(', ');
         const paramSchemaName = `${this.model.name}ParamSchema`;
         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.',
@@ -29,65 +33,89 @@ export class RouteGenerator {
             `import type { AppEnv } from '${PACKAGE_NAME}/api/types';`,
             `import { validateJson, validateParam, validateQuery } from '${PACKAGE_NAME}/api/middleware/validate';`,
             `import { notFoundResponse } from '${PACKAGE_NAME}/api/middleware/errors';`,
-            `import { buildListQuery } from '${PACKAGE_NAME}/api/utils/list-query';`,
-            `import { omitFields, omitFieldsMany } from '${PACKAGE_NAME}/api/utils/omit-fields';`,
+            `import { buildReadQuery } from '${PACKAGE_NAME}/api/utils/read-query';`,
+            `import { parseIncludeQuery } from '${PACKAGE_NAME}/api/utils/include-query';`,
+            `import { omitFields } from '${PACKAGE_NAME}/api/utils/omit-fields';`,
+            `import { shapeResponse, shapeResponseMany } from '${PACKAGE_NAME}/api/utils/response-shape';`,
             ...(modelHasPolicies
                 ? [
                     `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,`,
             `  ${paramSchemaName},`,
             `  ${listQuerySchemaName},`,
+            `  ${getQuerySchemaName},`,
             `  ${constantPrefix}_LIST_QUERY_FIELDS,`,
+            `  ${constantPrefix}_INCLUDABLE_RELATIONS,`,
             `  ${constantPrefix}_OMIT_FIELDS,`,
             `  ${constantPrefix}_SORTABLE_FIELDS,`,
+            `  API_OMIT_FIELDS_BY_MODEL,`,
+            `  API_RELATION_TARGETS,`,
             `} from '../schemas/validation.js';`,
             '',
             'const router = new Hono<AppEnv>();',
             '',
             ...this.generateListRoute(clientKey, modelHasPolicies, listQuerySchemaName, constantPrefix),
             '',
-            ...this.generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
+            ...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;',
             '',
         ].join('\n');
     }
-    jsonRow(variableName, constantPrefix, statusCode) {
-        const payload = `omitFields(${variableName}, ${constantPrefix}_OMIT_FIELDS)`;
+    jsonRow(variableName, modelName, constantPrefix, statusCode) {
+        const payload = `shapeResponse(${variableName}, '${modelName}', API_OMIT_FIELDS_BY_MODEL, API_RELATION_TARGETS)`;
         if (statusCode === undefined) {
             return `c.json(${payload})`;
         }
         return `c.json(${payload}, ${statusCode})`;
     }
-    jsonRows(variableName, constantPrefix) {
-        return `c.json(omitFieldsMany(${variableName}, ${constantPrefix}_OMIT_FIELDS))`;
+    jsonRows(variableName, modelName) {
+        return `c.json(shapeResponseMany(${variableName}, '${modelName}', API_OMIT_FIELDS_BY_MODEL, API_RELATION_TARGETS))`;
+    }
+    mutationJsonRow(variableName, constantPrefix, statusCode) {
+        const payload = `omitFields(${variableName}, ${constantPrefix}_OMIT_FIELDS)`;
+        if (statusCode === undefined) {
+            return `c.json(${payload})`;
+        }
+        return `c.json(${payload}, ${statusCode})`;
     }
     generateListRoute(clientKey, modelHasPolicies, listQuerySchemaName, constantPrefix) {
         const listQueryBlock = [
             `  const query = c.req.valid('query');`,
-            `  const { where, orderBy, take, skip } = buildListQuery(`,
+            `  const { where, orderBy, take, skip, include } = buildReadQuery(`,
             `    query,`,
             `    ${constantPrefix}_LIST_QUERY_FIELDS,`,
             `    ${constantPrefix}_SORTABLE_FIELDS,`,
+            `    ${constantPrefix}_INCLUDABLE_RELATIONS,`,
             `  );`,
         ];
+        const findManyArgs = ['where', 'orderBy', 'take', 'skip', 'include']
+            .map((key) => `    ${key},`)
+            .join('\n');
         if (!modelHasPolicies) {
             return [
                 `router.get('/', validateQuery(${listQuerySchemaName}), async (c) => {`,
                 '  const db = c.get(\'db\');',
                 ...listQueryBlock,
-                `  const rows = await db.${clientKey}.findMany({ where, orderBy, take, skip });`,
-                `  return ${this.jsonRows('rows', constantPrefix)};`,
+                `  const rows = await db.${clientKey}.findMany({`,
+                findManyArgs,
+                '  });',
+                `  return ${this.jsonRows('rows', this.model.name)};`,
                 '});',
             ];
         }
@@ -103,109 +131,131 @@ export class RouteGenerator {
             '    orderBy,',
             '    take,',
             '    skip,',
+            '    include,',
             '  });',
-            `  return ${this.jsonRows('rows', constantPrefix)};`,
+            `  return ${this.jsonRows('rows', this.model.name)};`,
             '});',
         ];
     }
-    generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
+    generateGetRoute(clientKey, pathParams, paramSchemaName, getQuerySchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
+        const includeBlock = [
+            '  const query = c.req.valid(\'query\');',
+            `  const include = query.include`,
+            `    ? parseIncludeQuery(query.include, ${constantPrefix}_INCLUDABLE_RELATIONS)`,
+            '    : undefined;',
+        ];
         if (!modelHasPolicies) {
             return [
-                `router.get('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
+                `router.get('/${pathParams}', validateParam(${paramSchemaName}), validateQuery(${getQuerySchemaName}), async (c) => {`,
                 '  const db = c.get(\'db\');',
                 '  const params = c.req.valid(\'param\');',
-                `  const row = await db.${clientKey}.findUnique({ ${whereFromParams} });`,
+                ...includeBlock,
+                `  const row = await db.${clientKey}.findUnique({ ${whereFromParams} }, { include });`,
                 '  if (!row) {',
                 '    return notFoundResponse(c);',
                 '  }',
-                `  return ${this.jsonRow('row', constantPrefix)};`,
+                `  return ${this.jsonRow('row', this.model.name, constantPrefix)};`,
                 '});',
             ];
         }
         return [
-            `router.get('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
+            `router.get('/${pathParams}', validateParam(${paramSchemaName}), validateQuery(${getQuerySchemaName}), async (c) => {`,
             '  const db = c.get(\'db\');',
             '  const auth = c.get(\'auth\');',
             `  const policy = assertPolicy('${this.model.name}', auth.role, 'select');`,
             '  const policyWhere = resolvePolicyWhere(policy, auth);',
             '  const params = c.req.valid(\'param\');',
-            `  const row = await db.${clientKey}.findUnique(mergeWhere({ ${whereFromParams} }, policyWhere));`,
+            ...includeBlock,
+            `  const row = await db.${clientKey}.findUnique(mergeWhere({ ${whereFromParams} }, policyWhere), { include });`,
             '  if (!row) {',
             '    return notFoundResponse(c);',
             '  }',
-            `  return ${this.jsonRow('row', constantPrefix)};`,
+            `  return ${this.jsonRow('row', this.model.name, constantPrefix)};`,
             '});',
         ];
     }
-    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.jsonRow('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.jsonRow('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.jsonRow('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.jsonRow('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.jsonRow('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.jsonRow('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);
@@ -214,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/api-generator/utils/api-fields.d.ts

@@ -1,8 +1,14 @@
 import type { Field, Model, Schema } from '../../schema-dsl/ast.js';
+import type { IncludableRelationTree } from '../../api/utils/include-query.js';
 export declare function isStoredScalarField(field: Field, schema: Schema): boolean;
+export declare function isRelationField(field: Field, schema: Schema): boolean;
 export declare function isUnfilterable(field: Field): boolean;
+export declare function isUnincludeable(field: Field): boolean;
 export declare function isOmitted(field: Field): boolean;
 export declare function getFilterableFields(model: Model, schema: Schema): Field[];
 export declare function getOmittedFields(model: Model, schema: Schema): Field[];
+export declare function getIncludableRelationFields(model: Model, schema: Schema): Field[];
+export declare function buildIncludableRelationTree(model: Model, schema: Schema, visited?: Set<string>): IncludableRelationTree;
+export declare function buildRelationTargets(model: Model, schema: Schema): Record<string, string>;
 export declare function getSortableFieldNames(model: Model, schema: Schema): string[];
 export declare function toModelConstantPrefix(modelName: string): string;

package/dist/api-generator/utils/api-fields.js

@@ -3,9 +3,15 @@ export function isStoredScalarField(field, schema) {
     const modelNames = getModelNames(schema);
     return !modelNames.has(field.type.name);
 }
+export function isRelationField(field, schema) {
+    return getModelNames(schema).has(field.type.name);
+}
 export function isUnfilterable(field) {
     return fieldHasAttribute(field, 'unfilterable') || fieldHasAttribute(field, 'omit');
 }
+export function isUnincludeable(field) {
+    return fieldHasAttribute(field, 'unincludeable');
+}
 export function isOmitted(field) {
     return fieldHasAttribute(field, 'omit');
 }
@@ -15,6 +21,32 @@ export function getFilterableFields(model, schema) {
 export function getOmittedFields(model, schema) {
     return getStoredFields(model, getModelNames(schema)).filter((field) => isStoredScalarField(field, schema) && isOmitted(field));
 }
+export function getIncludableRelationFields(model, schema) {
+    return model.fields.filter((field) => isRelationField(field, schema) && !isUnincludeable(field));
+}
+export function buildIncludableRelationTree(model, schema, visited = new Set()) {
+    if (visited.has(model.name)) {
+        return {};
+    }
+    const nextVisited = new Set(visited);
+    nextVisited.add(model.name);
+    const tree = {};
+    for (const field of getIncludableRelationFields(model, schema)) {
+        const targetModel = schema.models.find((candidate) => candidate.name === field.type.name);
+        if (!targetModel) {
+            continue;
+        }
+        tree[field.name] = buildIncludableRelationTree(targetModel, schema, nextVisited);
+    }
+    return tree;
+}
+export function buildRelationTargets(model, schema) {
+    const targets = {};
+    for (const field of getIncludableRelationFields(model, schema)) {
+        targets[field.name] = field.type.name;
+    }
+    return targets;
+}
 export function getSortableFieldNames(model, schema) {
     return getStoredFields(model, getModelNames(schema))
         .filter((field) => isStoredScalarField(field, schema))

package/dist/api-generator/zod-schema-generator.d.ts

@@ -3,8 +3,11 @@ export declare class ZodSchemaGenerator {
     private readonly schema;
     constructor(schema: Schema);
     generate(): string;
+    private generateGlobalMetadata;
     private generateModelSchemas;
     private generateListQuerySchemas;
+    private generateIncludeRefinement;
+    private generateReadQueryRefinement;
     private generateListQueryFieldLines;
     private generateObjectField;
     private generateParamField;