@currentjs/gen 0.3.2 → 0.5.0

package/dist/generators/storeGeneratorV2.js

@@ -0,0 +1,190 @@
+"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.StoreGeneratorV2 = 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");
+class StoreGeneratorV2 {
+    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 = '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, 'StoreInterface.ts');
+        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.StoreGeneratorV2 = StoreGeneratorV2;

package/dist/generators/templateGenerator.d.ts

@@ -1,29 +1,29 @@
+import { ModuleConfig } from '../types/configTypes';
 export declare class TemplateGenerator {
+    private valueObjects;
     /**
-     * Helper method to infer model from action handlers
+     * Convert a route prefix like "/invoice/:invoiceId/items" into a
+     * template-ready path like "/invoice/{{ invoiceId }}/items".
      */
-    private inferModelFromAction;
+    private prefixToTemplatePath;
     /**
-     * Find the actual API endpoint path for a given action and model
+     * Replace a single path param in prefix with a template expression (e.g. for list: item.id, for detail: id).
      */
-    private findApiEndpointPath;
-    /**
-     * Build relationship context for finding create routes and list API endpoints
-     */
-    private buildRelationshipContext;
-    /**
-     * Generate templates for a single routes configuration
-     */
-    private generateForRoutesConfig;
-    /**
-     * Generate templates for a module (handles both single routes object and array)
-     */
-    private generateForModule;
-    generateFromYamlFile(yamlFilePath: string): Record<string, {
-        file: string;
-        contents: string;
-    }>;
-    generateAndSaveFiles(yamlFilePath: string, _outputDir: string | undefined, opts?: {
+    private prefixWithParam;
+    private renderListTemplate;
+    private renderChildTableSection;
+    private renderDetailTemplate;
+    private buildFieldTypesJson;
+    private renderFormTemplate;
+    private renderCreateTemplate;
+    private renderEditTemplate;
+    private getInputType;
+    private renderValueObjectField;
+    private renderFormField;
+    private getEnumValuesMap;
+    generateFromConfig(config: ModuleConfig): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
         force?: boolean;
         skipOnConflict?: boolean;
     }): Promise<void>;