@currentjs/gen 0.1.1

package/dist/generators/serviceGenerator.js

@@ -0,0 +1,379 @@
+"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.ServiceGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const serviceTemplates_1 = require("./templates/serviceTemplates");
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const constants_1 = require("../utils/constants");
+class ServiceGenerator {
+    hasPermissions(config) {
+        if (config.modules) {
+            return Object.values(config.modules).some(module => module.permissions && module.permissions.length > 0);
+        }
+        const module = config;
+        return !!(module.permissions && module.permissions.length > 0);
+    }
+    getActionPermissions(moduleName, moduleConfig) {
+        if (!moduleConfig.permissions || !moduleConfig.actions) {
+            return {};
+        }
+        const actionPermissions = {};
+        // Initialize all actions with empty permissions
+        Object.keys(moduleConfig.actions).forEach(action => {
+            actionPermissions[action] = [];
+        });
+        // Fill in permissions for each action
+        moduleConfig.permissions.forEach(permission => {
+            permission.actions.forEach(action => {
+                if (actionPermissions[action]) {
+                    actionPermissions[action].push(permission.role);
+                }
+            });
+        });
+        return actionPermissions;
+    }
+    generatePermissionCheck(action, roles, entityName) {
+        if (roles.length === 0 || roles.includes('all')) {
+            return '';
+        }
+        if (roles.includes('none')) {
+            return "    throw new Error('This action is not permitted');";
+        }
+        const nonOwnerRoles = roles.filter(role => !['all', 'none', 'owner'].includes(role));
+        const rolesArray = nonOwnerRoles.map(role => `'${role}'`).join(', ');
+        // Special-case: list action with owner → rely on store-level filtering; only enforce static role checks for other roles
+        if (action === 'list' && roles.includes('owner')) {
+            if (nonOwnerRoles.length === 0) {
+                return '';
+            }
+            return serviceTemplates_1.serviceTemplates.permissionCheck
+                .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
+                .replace(/{{ACTION_NAME}}/g, action)
+                .replace(/{{ROLES_ARRAY}}/g, rolesArray);
+        }
+        // For resource-based owner permission (non-list), fetch resource first and verify ownership
+        if (roles.includes('owner')) {
+            const isResourceBased = ['get', 'update', 'delete'].includes(action);
+            if (!isResourceBased) {
+                // Not a resource-based action; fall back to static role checks only (if any non-owner roles)
+                if (nonOwnerRoles.length === 0) {
+                    return '';
+                }
+                return serviceTemplates_1.serviceTemplates.permissionCheck
+                    .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
+                    .replace(/{{ACTION_NAME}}/g, action)
+                    .replace(/{{ROLES_ARRAY}}/g, rolesArray);
+            }
+            const entityLower = entityName.toLowerCase();
+            const resourceIdParam = this.getResourceIdForAction(action);
+            const notFoundMessage = `${entityName} not found`;
+            // If there are additional roles besides owner, allow them to bypass owner check
+            const maybeRoleBypass = nonOwnerRoles.length > 0
+                ? `    const allowedRoles = [${rolesArray}];
+    if (allowedRoles.includes(user.role)) {
+      // Explicit role allowed; skip owner check
+    } else {
+      const ${entityLower} = await this.${entityLower}Store.getById(${resourceIdParam});
+      if (!${entityLower}) {
+        throw new Error('${notFoundMessage}');
+      }
+      if ((${entityLower} as any).userId !== user.id) {
+        throw new Error('You can only access your own resources');
+      }
+    }`
+                : `    const ${entityLower} = await this.${entityLower}Store.getById(${resourceIdParam});
+    if (!${entityLower}) {
+      throw new Error('${notFoundMessage}');
+    }
+    if ((${entityLower} as any).userId !== user.id) {
+      throw new Error('You can only access your own resources');
+    }`;
+            return maybeRoleBypass;
+        }
+        // Static role check for non-owner roles
+        return serviceTemplates_1.serviceTemplates.permissionCheck
+            .replace(/{{REQUIRED_ROLES}}/g, roles.join(', '))
+            .replace(/{{ACTION_NAME}}/g, action)
+            .replace(/{{ROLES_ARRAY}}/g, rolesArray);
+    }
+    getResourceIdForAction(action) {
+        switch (action) {
+            case 'get':
+            case 'update':
+            case 'delete':
+                return 'id';
+            default:
+                return 'id';
+        }
+    }
+    generateMethodParams(action, entityName) {
+        const entityParam = `${entityName.toLowerCase()}Data`;
+        switch (action) {
+            case 'list':
+                return 'page: number = 1, limit: number = 10';
+            case 'get':
+                return 'id: number';
+            case 'create':
+                return `${entityParam}: ${entityName}DTO`;
+            case 'update':
+                return `id: number, ${entityParam}: ${entityName}DTO`;
+            case 'delete':
+                return 'id: number';
+            default:
+                return '';
+        }
+    }
+    generateReturnType(action, entityName) {
+        switch (action) {
+            case 'list':
+                return `${entityName}[]`;
+            case 'get':
+            case 'create':
+            case 'update':
+                return entityName;
+            case 'delete':
+                return '{ success: boolean; message: string }';
+            default:
+                return 'void';
+        }
+    }
+    generateMethodImplementation(action, entityName, handlers, moduleName, roles, moduleConfig) {
+        if (!handlers || handlers.length === 0) {
+            return `// TODO: Implement ${action} method`;
+        }
+        const implementations = [];
+        handlers.forEach(handler => {
+            if (handler.startsWith('default:')) {
+                const defaultAction = handler.substring(8);
+                const template = serviceTemplates_1.serviceTemplates.defaultImplementations[defaultAction];
+                if (template) {
+                    const entityLower = entityName.toLowerCase();
+                    let processedTemplate = template
+                        .replace(/{{ENTITY_NAME}}/g, entityName)
+                        .replace(/{{ENTITY_LOWER}}/g, entityLower);
+                    // Handle constructor args for create action
+                    if (defaultAction === 'create') {
+                        const constructorArgs = this.generateConstructorArgs(moduleConfig, entityName);
+                        processedTemplate = processedTemplate.replace(/{{CONSTRUCTOR_ARGS}}/g, constructorArgs);
+                    }
+                    // Handle setter calls for update action
+                    if (defaultAction === 'update') {
+                        const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName);
+                        processedTemplate = processedTemplate.replace(/{{UPDATE_SETTER_CALLS}}/g, setterCalls);
+                    }
+                    // Special-case: list action with only owner role → fetch by userId
+                    if (defaultAction === 'list') {
+                        const onlyOwner = roles.length > 0 && roles.every(r => r === 'owner');
+                        if (onlyOwner) {
+                            processedTemplate = `const ${entityLower}s = await this.${entityLower}Store.getAllByUserId(user.id, page, limit);\n    return ${entityLower}s;`;
+                        }
+                    }
+                    implementations.push(processedTemplate);
+                }
+                else {
+                    implementations.push(`// TODO: Implement default ${defaultAction} method`);
+                }
+            }
+            else if (handler.startsWith(constants_1.PATH_PATTERNS.MODULES_DIRECTIVE)) {
+                const functionName = this.extractFunctionName(handler);
+                const customImpl = serviceTemplates_1.serviceTemplates.customActionImplementation.replace(/{{CUSTOM_FUNCTION_CALL}}/g, `${functionName}(${this.getMethodCallParams(action)})`);
+                implementations.push(customImpl);
+            }
+            else {
+                implementations.push(`// TODO: Implement handler ${handler}`);
+            }
+        });
+        return implementations.join('\n    ');
+    }
+    extractFunctionName(filePath) {
+        const parts = filePath.split('/');
+        const fileName = parts[parts.length - 1];
+        return fileName;
+    }
+    getMethodCallParams(action) {
+        switch (action) {
+            case 'list':
+                return 'page, limit';
+            case 'get':
+                return 'id';
+            case 'create':
+                return 'userData';
+            case 'update':
+                return 'id, updates';
+            case 'delete':
+                return 'id';
+            default:
+                return '/* custom params */';
+        }
+    }
+    generateConstructorArgs(moduleConfig, entityName) {
+        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        const model = moduleConfig.models[0];
+        const entityLower = entityName.toLowerCase();
+        return model.fields
+            .filter(field => !field.auto && field.name !== 'id')
+            .map(field => `${entityLower}Data.${field.name}`)
+            .join(', ');
+    }
+    generateUpdateSetterCalls(moduleConfig, entityName) {
+        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        const model = moduleConfig.models[0];
+        const entityLower = entityName.toLowerCase();
+        return model.fields
+            .filter(field => !field.auto && field.name !== 'id')
+            .map(field => {
+            const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
+            return `if (${entityLower}Data.${field.name} !== undefined) {
+      existing${entityName}.${methodName}(${entityLower}Data.${field.name});
+    }`;
+        })
+            .join('\n    ');
+    }
+    replaceTemplateVars(template, variables) {
+        let result = template;
+        Object.entries(variables).forEach(([key, value]) => {
+            const regex = new RegExp(`{{${key}}}`, 'g');
+            result = result.replace(regex, String(value));
+        });
+        return result;
+    }
+    generateServiceMethod(action, entityName, roles, hasPermissions, handlers, moduleName, moduleConfig) {
+        const methodParams = this.generateMethodParams(action, entityName);
+        const returnType = this.generateReturnType(action, entityName);
+        const permissionCheck = this.generatePermissionCheck(action, roles, entityName);
+        const methodImplementation = this.generateMethodImplementation(action, entityName, handlers, moduleName, roles, moduleConfig);
+        const hasUserParam = roles.length > 0 && !roles.includes('all');
+        const variables = {
+            METHOD_NAME: action,
+            METHOD_PARAMS: methodParams,
+            USER_PARAM: hasUserParam ? ', user: AuthenticatedUser' : '',
+            RETURN_TYPE: returnType,
+            PERMISSION_CHECK: permissionCheck,
+            METHOD_IMPLEMENTATION: methodImplementation
+        };
+        return this.replaceTemplateVars(serviceTemplates_1.serviceTemplates.serviceMethod, variables);
+    }
+    generateService(moduleName, moduleConfig, hasGlobalPermissions) {
+        if (!moduleConfig.actions || !moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        const entityName = moduleConfig.models[0].name;
+        const entityLower = entityName.toLowerCase();
+        const actionPermissions = this.getActionPermissions(moduleName, moduleConfig);
+        const hasPermissions = !!(hasGlobalPermissions && moduleConfig.permissions && moduleConfig.permissions.length > 0);
+        const serviceMethods = Object.entries(moduleConfig.actions)
+            .map(([action, actionConfig]) => {
+            const roles = actionPermissions[action] || [];
+            const handlers = actionConfig.handlers || [];
+            return this.generateServiceMethod(action, entityName, roles, hasPermissions, handlers, moduleName, moduleConfig);
+        })
+            .join('\n\n');
+        const serviceClass = this.replaceTemplateVars(serviceTemplates_1.serviceTemplates.serviceClass, {
+            ENTITY_NAME: entityName,
+            ENTITY_LOWER: entityLower,
+            AUTH_SERVICE_PARAM: '',
+            SERVICE_METHODS: serviceMethods
+        });
+        const customImports = this.generateCustomImports(moduleConfig);
+        return this.replaceTemplateVars(serviceTemplates_1.serviceFileTemplate, {
+            ENTITY_NAME: entityName,
+            PERMISSIONS_IMPORT: hasPermissions ? "\nimport type { AuthenticatedUser } from '@currentjs/router';" : '',
+            CUSTOM_IMPORTS: customImports,
+            SERVICE_CLASS: serviceClass
+        });
+    }
+    generateCustomImports(moduleConfig) {
+        if (!moduleConfig.actions)
+            return '';
+        const imports = [];
+        Object.values(moduleConfig.actions).forEach(actionConfig => {
+            if (actionConfig.handlers) {
+                actionConfig.handlers.forEach(handler => {
+                    if (handler.startsWith(constants_1.PATH_PATTERNS.MODULES_DIRECTIVE)) {
+                        const functionName = this.extractFunctionName(handler);
+                        const importPath = handler.replace(constants_1.PATH_PATTERNS.MODULES_DIRECTIVE, '../../');
+                        imports.push(`import ${functionName} from '${importPath}';`);
+                    }
+                });
+            }
+        });
+        return imports.length > 0 ? '\n' + imports.join('\n') : '';
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        const result = {};
+        const hasGlobalPermissions = this.hasPermissions(config);
+        if (config.modules) {
+            Object.entries(config.modules).forEach(([moduleName, moduleConfig]) => {
+                const serviceCode = this.generateService(moduleName, moduleConfig, hasGlobalPermissions);
+                if (serviceCode) {
+                    result[moduleName] = serviceCode;
+                }
+            });
+        }
+        else {
+            const moduleName = 'Module';
+            const moduleConfig = config;
+            const serviceCode = this.generateService(moduleName, moduleConfig, hasGlobalPermissions);
+            if (serviceCode && moduleConfig.models && moduleConfig.models[0]) {
+                result[moduleConfig.models[0].name] = serviceCode;
+            }
+        }
+        return result;
+    }
+    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'application', opts) {
+        const services = this.generateFromYamlFile(yamlFilePath);
+        const servicesDir = path.join(outputDir, 'services');
+        fs.mkdirSync(servicesDir, { recursive: true });
+        for (const [moduleName, serviceCode] of Object.entries(services)) {
+            const fileName = `${moduleName}Service.ts`;
+            const filePath = path.join(servicesDir, fileName);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, serviceCode, { 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('Service files generated successfully!') + '\n');
+    }
+}
+exports.ServiceGenerator = ServiceGenerator;

