@currentjs/gen 0.3.1 → 0.5.0

package/dist/generators/dtoGenerator.js

@@ -0,0 +1,518 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const configTypes_1 = require("../types/configTypes");
+const childEntityUtils_1 = require("../utils/childEntityUtils");
+const typeUtils_1 = require("../utils/typeUtils");
+class DtoGenerator {
+    constructor() {
+        this.availableAggregates = new Map();
+        this.availableValueObjects = new Map();
+    }
+    mapType(yamlType) {
+        return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates, this.availableValueObjects);
+    }
+    isValueObjectType(yamlType) {
+        const capitalizedType = (0, typeUtils_1.capitalize)(yamlType);
+        return this.availableValueObjects.has(capitalizedType);
+    }
+    getValidationCode(fieldName, fieldType, isRequired) {
+        const checks = [];
+        if (isRequired) {
+            if (fieldType === 'string') {
+                checks.push(`    if (typeof b.${fieldName} !== 'string' || !b.${fieldName}) {
+      throw new Error('${fieldName} is required');
+    }`);
+            }
+            else if (fieldType === 'number' || fieldType === 'integer' || fieldType === 'decimal' || fieldType === 'id') {
+                checks.push(`    if (b.${fieldName} === undefined || b.${fieldName} === null) {
+      throw new Error('${fieldName} is required');
+    }`);
+            }
+            else if (fieldType === 'boolean') {
+                checks.push(`    if (typeof b.${fieldName} !== 'boolean') {
+      throw new Error('${fieldName} is required');
+    }`);
+            }
+            else if (fieldType === 'datetime' || fieldType === 'date') {
+                checks.push(`    if (!b.${fieldName}) {
+      throw new Error('${fieldName} is required');
+    }`);
+            }
+            else {
+                checks.push(`    if (b.${fieldName} === undefined) {
+      throw new Error('${fieldName} is required');
+    }`);
+            }
+        }
+        return checks;
+    }
+    getTransformCode(fieldName, fieldType) {
+        if (fieldType === 'datetime' || fieldType === 'date') {
+            return `b.${fieldName} ? new Date(b.${fieldName} as string) : undefined`;
+        }
+        else if (fieldType === 'number' || fieldType === 'integer' || fieldType === 'decimal' || fieldType === 'id') {
+            return `typeof b.${fieldName} === 'string' ? parseFloat(b.${fieldName}) : b.${fieldName} as number`;
+        }
+        else if (fieldType === 'boolean') {
+            return `Boolean(b.${fieldName})`;
+        }
+        return `b.${fieldName} as ${this.mapType(fieldType)}`;
+    }
+    generateInputDto(modelName, actionName, inputConfig, aggregateConfig, childInfo) {
+        var _a, _b, _c, _d;
+        const className = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+        if (!inputConfig) {
+            return `export class ${className} {
+  private constructor() {}
+
+  static parse(body: unknown): ${className} {
+    return new ${className}();
+  }
+}`;
+        }
+        const fieldDeclarations = [];
+        const constructorParams = [];
+        const constructorAssignments = [];
+        const validationChecks = [];
+        const fieldTransforms = [];
+        // Handle identifier (for get, update, delete)
+        if (inputConfig.identifier) {
+            const fieldName = inputConfig.identifier;
+            fieldDeclarations.push(`  readonly ${fieldName}: number;`);
+            constructorParams.push(`${fieldName}: number`);
+            constructorAssignments.push(`    this.${fieldName} = ${fieldName};`);
+            validationChecks.push(`    if (b.${fieldName} === undefined || b.${fieldName} === null) {
+      throw new Error('${fieldName} is required');
+    }`);
+            fieldTransforms.push(`      ${fieldName}: typeof b.${fieldName} === 'string' ? parseInt(b.${fieldName}, 10) : b.${fieldName} as number`);
+        }
+        // Handle pagination
+        if (inputConfig.pagination) {
+            fieldDeclarations.push(`  readonly page: number;`);
+            fieldDeclarations.push(`  readonly limit: number;`);
+            constructorParams.push(`page: number`);
+            constructorParams.push(`limit: number`);
+            constructorAssignments.push(`    this.page = page;`);
+            constructorAssignments.push(`    this.limit = limit;`);
+            const defaultLimit = ((_a = inputConfig.pagination.defaults) === null || _a === void 0 ? void 0 : _a.limit) || 20;
+            const maxLimit = ((_b = inputConfig.pagination.defaults) === null || _b === void 0 ? void 0 : _b.maxLimit) || 100;
+            fieldTransforms.push(`      page: typeof b.page === 'string' ? parseInt(b.page, 10) : (b.page as number || 1)`);
+            fieldTransforms.push(`      limit: Math.min(typeof b.limit === 'string' ? parseInt(b.limit, 10) : (b.limit as number || ${defaultLimit}), ${maxLimit})`);
+            if (inputConfig.pagination.type === 'cursor') {
+                fieldDeclarations.push(`  readonly cursor?: string;`);
+                constructorParams.push(`cursor?: string`);
+                constructorAssignments.push(`    this.cursor = cursor;`);
+                fieldTransforms.push(`      cursor: b.cursor as string | undefined`);
+            }
+        }
+        // Handle fields from aggregate (pick/omit/add)
+        if (inputConfig.from) {
+            const aggregateFields = Object.entries(aggregateConfig.fields);
+            let fieldsToInclude = aggregateFields;
+            // Apply pick
+            if (inputConfig.pick && inputConfig.pick.length > 0) {
+                fieldsToInclude = fieldsToInclude.filter(([fieldName]) => inputConfig.pick.includes(fieldName));
+            }
+            // Apply omit
+            if (inputConfig.omit && inputConfig.omit.length > 0) {
+                fieldsToInclude = fieldsToInclude.filter(([fieldName]) => !inputConfig.omit.includes(fieldName));
+            }
+            const isCreateAction = !inputConfig.identifier && !inputConfig.partial;
+            if (isCreateAction) {
+                const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
+                fieldDeclarations.push(`  readonly ${ownerOrParentField}: number;`);
+                constructorParams.push(`${ownerOrParentField}: number`);
+                constructorAssignments.push(`    this.${ownerOrParentField} = ${ownerOrParentField};`);
+                validationChecks.push(`    if (b.${ownerOrParentField} === undefined || b.${ownerOrParentField} === null) {
+      throw new Error('${ownerOrParentField} is required');
+    }`);
+                fieldTransforms.push(`      ${ownerOrParentField}: typeof b.${ownerOrParentField} === 'string' ? parseInt(b.${ownerOrParentField}, 10) : b.${ownerOrParentField} as number`);
+            }
+            // Add fields
+            fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
+                if (fieldName === 'id' || fieldConfig.auto)
+                    return;
+                const tsType = this.mapType(fieldConfig.type);
+                // Fields are required by default unless partial or required: false
+                const isRequired = !inputConfig.partial && fieldConfig.required !== false;
+                const optional = isRequired ? '' : '?';
+                fieldDeclarations.push(`  readonly ${fieldName}${optional}: ${tsType};`);
+                constructorParams.push(`${fieldName}${optional}: ${tsType}`);
+                constructorAssignments.push(`    this.${fieldName} = ${fieldName};`);
+                validationChecks.push(...this.getValidationCode(fieldName, fieldConfig.type, isRequired));
+                fieldTransforms.push(`      ${fieldName}: ${this.getTransformCode(fieldName, fieldConfig.type)}`);
+            });
+        }
+        // Handle filters
+        if (inputConfig.filters) {
+            Object.entries(inputConfig.filters).forEach(([filterName, filterConfig]) => {
+                const tsType = this.mapType(filterConfig.type);
+                const isRequired = !filterConfig.optional;
+                const optional = isRequired ? '' : '?';
+                fieldDeclarations.push(`  readonly ${filterName}${optional}: ${tsType};`);
+                constructorParams.push(`${filterName}${optional}: ${tsType}`);
+                constructorAssignments.push(`    this.${filterName} = ${filterName};`);
+                if (isRequired) {
+                    validationChecks.push(...this.getValidationCode(filterName, filterConfig.type, true));
+                }
+                fieldTransforms.push(`      ${filterName}: ${this.getTransformCode(filterName, filterConfig.type)}`);
+            });
+        }
+        // Handle sorting
+        if (inputConfig.sorting) {
+            fieldDeclarations.push(`  readonly sortBy?: string;`);
+            fieldDeclarations.push(`  readonly sortOrder?: 'asc' | 'desc';`);
+            constructorParams.push(`sortBy?: string`);
+            constructorParams.push(`sortOrder?: 'asc' | 'desc'`);
+            constructorAssignments.push(`    this.sortBy = sortBy;`);
+            constructorAssignments.push(`    this.sortOrder = sortOrder;`);
+            const allowedFields = inputConfig.sorting.allow.map(f => `'${f}'`).join(', ');
+            const defaultField = ((_c = inputConfig.sorting.default) === null || _c === void 0 ? void 0 : _c.field) || inputConfig.sorting.allow[0];
+            const defaultOrder = ((_d = inputConfig.sorting.default) === null || _d === void 0 ? void 0 : _d.order) || 'asc';
+            fieldTransforms.push(`      sortBy: [${allowedFields}].includes(b.sortBy as string) ? b.sortBy as string : '${defaultField}'`);
+            fieldTransforms.push(`      sortOrder: b.sortOrder === 'desc' ? 'desc' : '${defaultOrder}'`);
+        }
+        const fieldsStr = fieldDeclarations.length > 0 ? fieldDeclarations.join('\n') : '  // No fields';
+        const paramsStr = constructorParams.join(', ');
+        const assignmentsStr = constructorAssignments.join('\n');
+        const validationsStr = validationChecks.length > 0 ? '\n' + validationChecks.join('\n') + '\n' : '';
+        const transformsStr = fieldTransforms.join(',\n');
+        return `export class ${className} {
+${fieldsStr}
+
+  private constructor(data: { ${constructorParams.map(p => p.replace('readonly ', '')).join('; ')} }) {
+${constructorAssignments.map(a => a.replace('this.', 'this.').replace(' = ', ' = data.')).join('\n').replace(/= data\./g, '= data.').split('\n').map(line => {
+            const match = line.match(/this\.(\w+) = data\.(\w+)/);
+            if (match) {
+                return `    this.${match[1]} = data.${match[1]};`;
+            }
+            return line;
+        }).join('\n')}
+  }
+
+  static parse(body: unknown): ${className} {
+    if (!body || typeof body !== 'object') {
+      throw new Error('Invalid request body');
+    }
+    const b = body as Record<string, unknown>;
+${validationsStr}
+    return new ${className}({
+${transformsStr}
+    });
+  }
+}`;
+    }
+    generateOutputDto(modelName, actionName, outputConfig, aggregateConfig, allAggregates) {
+        const className = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Output`;
+        if (outputConfig === 'void') {
+            return `export type ${className} = void;`;
+        }
+        const fieldDeclarations = [];
+        const constructorParams = [];
+        const fromMappings = [];
+        // Always include id for entity outputs
+        if (outputConfig.from) {
+            fieldDeclarations.push(`  readonly id: number;`);
+            constructorParams.push(`id: number`);
+            fromMappings.push(`      id: entity.id`);
+        }
+        // Handle fields from aggregate (pick)
+        if (outputConfig.from) {
+            const aggregateFields = Object.entries(aggregateConfig.fields);
+            let fieldsToInclude = aggregateFields;
+            // Apply pick
+            if (outputConfig.pick && outputConfig.pick.length > 0) {
+                fieldsToInclude = fieldsToInclude.filter(([fieldName]) => outputConfig.pick.includes(fieldName));
+            }
+            // Add fields
+            fieldsToInclude.forEach(([fieldName, fieldConfig]) => {
+                if (fieldName === 'id')
+                    return;
+                const tsType = this.mapType(fieldConfig.type);
+                const isOptional = fieldConfig.required === false;
+                const optional = isOptional ? '?' : '';
+                fieldDeclarations.push(`  readonly ${fieldName}${optional}: ${tsType};`);
+                constructorParams.push(`${fieldName}${optional}: ${tsType}`);
+                fromMappings.push(`      ${fieldName}: entity.${fieldName}`);
+            });
+        }
+        // Handle includes (nested objects)
+        if (outputConfig.include) {
+            Object.entries(outputConfig.include).forEach(([includeName, includeConfig]) => {
+                const relatedAggregate = allAggregates.get(includeConfig.from);
+                if (relatedAggregate && includeConfig.pick && includeConfig.pick.length > 0) {
+                    // Filter out 'id' from picked fields since we add it separately
+                    const pickedFieldsFiltered = includeConfig.pick.filter(f => f !== 'id');
+                    const pickedFields = pickedFieldsFiltered.map(fieldName => {
+                        const fieldConfig = relatedAggregate.fields[fieldName];
+                        if (fieldConfig) {
+                            const tsType = this.mapType(fieldConfig.type);
+                            return `${fieldName}: ${tsType}`;
+                        }
+                        return `${fieldName}: any`;
+                    }).join('; ');
+                    const fieldsStr = pickedFields ? `id: number; ${pickedFields}` : 'id: number';
+                    fieldDeclarations.push(`  readonly ${includeName}?: { ${fieldsStr} };`);
+                    constructorParams.push(`${includeName}?: { ${fieldsStr} }`);
+                    fromMappings.push(`      ${includeName}: (entity as any).${includeName}`);
+                }
+                else {
+                    fieldDeclarations.push(`  readonly ${includeName}?: ${includeConfig.from};`);
+                    constructorParams.push(`${includeName}?: ${includeConfig.from}`);
+                    fromMappings.push(`      ${includeName}: (entity as any).${includeName}`);
+                }
+            });
+        }
+        // Handle additional fields
+        if (outputConfig.add) {
+            Object.entries(outputConfig.add).forEach(([fieldName, fieldDef]) => {
+                const tsType = this.mapType(fieldDef.type);
+                fieldDeclarations.push(`  readonly ${fieldName}: ${tsType};`);
+                constructorParams.push(`${fieldName}: ${tsType}`);
+                fromMappings.push(`      ${fieldName}: (entity as any).${fieldName}`);
+            });
+        }
+        const fieldsStr = fieldDeclarations.length > 0 ? fieldDeclarations.join('\n') : '  // No fields';
+        const paramsStr = constructorParams.map(p => p.replace('readonly ', '')).join('; ');
+        const mappingsStr = fromMappings.join(',\n');
+        // Wrap in pagination if needed
+        if (outputConfig.pagination) {
+            return `export class ${className}Item {
+${fieldsStr}
+
+  private constructor(data: { ${paramsStr} }) {
+${fieldDeclarations.map(d => {
+                const match = d.match(/readonly (\w+)/);
+                if (match)
+                    return `    this.${match[1]} = data.${match[1]};`;
+                return '';
+            }).filter(Boolean).join('\n')}
+  }
+
+  static from(entity: ${modelName}): ${className}Item {
+    return new ${className}Item({
+${mappingsStr}
+    });
+  }
+}
+
+export class ${className} {
+  readonly items: ${className}Item[];
+  readonly total: number;
+  readonly page?: number;
+  readonly limit?: number;
+
+  private constructor(data: { items: ${className}Item[]; total: number; page?: number; limit?: number }) {
+    this.items = data.items;
+    this.total = data.total;
+    this.page = data.page;
+    this.limit = data.limit;
+  }
+
+  static from(data: { items: ${modelName}[]; total: number; page?: number; limit?: number }): ${className} {
+    return new ${className}({
+      items: data.items.map(item => ${className}Item.from(item)),
+      total: data.total,
+      page: data.page,
+      limit: data.limit
+    });
+  }
+}`;
+        }
+        // List action without pagination: still wrap items in a list container
+        if (actionName === 'list') {
+            return `export class ${className}Item {
+${fieldsStr}
+
+  private constructor(data: { ${paramsStr} }) {
+${fieldDeclarations.map(d => {
+                const match = d.match(/readonly (\w+)/);
+                if (match)
+                    return `    this.${match[1]} = data.${match[1]};`;
+                return '';
+            }).filter(Boolean).join('\n')}
+  }
+
+  static from(entity: ${modelName}): ${className}Item {
+    return new ${className}Item({
+${mappingsStr}
+    });
+  }
+}
+
+export class ${className} {
+  readonly items: ${className}Item[];
+
+  private constructor(data: { items: ${className}Item[] }) {
+    this.items = data.items;
+  }
+
+  static from(data: { items: ${modelName}[] }): ${className} {
+    return new ${className}({
+      items: data.items.map(item => ${className}Item.from(item))
+    });
+  }
+}`;
+        }
+        return `export class ${className} {
+${fieldsStr}
+
+  private constructor(data: { ${paramsStr} }) {
+${fieldDeclarations.map(d => {
+            const match = d.match(/readonly (\w+)/);
+            if (match)
+                return `    this.${match[1]} = data.${match[1]};`;
+            return '';
+        }).filter(Boolean).join('\n')}
+  }
+
+  static from(entity: ${modelName}): ${className} {
+    return new ${className}({
+${mappingsStr}
+    });
+  }
+}`;
+    }
+    /**
+     * Collect types that need to be imported for a use case DTO.
+     */
+    collectRequiredImports(modelName, aggregateConfig, outputConfig) {
+        const valueObjects = new Set();
+        const entities = new Set();
+        // Check aggregate fields for value object types
+        if (outputConfig !== 'void' && outputConfig.from) {
+            const aggregateFields = Object.entries(aggregateConfig.fields);
+            let fieldsToCheck = aggregateFields;
+            // Apply pick filter if specified
+            if (outputConfig.pick && outputConfig.pick.length > 0) {
+                fieldsToCheck = fieldsToCheck.filter(([fieldName]) => outputConfig.pick.includes(fieldName));
+            }
+            // Check each field for value object types
+            fieldsToCheck.forEach(([, fieldConfig]) => {
+                if (this.isValueObjectType(fieldConfig.type)) {
+                    valueObjects.add((0, typeUtils_1.capitalize)(fieldConfig.type));
+                }
+            });
+        }
+        // Check include for child entities
+        if (outputConfig !== 'void' && outputConfig.include) {
+            Object.entries(outputConfig.include).forEach(([, includeConfig]) => {
+                if (includeConfig.from && includeConfig.from !== modelName) {
+                    entities.add(includeConfig.from);
+                }
+            });
+        }
+        return { valueObjects, entities };
+    }
+    generateFromConfig(config) {
+        const result = {};
+        // Collect all aggregates
+        if (config.domain.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                this.availableAggregates.set(name, aggConfig);
+            });
+        }
+        // Collect all value objects
+        if (config.domain.valueObjects) {
+            Object.entries(config.domain.valueObjects).forEach(([name, voConfig]) => {
+                this.availableValueObjects.set(name, voConfig);
+            });
+        }
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        // Generate DTOs for each use case
+        Object.entries(config.useCases).forEach(([modelName, useCases]) => {
+            const aggregateConfig = this.availableAggregates.get(modelName);
+            if (!aggregateConfig) {
+                console.warn(`Warning: No aggregate found for model ${modelName}`);
+                return;
+            }
+            const childInfo = childEntityMap.get(modelName);
+            Object.entries(useCases).forEach(([actionName, useCaseConfig]) => {
+                // Generate Input DTO
+                const inputDto = this.generateInputDto(modelName, actionName, useCaseConfig.input, aggregateConfig, childInfo);
+                // Generate Output DTO
+                const outputDto = this.generateOutputDto(modelName, actionName, useCaseConfig.output || 'void', aggregateConfig, this.availableAggregates);
+                // Collect required imports
+                const imports = [];
+                const needsModelImport = useCaseConfig.output !== 'void';
+                if (needsModelImport) {
+                    imports.push(`import { ${modelName} } from '../../domain/entities/${modelName}';`);
+                }
+                // Collect value objects and entities needed
+                const { valueObjects, entities } = this.collectRequiredImports(modelName, aggregateConfig, useCaseConfig.output || 'void');
+                // Add value object imports
+                valueObjects.forEach(voName => {
+                    imports.push(`import { ${voName} } from '../../domain/valueObjects/${voName}';`);
+                });
+                // Add entity imports for includes
+                entities.forEach(entityName => {
+                    imports.push(`import { ${entityName} } from '../../domain/entities/${entityName}';`);
+                });
+                const importStatement = imports.length > 0 ? imports.join('\n') + '\n\n' : '';
+                const dtoFileName = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}`;
+                result[dtoFileName] = `${importStatement}${inputDto}\n\n${outputDto}`;
+            });
+        });
+        return result;
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        if (!(0, configTypes_1.isValidModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected useCases structure.');
+        }
+        return this.generateFromConfig(config);
+    }
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const dtosByName = this.generateFromYamlFile(yamlFilePath);
+        const dtoDir = path.join(moduleDir, 'application', 'dto');
+        fs.mkdirSync(dtoDir, { recursive: true });
+        for (const [name, code] of Object.entries(dtosByName)) {
+            const filePath = path.join(dtoDir, `${name}.ts`);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, code, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+        }
+        // eslint-disable-next-line no-console
+        console.log('\n' + colors_1.colors.green('DTO files generated successfully!') + '\n');
+    }
+}
+exports.DtoGenerator = DtoGenerator;

