@currentjs/gen 0.3.1 → 0.5.0

package/dist/generators/newServiceGenerator.js

@@ -0,0 +1,266 @@
+"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.NewServiceGenerator = 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");
+class NewServiceGenerator {
+    constructor() {
+        this.typeMapping = {
+            string: 'string',
+            number: 'number',
+            integer: 'number',
+            decimal: 'number',
+            boolean: 'boolean',
+            datetime: 'Date',
+            date: 'Date',
+            id: 'number',
+            money: 'Money',
+            json: 'any',
+            array: 'any[]',
+            object: 'object'
+        };
+        this.availableAggregates = new Map();
+    }
+    mapType(yamlType) {
+        if (this.availableAggregates.has(yamlType)) {
+            return yamlType;
+        }
+        return this.typeMapping[yamlType] || 'any';
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo) {
+        const entityLower = modelName.toLowerCase();
+        const storeName = `${entityLower}Store`;
+        switch (actionName) {
+            case 'list':
+                return `  async list(page: number = 1, limit: number = 20): Promise<{ items: ${modelName}[]; total: number; page: number; limit: number }> {
+    const [items, total] = await Promise.all([
+      this.${storeName}.getAll(page, limit),
+      this.${storeName}.count()
+    ]);
+    return { items, total, page, limit };
+  }`;
+            case 'get':
+                return `  async get(id: number): Promise<${modelName}> {
+    const ${entityLower} = await this.${storeName}.getById(id);
+    if (!${entityLower}) {
+      throw new Error('${modelName} not found');
+    }
+    return ${entityLower};
+  }`;
+            case 'create': {
+                // Generate constructor args (ownerId for root, parentIdField for child)
+                const firstArgField = childInfo ? childInfo.parentIdField : 'ownerId';
+                const fields = Object.entries(aggregateConfig.fields)
+                    .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
+                    .sort((a, b) => {
+                    const aRequired = a[1].required !== false;
+                    const bRequired = b[1].required !== false;
+                    if (aRequired === bRequired)
+                        return 0;
+                    return aRequired ? -1 : 1;
+                });
+                const fieldArgs = fields
+                    .map(([fieldName]) => `input.${fieldName}`)
+                    .join(', ');
+                const constructorArgs = `input.${firstArgField}, ${fieldArgs}`;
+                return `  async create(input: any): Promise<${modelName}> {
+    const ${entityLower} = new ${modelName}(0, ${constructorArgs});
+    return await this.${storeName}.insert(${entityLower});
+  }`;
+            }
+            case 'update':
+                const setterCalls = Object.entries(aggregateConfig.fields)
+                    .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
+                    .map(([fieldName]) => {
+                    const methodName = `set${this.capitalize(fieldName)}`;
+                    return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName});
+    }`;
+                })
+                    .join('\n');
+                return `  async update(id: number, input: any): Promise<${modelName}> {
+    const existing${modelName} = await this.${storeName}.getById(id);
+    if (!existing${modelName}) {
+      throw new Error('${modelName} not found');
+    }
+    
+${setterCalls}
+    
+    return await this.${storeName}.update(id, existing${modelName});
+  }`;
+            case 'delete':
+                return `  async delete(id: number): Promise<{ success: boolean; message: string }> {
+    const success = await this.${storeName}.softDelete(id);
+    if (!success) {
+      throw new Error('${modelName} not found or could not be deleted');
+    }
+    return { success: true, message: '${modelName} deleted successfully' };
+  }`;
+            default:
+                return `  async ${actionName}(input: any): Promise<any> {
+    // TODO: Implement default ${actionName} handler
+    throw new Error('Not implemented');
+  }`;
+        }
+    }
+    generateCustomHandlerMethod(modelName, handlerName) {
+        return `  async ${handlerName}(result: any, input: any): Promise<any> {
+    // TODO: Implement custom ${handlerName} handler
+    // This method receives the result from the previous handler (or null if first)
+    // and the input context
+    return result;
+  }`;
+    }
+    collectHandlers(useCases) {
+        const handlers = new Set();
+        Object.values(useCases).forEach(useCaseConfig => {
+            useCaseConfig.handlers.forEach(handler => {
+                handlers.add(handler);
+            });
+        });
+        return handlers;
+    }
+    generateListByParentMethod(modelName, childInfo) {
+        if (!childInfo)
+            return '';
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        return `
+  async listByParent(parentId: number): Promise<${modelName}[]> {
+    return await this.${storeVar}.getByParentId(parentId);
+  }`;
+    }
+    generateGetResourceOwnerMethod(modelName) {
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        return `
+  /**
+   * Get the owner ID of a resource by its ID.
+   * Used for pre-mutation authorization checks.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    return await this.${storeVar}.getResourceOwner(id);
+  }`;
+    }
+    generateService(modelName, useCases, aggregateConfig, childInfo) {
+        const serviceName = `${modelName}Service`;
+        const storeName = `${modelName}Store`;
+        const storeVar = `${modelName.toLowerCase()}Store`;
+        // Collect all unique handlers
+        const handlers = this.collectHandlers(useCases);
+        // Generate methods for each handler
+        const methods = [];
+        handlers.forEach(handler => {
+            if (handler.startsWith('default:')) {
+                const actionName = handler.replace('default:', '');
+                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo));
+            }
+            else {
+                methods.push(this.generateCustomHandlerMethod(modelName, handler));
+            }
+        });
+        const listByParentMethod = this.generateListByParentMethod(modelName, childInfo);
+        if (listByParentMethod) {
+            methods.push(listByParentMethod);
+        }
+        const getResourceOwnerMethod = this.generateGetResourceOwnerMethod(modelName);
+        if (getResourceOwnerMethod) {
+            methods.push(getResourceOwnerMethod);
+        }
+        return `import { ${modelName} } from '../../domain/entities/${modelName}';
+import { ${storeName} } from '../../infrastructure/stores/${storeName}';
+
+/**
+ * Service layer for ${modelName}
+ * Contains business logic handlers that can be composed in use cases
+ */
+export class ${serviceName} {
+  constructor(
+    private ${storeVar}: ${storeName}
+  ) {}
+
+${methods.join('\n\n')}
+}`;
+    }
+    generateFromConfig(config) {
+        const result = {};
+        // Collect all aggregates
+        if (config.domain.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                this.availableAggregates.set(name, aggConfig);
+            });
+        }
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        // Generate a Service file for each model
+        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);
+            result[modelName] = this.generateService(modelName, useCases, aggregateConfig, childInfo);
+        });
+        return result;
+    }
+    generateFromYamlFile(yamlFilePath) {
+        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
+        const config = (0, yaml_1.parse)(yamlContent);
+        if (!(0, configTypes_1.isNewModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected useCases structure.');
+        }
+        return this.generateFromConfig(config);
+    }
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const servicesByModel = this.generateFromYamlFile(yamlFilePath);
+        const servicesDir = path.join(moduleDir, 'application', 'services');
+        fs.mkdirSync(servicesDir, { recursive: true });
+        for (const [modelName, code] of Object.entries(servicesByModel)) {
+            const filePath = path.join(servicesDir, `${modelName}Service.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('Service files generated successfully!') + '\n');
+    }
+}
+exports.NewServiceGenerator = NewServiceGenerator;

