@currentjs/gen 0.3.2 → 0.5.0

package/dist/generators/useCaseGenerator.d.ts

@@ -0,0 +1,13 @@
+import { ModuleConfig } from '../types/configTypes';
+export declare class UseCaseGenerator {
+    private availableAggregates;
+    private generateUseCaseMethod;
+    private generateGetResourceOwnerMethod;
+    private generateUseCase;
+    generateFromConfig(config: ModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}

package/dist/generators/useCaseGenerator.js

@@ -0,0 +1,188 @@
+"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.UseCaseGenerator = 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 typeUtils_1 = require("../utils/typeUtils");
+class UseCaseGenerator {
+    constructor() {
+        this.availableAggregates = new Map();
+    }
+    generateUseCaseMethod(modelName, actionName, useCaseConfig) {
+        const methodName = actionName;
+        const inputType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+        // Determine the return type based on action
+        let returnType;
+        if (useCaseConfig.output === 'void') {
+            returnType = '{ success: boolean; message: string }';
+        }
+        else if (actionName === 'list') {
+            returnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+        }
+        else {
+            returnType = modelName;
+        }
+        // Generate handler calls
+        const handlerCalls = useCaseConfig.handlers.map((handler, index) => {
+            var _a;
+            const isLast = index === useCaseConfig.handlers.length - 1;
+            if (handler.startsWith('default:')) {
+                // Default handler - call service method directly
+                const defaultAction = handler.replace('default:', '');
+                const resultVar = isLast ? 'result' : `result${index}`;
+                // Determine parameters based on action
+                let params = '';
+                if (defaultAction === 'list') {
+                    params = ((_a = useCaseConfig.input) === null || _a === void 0 ? void 0 : _a.pagination)
+                        ? 'input.page || 1, input.limit || 20'
+                        : '';
+                }
+                else if (defaultAction === 'get') {
+                    params = 'input.id';
+                }
+                else if (defaultAction === 'create') {
+                    params = 'input';
+                }
+                else if (defaultAction === 'update') {
+                    params = 'input.id, input';
+                }
+                else if (defaultAction === 'delete') {
+                    params = 'input.id';
+                }
+                else {
+                    params = 'input';
+                }
+                return `    const ${resultVar} = await this.${modelName.toLowerCase()}Service.${defaultAction}(${params});`;
+            }
+            else {
+                // Custom handler
+                const prevResult = index === 0 ? 'null' : `result${index - 1}`;
+                const resultVar = isLast ? 'result' : `result${index}`;
+                return `    const ${resultVar} = await this.${modelName.toLowerCase()}Service.${handler}(${prevResult}, input);`;
+            }
+        }).join('\n');
+        const returnStatement = '\n    return result;';
+        return `  async ${methodName}(input: ${inputType}): Promise<${returnType}> {
+${handlerCalls}${returnStatement}
+  }`;
+    }
+    generateGetResourceOwnerMethod(modelName) {
+        const serviceVar = `${modelName.toLowerCase()}Service`;
+        return `
+  /**
+   * Get the owner ID of a resource by its ID.
+   * Used for pre-mutation authorization checks in controllers.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    return await this.${serviceVar}.getResourceOwner(id);
+  }`;
+    }
+    generateUseCase(modelName, useCases) {
+        const className = `${modelName}UseCase`;
+        const serviceName = `${modelName}Service`;
+        const serviceVar = `${modelName.toLowerCase()}Service`;
+        // Generate imports for DTOs (only Input types since UseCases return models)
+        const dtoImports = Object.keys(useCases)
+            .map(actionName => {
+            const inputType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+            return `import { ${inputType} } from '../dto/${modelName}${(0, typeUtils_1.capitalize)(actionName)}';`;
+        })
+            .join('\n');
+        // Generate methods
+        const methods = Object.entries(useCases)
+            .map(([actionName, useCaseConfig]) => this.generateUseCaseMethod(modelName, actionName, useCaseConfig))
+            .join('\n\n');
+        const getResourceOwnerMethod = this.generateGetResourceOwnerMethod(modelName);
+        return `import { Injectable } from '../../../../system';
+import { ${modelName} } from '../../domain/entities/${modelName}';
+${dtoImports}
+import { ${serviceName} } from '../services/${serviceName}';
+
+/**
+ * Use Case orchestrator for ${modelName}
+ * Coordinates business logic by calling service handlers in sequence
+ */
+@Injectable()
+export class ${className} {
+  constructor(
+    private ${serviceVar}: ${serviceName}
+  ) {}
+
+${methods}${getResourceOwnerMethod}
+}`;
+    }
+    generateFromConfig(config) {
+        var _a;
+        const result = {};
+        // Collect all aggregates to know which are roots
+        this.availableAggregates.clear();
+        if ((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                this.availableAggregates.set(name, aggConfig);
+            });
+        }
+        // Generate a UseCase file for each model
+        Object.entries(config.useCases).forEach(([modelName, useCases]) => {
+            result[modelName] = this.generateUseCase(modelName, useCases);
+        });
+        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 useCasesByModel = this.generateFromYamlFile(yamlFilePath);
+        const useCasesDir = path.join(moduleDir, 'application', 'useCases');
+        fs.mkdirSync(useCasesDir, { recursive: true });
+        for (const [modelName, code] of Object.entries(useCasesByModel)) {
+            const filePath = path.join(useCasesDir, `${modelName}UseCase.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('Use Case files generated successfully!') + '\n');
+    }
+}
+exports.UseCaseGenerator = UseCaseGenerator;

package/dist/types/configTypes.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Type definitions for the Clean Architecture module configuration
+ */
+export interface FieldDefinition {
+    type: string;
+    constraints?: {
+        min?: number;
+        max?: number;
+        pattern?: string;
+        unique?: boolean;
+    };
+}
+export interface ValueObjectConfig {
+    fields: Record<string, FieldDefinition | {
+        type: string;
+        values: string[];
+    }>;
+}
+export interface AggregateFieldConfig {
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+    values?: string[];
+}
+export interface AggregateConfig {
+    root?: boolean;
+    fields: Record<string, AggregateFieldConfig>;
+    entities?: string[];
+}
+export interface DomainConfig {
+    aggregates: Record<string, AggregateConfig>;
+    valueObjects?: Record<string, ValueObjectConfig>;
+}
+export interface PaginationConfig {
+    type: 'cursor' | 'offset';
+    defaults?: {
+        limit?: number;
+        maxLimit?: number;
+    };
+}
+export interface FilterFieldConfig {
+    type: string;
+    enum?: string[];
+    optional?: boolean;
+    searchIn?: string[];
+}
+export interface SortingConfig {
+    allow: string[];
+    default?: {
+        field: string;
+        order: 'asc' | 'desc';
+    };
+}
+/** Additional input field definition (type only; used in add) */
+export interface UseCaseInputAddField {
+    type: string;
+    source?: string;
+}
+export interface UseCaseInputConfig {
+    from?: string;
+    pick?: string[];
+    omit?: string[];
+    add?: Record<string, UseCaseInputAddField>;
+    validate?: Record<string, unknown>;
+    identifier?: string;
+    partial?: boolean;
+    pagination?: PaginationConfig;
+    filters?: Record<string, FilterFieldConfig>;
+    sorting?: SortingConfig;
+    parentId?: string;
+}
+export interface UseCaseOutputInclude {
+    from: string;
+    pick?: string[];
+}
+export interface UseCaseOutputConfig {
+    from?: string;
+    pick?: string[];
+    include?: Record<string, UseCaseOutputInclude>;
+    add?: Record<string, {
+        type: string;
+        source?: string;
+    }>;
+    pagination?: boolean;
+}
+export interface UseCaseDefinition {
+    input?: UseCaseInputConfig;
+    output?: UseCaseOutputConfig | 'void';
+    handlers: string[];
+    withChild?: boolean;
+}
+export interface UseCasesConfig {
+    [modelName: string]: {
+        [actionName: string]: UseCaseDefinition;
+    };
+}
+/**
+ * Auth configuration for endpoints.
+ * Can be:
+ * - 'all': Public access (no authentication required)
+ * - 'authenticated': Any logged-in user
+ * - 'owner': User must own the resource (checks owner_id field)
+ * - string (e.g., 'admin', 'editor'): User must have this role
+ * - string[] (e.g., ['owner', 'admin']): User must match ANY of these (OR logic)
+ */
+export type AuthConfig = 'all' | 'authenticated' | 'owner' | string | string[];
+export interface ApiEndpointConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    useCase: string;
+    auth?: AuthConfig;
+}
+export interface ApiResourceConfig {
+    prefix: string;
+    endpoints: ApiEndpointConfig[];
+}
+export type ApiConfig = Record<string, ApiResourceConfig>;
+export interface WebPageConfig {
+    path: string;
+    method?: 'GET' | 'POST';
+    useCase?: string;
+    view?: string;
+    auth?: AuthConfig;
+    onSuccess?: {
+        redirect?: string;
+        toast?: string;
+        back?: boolean;
+        stay?: boolean;
+    };
+    onError?: {
+        stay?: boolean;
+        toast?: string | 'error';
+    };
+}
+export interface WebResourceConfig {
+    prefix: string;
+    layout?: string;
+    pages: WebPageConfig[];
+}
+export type WebConfig = Record<string, WebResourceConfig>;
+export interface ModuleConfig {
+    domain: DomainConfig;
+    useCases: UseCasesConfig;
+    api?: ApiConfig;
+    web?: WebConfig;
+}
+export declare function isValidModuleConfig(config: any): config is ModuleConfig;

package/dist/types/configTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Type definitions for the Clean Architecture module configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidModuleConfig = isValidModuleConfig;
+// Type guard to validate module config (domain + useCases)
+function isValidModuleConfig(config) {
+    return config && typeof config === 'object' && 'domain' in config && 'useCases' in config;
+}

package/dist/utils/childEntityUtils.d.ts

@@ -0,0 +1,18 @@
+import { ModuleConfig, AggregateFieldConfig } from '../types/configTypes';
+export interface ChildEntityInfo {
+    parentEntityName: string;
+    parentIdField: string;
+    parentTableName: string;
+}
+export interface ParentChildInfo {
+    childEntityName: string;
+    parentIdField: string;
+    childFields: Record<string, AggregateFieldConfig>;
+    childWebPrefix?: string;
+}
+export declare function buildChildEntityMap(config: ModuleConfig): Map<string, ChildEntityInfo>;
+/**
+ * Returns all child entities of a given parent aggregate, with field definitions and web prefix.
+ * Used by template and controller generators when withChild is true.
+ */
+export declare function getChildrenOfParent(config: ModuleConfig, parentName: string): ParentChildInfo[];

package/dist/utils/childEntityUtils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChildEntityMap = buildChildEntityMap;
+exports.getChildrenOfParent = getChildrenOfParent;
+function buildChildEntityMap(config) {
+    var _a;
+    const map = new Map();
+    if (!((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) || !config.useCases) {
+        return map;
+    }
+    const aggregates = config.domain.aggregates;
+    Object.entries(aggregates).forEach(([parentName, aggregateConfig]) => {
+        const entities = aggregateConfig.entities || [];
+        entities.forEach(childName => {
+            const childUseCases = config.useCases[childName];
+            if (!childUseCases) {
+                return;
+            }
+            let parentIdField;
+            Object.values(childUseCases).forEach(useCaseDef => {
+                const input = useCaseDef.input;
+                if (input && typeof input.parentId === 'string' && !parentIdField) {
+                    parentIdField = input.parentId;
+                }
+            });
+            if (!parentIdField) {
+                return;
+            }
+            map.set(childName, {
+                parentEntityName: parentName,
+                parentIdField,
+                parentTableName: parentName.toLowerCase(),
+            });
+        });
+    });
+    return map;
+}
+/**
+ * Returns all child entities of a given parent aggregate, with field definitions and web prefix.
+ * Used by template and controller generators when withChild is true.
+ */
+function getChildrenOfParent(config, parentName) {
+    var _a, _b, _c, _d;
+    const result = [];
+    if (!((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) || !config.useCases) {
+        return result;
+    }
+    const parentAggregate = config.domain.aggregates[parentName];
+    if (!((_b = parentAggregate === null || parentAggregate === void 0 ? void 0 : parentAggregate.entities) === null || _b === void 0 ? void 0 : _b.length)) {
+        return result;
+    }
+    for (const childName of parentAggregate.entities) {
+        const childUseCases = config.useCases[childName];
+        if (!childUseCases)
+            continue;
+        let parentIdField;
+        for (const useCaseDef of Object.values(childUseCases)) {
+            const input = useCaseDef.input;
+            if (input === null || input === void 0 ? void 0 : input.parentId) {
+                parentIdField = input.parentId;
+                break;
+            }
+        }
+        if (!parentIdField)
+            continue;
+        const childAggregate = config.domain.aggregates[childName];
+        if (!(childAggregate === null || childAggregate === void 0 ? void 0 : childAggregate.fields))
+            continue;
+        const childWebPrefix = (_d = (_c = config.web) === null || _c === void 0 ? void 0 : _c[childName]) === null || _d === void 0 ? void 0 : _d.prefix;
+        result.push({
+            childEntityName: childName,
+            parentIdField,
+            childFields: childAggregate.fields,
+            childWebPrefix,
+        });
+    }
+    return result;
+}

package/dist/utils/commandUtils.d.ts

@@ -0,0 +1,43 @@
+import { DomainLayerGenerator } from '../generators/domainLayerGenerator';
+import { DtoGenerator } from '../generators/dtoGenerator';
+import { UseCaseGenerator } from '../generators/useCaseGenerator';
+import { ServiceGenerator } from '../generators/serviceGenerator';
+import { ControllerGenerator } from '../generators/controllerGenerator';
+import { StoreGenerator } from '../generators/storeGenerator';
+import { TemplateGenerator } from '../generators/templateGenerator';
+export interface ModuleEntry {
+    path: string;
+    database?: string;
+    styling?: string;
+    identifiers?: string;
+}
+export interface GlobalConfig {
+    database?: string;
+    styling?: string;
+    identifiers?: string;
+}
+export interface AppConfig {
+    providers?: Record<string, string>;
+    config?: GlobalConfig;
+    modules: Record<string, ModuleEntry>;
+}
+export declare function loadAppConfig(yamlPath: string): AppConfig;
+export declare function getModuleList(config: AppConfig): string[];
+export interface ModuleEntryResolved {
+    name: string;
+    path: string;
+    database: string;
+    styling: string;
+    identifiers: string;
+}
+export declare function getModuleEntries(config: AppConfig): ModuleEntryResolved[];
+export declare function shouldIncludeModule(moduleYamlRel: string, moduleName?: string): boolean;
+export declare function createGenerators(): {
+    domainGen: DomainLayerGenerator;
+    dtoGen: DtoGenerator;
+    useCaseGen: UseCaseGenerator;
+    serviceGen: ServiceGenerator;
+    controllerGen: ControllerGenerator;
+    templateGen: TemplateGenerator;
+    storeGen: StoreGenerator;
+};

package/dist/utils/commandUtils.js

@@ -0,0 +1,124 @@
+"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.loadAppConfig = loadAppConfig;
+exports.getModuleList = getModuleList;
+exports.getModuleEntries = getModuleEntries;
+exports.shouldIncludeModule = shouldIncludeModule;
+exports.createGenerators = createGenerators;
+/**
+ * Shared command infrastructure: app config loading, module filtering, generator creation.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+const domainLayerGenerator_1 = require("../generators/domainLayerGenerator");
+const dtoGenerator_1 = require("../generators/dtoGenerator");
+const useCaseGenerator_1 = require("../generators/useCaseGenerator");
+const serviceGenerator_1 = require("../generators/serviceGenerator");
+const controllerGenerator_1 = require("../generators/controllerGenerator");
+const storeGenerator_1 = require("../generators/storeGenerator");
+const templateGenerator_1 = require("../generators/templateGenerator");
+const DEFAULT_DATABASE = 'mysql';
+const DEFAULT_STYLING = 'bootstrap';
+const DEFAULT_IDENTIFIERS = 'id';
+function loadAppConfig(yamlPath) {
+    const raw = fs.readFileSync(yamlPath, 'utf8');
+    const parsed = (0, yaml_1.parse)(raw);
+    if (!parsed || typeof parsed !== 'object') {
+        return { modules: {} };
+    }
+    const modules = parsed.modules && typeof parsed.modules === 'object' && !Array.isArray(parsed.modules)
+        ? parsed.modules
+        : {};
+    return {
+        providers: parsed.providers,
+        config: parsed.config,
+        modules
+    };
+}
+function getModuleList(config) {
+    if (!config.modules || typeof config.modules !== 'object')
+        return [];
+    return Object.values(config.modules).map((e) => e.path);
+}
+function getModuleEntries(config) {
+    var _a, _b, _c;
+    if (!config.modules || typeof config.modules !== 'object')
+        return [];
+    const global = config.config || {};
+    const database = (_a = global.database) !== null && _a !== void 0 ? _a : DEFAULT_DATABASE;
+    const styling = (_b = global.styling) !== null && _b !== void 0 ? _b : DEFAULT_STYLING;
+    const identifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const globalConfig = { database, styling, identifiers };
+    return Object.entries(config.modules).map(([name, entry]) => {
+        var _a, _b, _c;
+        return ({
+            name,
+            path: entry.path,
+            database: (_a = entry.database) !== null && _a !== void 0 ? _a : globalConfig.database,
+            styling: (_b = entry.styling) !== null && _b !== void 0 ? _b : globalConfig.styling,
+            identifiers: (_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers
+        });
+    });
+}
+function shouldIncludeModule(moduleYamlRel, moduleName) {
+    if (!moduleName || moduleName === '*')
+        return true;
+    const moduleNameLc = moduleName.toLowerCase();
+    const relNormalized = moduleYamlRel.replace(/\\/g, '/').toLowerCase();
+    if (relNormalized.endsWith(`/${moduleNameLc}.yaml`))
+        return true;
+    const moduleYamlPath = path.isAbsolute(moduleYamlRel)
+        ? moduleYamlRel
+        : path.resolve(process.cwd(), moduleYamlRel);
+    const dirName = path.basename(path.dirname(moduleYamlPath)).toLowerCase();
+    if (dirName === moduleNameLc)
+        return true;
+    if (relNormalized.includes(`/${moduleNameLc}/`) || relNormalized.endsWith(`/${moduleNameLc}`))
+        return true;
+    return false;
+}
+function createGenerators() {
+    return {
+        domainGen: new domainLayerGenerator_1.DomainLayerGenerator(),
+        dtoGen: new dtoGenerator_1.DtoGenerator(),
+        useCaseGen: new useCaseGenerator_1.UseCaseGenerator(),
+        serviceGen: new serviceGenerator_1.ServiceGenerator(),
+        controllerGen: new controllerGenerator_1.ControllerGenerator(),
+        templateGen: new templateGenerator_1.TemplateGenerator(),
+        storeGen: new storeGenerator_1.StoreGenerator()
+    };
+}

package/dist/utils/commitUtils.d.ts

@@ -8,6 +8,9 @@ export type DiffHunk = {
     ctxBeforeOld?: string[];
     ctxAfterOld?: string[];
 };
+export interface CommitMeta {
+    [key: string]: unknown;
+}
 type StoredCommit = {
     createdAt?: string;
     files: Array<{
@@ -20,7 +23,7 @@ type StoredCommit = {
         baseHash?: string;
         resultHash?: string;
         hunks?: DiffHunk[];
-        meta?: Record<string, any>;
+        meta?: CommitMeta;
     }>;
 };
 export declare function loadAllCommitRecords(rootDir: string): Array<{

package/dist/utils/constants.d.ts

@@ -53,3 +53,13 @@ export declare const GENERATOR_SUFFIXES: {
     readonly API_CONTROLLER: "ApiController";
     readonly WEB_CONTROLLER: "WebController";
 };
+export declare const AUTH_ROLES: {
+    readonly ALL: "all";
+    readonly AUTHENTICATED: "authenticated";
+    readonly OWNER: "owner";
+};
+export declare const AUTH_ERRORS: {
+    readonly REQUIRED: "Authentication required";
+    readonly ACCESS_DENIED: "Access denied: you do not own this resource";
+    readonly INSUFFICIENT_PERMISSIONS: "Insufficient permissions";
+};

package/dist/utils/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 // Common constants used across the generator
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GENERATOR_SUFFIXES = exports.SERVER = exports.MODULE_STRUCTURE = exports.DEFAULTS = exports.PATH_PATTERNS = exports.GENERATOR_MARKERS = exports.COMMON_FILES = exports.FILE_EXTENSIONS = void 0;
+exports.AUTH_ERRORS = exports.AUTH_ROLES = exports.GENERATOR_SUFFIXES = exports.SERVER = exports.MODULE_STRUCTURE = exports.DEFAULTS = exports.PATH_PATTERNS = exports.GENERATOR_MARKERS = exports.COMMON_FILES = exports.FILE_EXTENSIONS = void 0;
 // File extensions
 exports.FILE_EXTENSIONS = {
     YAML: '.yaml',
@@ -65,3 +65,15 @@ exports.GENERATOR_SUFFIXES = {
     API_CONTROLLER: 'ApiController',
     WEB_CONTROLLER: 'WebController'
 };
+// Auth roles (magic strings used in controller auth generation)
+exports.AUTH_ROLES = {
+    ALL: 'all',
+    AUTHENTICATED: 'authenticated',
+    OWNER: 'owner',
+};
+// Auth error messages (used in controller auth check generation)
+exports.AUTH_ERRORS = {
+    REQUIRED: 'Authentication required',
+    ACCESS_DENIED: 'Access denied: you do not own this resource',
+    INSUFFICIENT_PERMISSIONS: 'Insufficient permissions',
+};