package/dist/generators/newControllerGenerator.d.ts

@@ -0,0 +1,55 @@
+import { NewModuleConfig } from '../types/configTypes';
+export declare class NewControllerGenerator {
+    private capitalize;
+    private getHttpDecorator;
+    private parseUseCase;
+    /**
+     * Normalize auth config to an array of roles
+     */
+    private normalizeAuth;
+    /**
+     * Check if auth config includes owner permission
+     */
+    private hasOwnerAuth;
+    /**
+     * Generate pre-fetch authentication/authorization check code.
+     * This runs before fetching the entity and validates authentication and role-based access.
+     * @param auth - The auth requirement: 'all', 'authenticated', 'owner', role names, or array of roles
+     * @returns Code string for the auth check, or empty string if no check needed
+     */
+    private generateAuthCheck;
+    /**
+     * Generate post-fetch authorization check for owner validation.
+     * This runs after fetching the entity and validates ownership.
+     * Used for READ operations (get, list) where we check after fetch.
+     * For child entities, uses getResourceOwner() since result has no ownerId.
+     */
+    private generatePostFetchOwnerCheck;
+    /**
+     * Generate pre-mutation authorization check for owner validation.
+     * This runs BEFORE the mutation to prevent unauthorized changes.
+     * Used for WRITE operations (update, delete).
+     * @param auth - The auth requirement
+     * @param useCaseVar - The use case variable name
+     * @returns Code string for the pre-mutation owner check, or empty string if not needed
+     */
+    private generatePreMutationOwnerCheck;
+    private generateApiEndpointMethod;
+    private generateWebPageMethod;
+    private generateOnSuccessHandler;
+    private generateOnErrorHandler;
+    /**
+     * Sort routes so static paths are registered before parameterized ones.
+     * This prevents parameterized routes (e.g. /:id) from catching requests
+     * meant for static routes (e.g. /create).
+     */
+    private sortRoutesBySpecificity;
+    private generateApiController;
+    private generateWebController;
+    generateFromConfig(config: NewModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<string[]>;
+}