package/dist/generators/newStoreGenerator.d.ts

@@ -0,0 +1,39 @@
+import { NewModuleConfig } from '../types/configTypes';
+export declare class NewStoreGenerator {
+    private rowTypeMapping;
+    private availableValueObjects;
+    private capitalize;
+    private isValueObjectType;
+    private getValueObjectName;
+    private getValueObjectConfig;
+    /**
+     * Sort fields the same way as the domain layer generator:
+     * Required fields first, then optional fields.
+     * This ensures rowToModel parameter order matches entity constructor.
+     */
+    private sortFieldsForConstructor;
+    /**
+     * Gets the type name for a value object field (for casting).
+     * For enum fields, returns the generated type name (e.g., BreedName).
+     * For other fields, returns the basic TypeScript type.
+     */
+    private getValueObjectFieldTypeName;
+    private mapTypeToRowType;
+    private replaceTemplateVars;
+    private generateRowFields;
+    private generateFieldNamesStr;
+    private generateRowToModelMapping;
+    private generateInsertDataMapping;
+    private generateUpdateDataMapping;
+    private generateUpdateFieldsArray;
+    private generateValueObjectImports;
+    private generateGetByParentIdMethod;
+    private generateGetResourceOwnerMethod;
+    private generateStore;
+    generateFromConfig(config: NewModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}