@currentjs/gen 0.3.2 → 0.5.1

package/dist/generators/domainLayerGenerator.d.ts

@@ -0,0 +1,21 @@
+import { ModuleConfig } from '../types/configTypes';
+export declare class DomainLayerGenerator {
+    private availableAggregates;
+    private availableValueObjects;
+    private mapType;
+    private getDefaultValue;
+    private generateValueObject;
+    private generateAggregate;
+    generateFromConfig(config: ModuleConfig): Record<string, {
+        code: string;
+        type: 'entity' | 'valueObject';
+    }>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, {
+        code: string;
+        type: 'entity' | 'valueObject';
+    }>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}

package/dist/generators/domainLayerGenerator.js

@@ -0,0 +1,286 @@
+"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.DomainLayerGenerator = 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 DomainLayerGenerator {
+    constructor() {
+        this.availableAggregates = new Set();
+        this.availableValueObjects = new Set();
+    }
+    mapType(yamlType) {
+        return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates, this.availableValueObjects);
+    }
+    getDefaultValue(type) {
+        switch (type) {
+            case 'datetime':
+            case 'date':
+                return 'new Date()';
+            case 'string':
+                return "''";
+            case 'number':
+            case 'integer':
+            case 'decimal':
+                return '0';
+            case 'boolean':
+                return 'false';
+            case 'array':
+                return '[]';
+            case 'object':
+            case 'json':
+                return '{}';
+            default:
+                return 'undefined';
+        }
+    }
+    generateValueObject(name, config) {
+        const fields = Object.entries(config.fields);
+        // Collect type definitions for enum fields
+        const typeDefinitions = [];
+        // Generate constructor parameters
+        const constructorParams = fields.map(([fieldName, fieldConfig]) => {
+            if (typeof fieldConfig === 'object' && 'values' in fieldConfig) {
+                // Enum type - generate a type alias
+                const typeName = `${name}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                const uniqueValues = [...new Set(fieldConfig.values)]; // dedupe
+                const enumValues = uniqueValues.map(v => `'${v}'`).join(' | ');
+                typeDefinitions.push(`export type ${typeName} = ${enumValues};`);
+                return `public ${fieldName}: ${typeName}`;
+            }
+            else {
+                const tsType = this.mapType(fieldConfig.type);
+                return `public ${fieldName}: ${tsType}`;
+            }
+        }).join(',\n        ');
+        // Generate validation logic
+        const validations = [];
+        fields.forEach(([fieldName, fieldConfig]) => {
+            if (typeof fieldConfig === 'object' && 'constraints' in fieldConfig && fieldConfig.constraints) {
+                const constraints = fieldConfig.constraints;
+                if (constraints.min !== undefined) {
+                    validations.push(`    if (this.${fieldName} < ${constraints.min}) {
+      throw new Error('${name}.${fieldName} must be at least ${constraints.min}');
+    }`);
+                }
+                if (constraints.max !== undefined) {
+                    validations.push(`    if (this.${fieldName} > ${constraints.max}) {
+      throw new Error('${name}.${fieldName} must be at most ${constraints.max}');
+    }`);
+                }
+                if (constraints.pattern) {
+                    validations.push(`    if (!/${constraints.pattern}/.test(String(this.${fieldName}))) {
+      throw new Error('${name}.${fieldName} does not match required pattern');
+    }`);
+                }
+            }
+            if (typeof fieldConfig === 'object' && 'values' in fieldConfig) {
+                const uniqueValues = [...new Set(fieldConfig.values)]; // dedupe
+                const values = uniqueValues.map(v => `'${v}'`).join(', ');
+                validations.push(`    if (![${values}].includes(this.${fieldName})) {
+      throw new Error(\`${name}.${fieldName} must be one of: ${values}\`);
+    }`);
+            }
+        });
+        const validationCode = validations.length > 0 ? `\n    this.validate();\n  }\n\n  private validate(): void {\n${validations.join('\n')}\n  }` : '\n  }';
+        const typeDefsCode = typeDefinitions.length > 0 ? typeDefinitions.join('\n') + '\n\n' : '';
+        return `${typeDefsCode}export class ${name} {
+  public constructor(
+        ${constructorParams}
+    ) {${validationCode}
+}`;
+    }
+    generateAggregate(name, config, allAggregates, childInfo) {
+        const fields = Object.entries(config.fields);
+        // Determine which entities are contained in this aggregate
+        const containedEntities = config.entities || [];
+        // Generate imports for contained entities
+        const entityImports = containedEntities
+            .filter(entityName => entityName !== name && allAggregates[entityName])
+            .map(entityName => `import { ${entityName} } from './${entityName}';`)
+            .join('\n');
+        // Generate imports for value objects used in fields
+        const valueObjectImports = fields
+            .filter(([, fieldConfig]) => this.availableValueObjects.has((0, typeUtils_1.capitalize)(fieldConfig.type)))
+            .map(([, fieldConfig]) => {
+            const voName = (0, typeUtils_1.capitalize)(fieldConfig.type);
+            return `import { ${voName} } from '../valueObjects/${voName}';`;
+        })
+            .filter((imp, idx, arr) => arr.indexOf(imp) === idx) // dedupe
+            .join('\n');
+        // Generate imports for aggregate references in fields (e.g. idea: { type: Idea })
+        const aggregateRefImports = fields
+            .filter(([, fieldConfig]) => (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates) &&
+            fieldConfig.type !== name)
+            .map(([, fieldConfig]) => `import { ${fieldConfig.type} } from './${fieldConfig.type}';`)
+            .filter((imp, idx, arr) => arr.indexOf(imp) === idx)
+            .join('\n');
+        const imports = [entityImports, valueObjectImports, aggregateRefImports].filter(Boolean).join('\n');
+        // Generate constructor parameters: id, then ownerId (root) or parentId field (child)
+        const constructorParams = ['public id: number'];
+        if (childInfo) {
+            constructorParams.push(`public ${childInfo.parentIdField}: number`);
+        }
+        else {
+            constructorParams.push('public ownerId: number');
+        }
+        // Sort fields: required first, then optional
+        // Fields are required by default unless required: false
+        // Aggregate references are always treated as optional (store can't populate them from FK alone)
+        const sortedFields = fields.sort((a, b) => {
+            const aIsAggRef = (0, typeUtils_1.isAggregateReference)(a[1].type, this.availableAggregates);
+            const bIsAggRef = (0, typeUtils_1.isAggregateReference)(b[1].type, this.availableAggregates);
+            const aRequired = a[1].required !== false && !a[1].auto && !aIsAggRef;
+            const bRequired = b[1].required !== false && !b[1].auto && !bIsAggRef;
+            if (aRequired === bRequired)
+                return 0;
+            return aRequired ? -1 : 1;
+        });
+        const enumTypeDefinitions = [];
+        const enumTypeNames = {};
+        sortedFields.forEach(([fieldName, fieldConfig]) => {
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const typeName = `${name}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                const uniqueValues = [...new Set(fieldConfig.values)];
+                const enumValues = uniqueValues.map(v => `'${v}'`).join(' | ');
+                enumTypeDefinitions.push(`export type ${typeName} = ${enumValues};`);
+                enumTypeNames[fieldName] = typeName;
+            }
+        });
+        sortedFields.forEach(([fieldName, fieldConfig]) => {
+            const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
+            const tsType = enumTypeNames[fieldName] || this.mapType(fieldConfig.type);
+            const isOptional = fieldConfig.required === false || isAggRef;
+            const hasDefault = fieldConfig.auto;
+            let param = `public ${fieldName}`;
+            if (isOptional && !hasDefault) {
+                param += '?';
+            }
+            param += `: ${tsType}`;
+            if (hasDefault) {
+                param += ` = ${this.getDefaultValue(fieldConfig.type)}`;
+            }
+            constructorParams.push(param);
+        });
+        const constructorParamsStr = constructorParams.join(',\n        ');
+        // Generate setter methods
+        const setterMethods = sortedFields
+            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
+            .map(([fieldName, fieldConfig]) => {
+            const isAggRef = (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
+            const tsType = enumTypeNames[fieldName] || this.mapType(fieldConfig.type);
+            const methodName = `set${(0, typeUtils_1.capitalize)(fieldName)}`;
+            const isOptional = fieldConfig.required === false || isAggRef;
+            return `
+    ${methodName}(${fieldName}: ${tsType}${isOptional ? ' | undefined' : ''}): void {
+        this.${fieldName} = ${fieldName};
+    }`;
+        })
+            .join('\n');
+        const rootComment = config.root ? '// Aggregate Root\n' : '';
+        const enumTypeDefsCode = enumTypeDefinitions.length > 0 ? enumTypeDefinitions.join('\n') + '\n\n' : '';
+        return `${imports ? imports + '\n\n' : ''}${enumTypeDefsCode}${rootComment}export class ${name} {
+    public constructor(
+        ${constructorParamsStr}
+    ) { }
+${setterMethods}
+}`;
+    }
+    generateFromConfig(config) {
+        const result = {};
+        // First pass: collect all aggregate and value object names
+        if (config.domain.aggregates) {
+            Object.keys(config.domain.aggregates).forEach(name => {
+                this.availableAggregates.add(name);
+            });
+        }
+        if (config.domain.valueObjects) {
+            Object.keys(config.domain.valueObjects).forEach(name => {
+                this.availableValueObjects.add(name);
+            });
+        }
+        // Generate value objects first (they may be used by aggregates)
+        if (config.domain.valueObjects) {
+            Object.entries(config.domain.valueObjects).forEach(([name, voConfig]) => {
+                result[name] = {
+                    code: this.generateValueObject(name, voConfig),
+                    type: 'valueObject'
+                };
+            });
+        }
+        // Generate aggregates
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        if (config.domain.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([name, aggConfig]) => {
+                const childInfo = childEntityMap.get(name);
+                result[name] = {
+                    code: this.generateAggregate(name, aggConfig, config.domain.aggregates, childInfo),
+                    type: 'entity'
+                };
+            });
+        }
+        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 domain.aggregates structure.');
+        }
+        return this.generateFromConfig(config);
+    }
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const codeByEntity = this.generateFromYamlFile(yamlFilePath);
+        const entitiesDir = path.join(moduleDir, 'domain', 'entities');
+        const valueObjectsDir = path.join(moduleDir, 'domain', 'valueObjects');
+        fs.mkdirSync(entitiesDir, { recursive: true });
+        fs.mkdirSync(valueObjectsDir, { recursive: true });
+        for (const [name, { code, type }] of Object.entries(codeByEntity)) {
+            const outputDir = type === 'valueObject' ? valueObjectsDir : entitiesDir;
+            const filePath = path.join(outputDir, `${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('Domain layer files generated successfully!') + '\n');
+    }
+}
+exports.DomainLayerGenerator = DomainLayerGenerator;

package/dist/generators/dtoGenerator.d.ts

@@ -0,0 +1,21 @@
+import { ModuleConfig } from '../types/configTypes';
+export declare class DtoGenerator {
+    private availableAggregates;
+    private availableValueObjects;
+    private mapType;
+    private isValueObjectType;
+    private getValidationCode;
+    private getTransformCode;
+    private generateInputDto;
+    private generateOutputDto;
+    /**
+     * Collect types that need to be imported for a use case DTO.
+     */
+    private collectRequiredImports;
+    generateFromConfig(config: ModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}