package/dist/generators/storeGenerator.d.ts

@@ -0,0 +1,31 @@
+interface FieldConfig {
+    name: string;
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+}
+interface ModelConfig {
+    name: string;
+    fields: FieldConfig[];
+}
+export declare class StoreGenerator {
+    private typeMapping;
+    private mapType;
+    private generateRowFields;
+    private generateFilterableFields;
+    private generateFilterableFieldsArray;
+    private generateUpdatableFieldsArray;
+    private generateRowToModelMapping;
+    private generateModelToRowMapping;
+    private replaceTemplateVars;
+    generateStoreInterface(): string;
+    generateStore(modelConfig: ModelConfig): string;
+    generateStores(models: ModelConfig[]): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}
+export {};

package/dist/generators/storeGenerator.js

@@ -0,0 +1,191 @@
+"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.StoreGenerator = void 0;
+const yaml_1 = require("yaml");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const storeTemplates_1 = require("./templates/storeTemplates");
+const generationRegistry_1 = require("../utils/generationRegistry");
+const colors_1 = require("../utils/colors");
+const constants_1 = require("../utils/constants");
+class StoreGenerator {
+    constructor() {
+        this.typeMapping = {
+            string: 'string',
+            number: 'number',
+            boolean: 'boolean',
+            datetime: 'Date',
+            json: 'any',
+            array: 'any[]',
+            object: 'object'
+        };
+    }
+    mapType(yamlType) {
+        return this.typeMapping[yamlType] || 'any';
+    }
+    generateRowFields(modelConfig) {
+        const fields = [];
+        modelConfig.fields.forEach(field => {
+            if (field.name === 'createdAt') {
+                return;
+            }
+            const tsType = this.mapType(field.type);
+            const isOptional = !field.required && !field.auto;
+            const fieldDef = `  ${field.name}${isOptional ? '?' : ''}: ${tsType};`;
+            fields.push(fieldDef);
+        });
+        return fields.join('\n');
+    }
+    generateFilterableFields(modelConfig) {
+        const filterableFields = modelConfig.fields
+            .filter(field => ['string', 'number', 'boolean'].includes(field.type))
+            .map(field => `'${field.name}'`);
+        return filterableFields.join(' | ');
+    }
+    generateFilterableFieldsArray(modelConfig) {
+        const filterableFields = modelConfig.fields
+            .filter(field => ['string', 'number', 'boolean'].includes(field.type))
+            .map(field => `'${field.name}'`);
+        return filterableFields.join(', ');
+    }
+    generateUpdatableFieldsArray(modelConfig) {
+        const updatableFields = modelConfig.fields
+            .filter(field => field.name !== 'id' && field.name !== 'createdAt')
+            .map(field => `'${field.name}'`);
+        return updatableFields.join(', ');
+    }
+    generateRowToModelMapping(modelConfig) {
+        const mappings = modelConfig.fields.map(field => {
+            if (field.name === 'createdAt') {
+                return '      row.created_at';
+            }
+            return `      row.${field.name}`;
+        });
+        return mappings.join(',\n');
+    }
+    generateModelToRowMapping(modelConfig) {
+        const mappings = modelConfig.fields.map(field => {
+            if (field.name === 'createdAt') {
+                return '      created_at: model.createdAt';
+            }
+            return `      ${field.name}: model.${field.name}`;
+        });
+        return mappings.join(',\n');
+    }
+    replaceTemplateVars(template, variables) {
+        let result = template;
+        Object.entries(variables).forEach(([key, value]) => {
+            const regex = new RegExp(`{{${key}}}`, 'g');
+            result = result.replace(regex, value);
+        });
+        return result;
+    }
+    generateStoreInterface() {
+        return storeTemplates_1.fileTemplates.storeInterface;
+    }
+    generateStore(modelConfig) {
+        const entityName = modelConfig.name;
+        const tableName = entityName.toLowerCase() + 's';
+        const variables = {
+            ENTITY_NAME: entityName,
+            TABLE_NAME: tableName,
+            ROW_FIELDS: this.generateRowFields(modelConfig),
+            FILTERABLE_FIELDS: this.generateFilterableFields(modelConfig),
+            FILTERABLE_FIELDS_ARRAY: this.generateFilterableFieldsArray(modelConfig),
+            UPDATABLE_FIELDS_ARRAY: this.generateUpdatableFieldsArray(modelConfig),
+            ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(modelConfig),
+            MODEL_TO_ROW_MAPPING: this.generateModelToRowMapping(modelConfig)
+        };
+        const rowInterface = this.replaceTemplateVars(storeTemplates_1.storeTemplates.rowInterface, variables);
+        const conversionMethods = this.replaceTemplateVars(storeTemplates_1.storeTemplates.conversionMethods, variables);
+        const storeClass = this.replaceTemplateVars(storeTemplates_1.storeTemplates.storeClass, {
+            ...variables,
+            CONVERSION_METHODS: conversionMethods
+        });
+        return this.replaceTemplateVars(storeTemplates_1.fileTemplates.storeFile, {
+            ENTITY_NAME: entityName,
+            ROW_INTERFACE: rowInterface,
+            STORE_CLASS: storeClass
+        });
+    }
+    generateStores(models) {
+        const result = {};
+        models.forEach(model => {
+            result[model.name] = this.generateStore(model);
+        });
+        return result;
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        const result = {};
+        if (config.modules) {
+            Object.values(config.modules).forEach(moduleConfig => {
+                if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    const stores = this.generateStores(moduleConfig.models);
+                    Object.assign(result, stores);
+                }
+            });
+        }
+        else if (config.models) {
+            const module = config;
+            if (module.models && module.models.length > 0) {
+                const stores = this.generateStores(module.models);
+                Object.assign(result, stores);
+            }
+        }
+        return result;
+    }
+    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'infrastructure', opts) {
+        const stores = this.generateFromYamlFile(yamlFilePath);
+        const storesDir = path.join(outputDir, 'stores');
+        const interfacesDir = path.join(outputDir, 'interfaces');
+        fs.mkdirSync(storesDir, { recursive: true });
+        fs.mkdirSync(interfacesDir, { recursive: true });
+        const storeInterface = this.generateStoreInterface();
+        const interfaceFilePath = path.join(interfacesDir, constants_1.COMMON_FILES.STORE_INTERFACE);
+        await (0, generationRegistry_1.writeGeneratedFile)(interfaceFilePath, storeInterface, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+        for (const [entityName, storeCode] of Object.entries(stores)) {
+            const fileName = `${entityName}Store.ts`;
+            const filePath = path.join(storesDir, fileName);
+            // eslint-disable-next-line no-await-in-loop
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, storeCode, { 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('All store files generated successfully!') + '\n');
+    }
+}
+exports.StoreGenerator = StoreGenerator;

package/dist/generators/templateGenerator.d.ts

@@ -0,0 +1,11 @@
+export declare class TemplateGenerator {
+    private generateForModule;
+    generateFromYamlFile(yamlFilePath: string): Record<string, {
+        file: string;
+        contents: string;
+    }>;
+    generateAndSaveFiles(yamlFilePath: string, _outputDir: string | undefined, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}