@currentjs/gen 0.5.0 → 0.5.2

package/dist/generators/validationGenerator.js

@@ -1,250 +0,0 @@
-"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.ValidationGenerator = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml_1 = require("yaml");
-const validationTemplates_1 = require("./templates/validationTemplates");
-const generationRegistry_1 = require("../utils/generationRegistry");
-const colors_1 = require("../utils/colors");
-const constants_1 = require("../utils/constants");
-class ValidationGenerator {
-    constructor() {
-        this.availableModels = new Set();
-    }
-    setAvailableModels(models) {
-        this.availableModels.clear();
-        models.forEach(model => {
-            this.availableModels.add(model.name);
-        });
-    }
-    isRelationshipField(field) {
-        return this.availableModels.has(field.type);
-    }
-    getForeignKeyFieldName(field) {
-        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
-        return field.name + 'Id';
-    }
-    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;
-    }
-    getTypeScriptType(yamlType) {
-        return validationTemplates_1.typeMapping[yamlType] || 'any';
-    }
-    generateInterfaceField(field, isCreate) {
-        // For relationship fields, use the foreign key field instead
-        if (this.isRelationshipField(field)) {
-            const foreignKeyName = this.getForeignKeyFieldName(field);
-            const tsType = 'number'; // Foreign keys are always numbers
-            if (isCreate) {
-                const optional = !field.required ? '?' : '';
-                return `  ${foreignKeyName}${optional}: ${tsType};`;
-            }
-            else {
-                return `  ${foreignKeyName}?: ${tsType};`;
-            }
-        }
-        const tsType = this.getTypeScriptType(field.type);
-        if (isCreate) {
-            if (field.auto || field.name === 'id') {
-                return '';
-            }
-            const optional = !field.required ? '?' : '';
-            return `  ${field.name}${optional}: ${tsType};`;
-        }
-        else {
-            if (field.name === 'id' || field.auto) {
-                return '';
-            }
-            return `  ${field.name}?: ${tsType};`;
-        }
-    }
-    generateValidationLogic(field, isCreate) {
-        // For relationship fields, validate the foreign key
-        if (this.isRelationshipField(field)) {
-            const foreignKeyName = this.getForeignKeyFieldName(field);
-            const isRequired = isCreate && field.required;
-            const template = isRequired ? validationTemplates_1.validationTemplates.requiredNumberValidation : validationTemplates_1.validationTemplates.optionalNumberValidation;
-            return this.replaceTemplateVars(template, { FIELD_NAME: foreignKeyName });
-        }
-        const fieldName = field.name;
-        if (field.auto || field.name === 'id') {
-            return '';
-        }
-        let template = '';
-        const isRequired = isCreate && field.required;
-        switch (field.type) {
-            case 'string':
-                template = isRequired ? validationTemplates_1.validationTemplates.requiredStringValidation : validationTemplates_1.validationTemplates.optionalStringValidation;
-                break;
-            case 'number':
-                template = isRequired ? validationTemplates_1.validationTemplates.requiredNumberValidation : validationTemplates_1.validationTemplates.optionalNumberValidation;
-                break;
-            case 'boolean':
-                template = isRequired ? validationTemplates_1.validationTemplates.requiredBooleanValidation : validationTemplates_1.validationTemplates.optionalBooleanValidation;
-                break;
-            case 'datetime':
-                template = isRequired ? validationTemplates_1.validationTemplates.requiredDateValidation : validationTemplates_1.validationTemplates.optionalDateValidation;
-                break;
-            default:
-                template = isRequired ? validationTemplates_1.validationTemplates.requiredComplexValidation : validationTemplates_1.validationTemplates.optionalComplexValidation;
-                break;
-        }
-        return this.replaceTemplateVars(template, { FIELD_NAME: fieldName });
-    }
-    generateDtoField(field, isCreate) {
-        // For relationship fields, use the foreign key field instead
-        if (this.isRelationshipField(field)) {
-            const foreignKeyName = this.getForeignKeyFieldName(field);
-            const tsType = 'number'; // Foreign keys are always numbers
-            if (isCreate) {
-                const optional = !field.required ? '?' : '';
-                return `  ${foreignKeyName}${optional}: ${tsType};`;
-            }
-            else {
-                return `  ${foreignKeyName}?: ${tsType};`;
-            }
-        }
-        const tsType = this.getTypeScriptType(field.type);
-        if (isCreate) {
-            if (field.auto || field.name === 'id') {
-                return '';
-            }
-            const optional = !field.required ? '?' : '';
-            return `  ${field.name}${optional}: ${tsType};`;
-        }
-        else {
-            if (field.name === 'id' || field.auto) {
-                return '';
-            }
-            return `  ${field.name}?: ${tsType};`;
-        }
-    }
-    generateDtoInterface(entityName, fields, isCreate) {
-        const dtoName = `${entityName}DTO`;
-        const dtoFields = fields
-            .map(field => this.generateDtoField(field, isCreate))
-            .filter(field => field !== '')
-            .join('\n');
-        return this.replaceTemplateVars(validationTemplates_1.validationTemplates.dtoInterface, {
-            DTO_NAME: dtoName,
-            DTO_FIELDS: dtoFields
-        });
-    }
-    generateInputInterface(entityName, fields, isCreate) {
-        const interfaceName = `${isCreate ? 'Create' : 'Update'}${entityName}Input`;
-        const interfaceFields = fields
-            .map(field => this.generateInterfaceField(field, isCreate))
-            .filter(field => field !== '')
-            .join('\n');
-        return this.replaceTemplateVars(validationTemplates_1.validationTemplates.inputInterface, {
-            INTERFACE_NAME: interfaceName,
-            INTERFACE_FIELDS: interfaceFields
-        });
-    }
-    generateValidationFunction(entityName, fields, isCreate) {
-        const functionName = `validate${isCreate ? 'Create' : 'Update'}${entityName}`;
-        const dtoParam = `${entityName.toLowerCase()}Data: ${entityName}DTO`;
-        const validationLogic = fields
-            .map(field => this.generateValidationLogic(field, isCreate))
-            .filter(logic => logic !== '')
-            .join('\n');
-        return this.replaceTemplateVars(validationTemplates_1.validationTemplates.validationFunction, {
-            FUNCTION_NAME: functionName,
-            VALIDATION_LOGIC: validationLogic
-        }).replace('(data: any)', `(${dtoParam})`).replace(/data\./g, `${entityName.toLowerCase()}Data.`);
-    }
-    generateValidation(entityName, fields) {
-        const dtoInterface = this.generateDtoInterface(entityName, fields, true);
-        const createValidation = this.generateValidationFunction(entityName, fields, true);
-        const updateValidation = this.generateValidationFunction(entityName, fields, false);
-        const validationFunctions = `${createValidation}\n\n${updateValidation}`;
-        return this.replaceTemplateVars(validationTemplates_1.validationTemplates.validationFileTemplate, {
-            ENTITY_NAME: entityName,
-            DTO_INTERFACES: dtoInterface,
-            VALIDATION_FUNCTIONS: validationFunctions
-        });
-    }
-    generateFromYamlFile(yamlFilePath) {
-        const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
-        const config = (0, yaml_1.parse)(yamlContent);
-        const validations = {};
-        if (config.modules) {
-            Object.values(config.modules).forEach(moduleConfig => {
-                if (moduleConfig.models && moduleConfig.models.length > 0) {
-                    // Set available models for relationship detection
-                    this.setAvailableModels(moduleConfig.models);
-                    moduleConfig.models.forEach(model => {
-                        const validationCode = this.generateValidation(model.name, model.fields);
-                        validations[model.name] = validationCode;
-                    });
-                }
-            });
-        }
-        else if (config.models) {
-            const module = config;
-            if (module.models) {
-                // Set available models for relationship detection
-                this.setAvailableModels(module.models);
-                module.models.forEach(model => {
-                    const validationCode = this.generateValidation(model.name, model.fields);
-                    validations[model.name] = validationCode;
-                });
-            }
-        }
-        return validations;
-    }
-    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'application', opts) {
-        const validations = this.generateFromYamlFile(yamlFilePath);
-        const validationDir = path.join(outputDir, 'validation');
-        fs.mkdirSync(validationDir, { recursive: true });
-        for (const [entityName, validationCode] of Object.entries(validations)) {
-            const fileName = `${entityName}Validation.ts`;
-            const filePath = path.join(validationDir, fileName);
-            // Sequential to avoid multiple prompts overlapping
-            // eslint-disable-next-line no-await-in-loop
-            await (0, generationRegistry_1.writeGeneratedFile)(filePath, validationCode, { 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('Validation files generated successfully!') + '\n');
-    }
-}
-exports.ValidationGenerator = ValidationGenerator;

package/dist/utils/new_parts_of_migrationUtils.js

@@ -1,164 +0,0 @@
-"use strict";
-/*
-export async function connectToDatabase(): Promise<mysql.Connection> {
-  const config = {
-    host: process.env.DB_HOST || 'localhost',
-    port: parseInt(process.env.DB_PORT || '3306'),
-    user: process.env.DB_USER || 'root',
-    password: process.env.DB_PASSWORD || '',
-    database: process.env.DB_NAME || 'test',
-  };
-
-  try {
-    const connection = await mysql.createConnection(config);
-    return connection;
-  } catch (error) {
-    throw new Error(`Failed to connect to database: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export async function getTableNames(connection: mysql.Connection): Promise<string[]> {
-  const [rows] = await connection.query('SHOW TABLES');
-  const tableKey = Object.keys(rows[0] as object)[0];
-  return (rows as any[]).map(row => row[tableKey]);
-}
-
-export async function getTableSchema(connection: mysql.Connection, tableName: string): Promise<ColumnInfo[]> {
-  const [rows] = await connection.query(`DESCRIBE ${tableName}`);
-  return rows as ColumnInfo[];
-}
-
-export async function getForeignKeys(connection: mysql.Connection, tableName: string): Promise<ForeignKeyInfo[]> {
-  const [rows] = await connection.query(
-    `SELECT
-      CONSTRAINT_NAME,
-      COLUMN_NAME,
-      REFERENCED_TABLE_NAME,
-      REFERENCED_COLUMN_NAME
-    FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-    WHERE TABLE_SCHEMA = DATABASE()
-      AND TABLE_NAME = ?
-      AND REFERENCED_TABLE_NAME IS NOT NULL`,
-    [tableName]
-  );
-  return rows as ForeignKeyInfo[];
-}
-
-
-export function sqlTypeToYamlType(sqlType: string): string {
-  const upperType = sqlType.toUpperCase();
-  
-  if (upperType.includes('VARCHAR') || upperType.includes('TEXT') || upperType.includes('CHAR')) {
-    return 'string';
-  }
-  if (upperType.includes('INT') || upperType.includes('DECIMAL') || upperType.includes('FLOAT') || upperType.includes('DOUBLE')) {
-    return 'number';
-  }
-  if (upperType.includes('TINYINT(1)') || upperType.includes('BOOLEAN')) {
-    return 'boolean';
-  }
-  if (upperType.includes('DATETIME') || upperType.includes('TIMESTAMP') || upperType.includes('DATE')) {
-    return 'datetime';
-  }
-  if (upperType.includes('JSON')) {
-    return 'json';
-  }
-  
-  return 'string'; // Default
-}
-
-
-export async function extractSchemaFromDatabase(connection: mysql.Connection): Promise<ModelConfig[]> {
-  const models: ModelConfig[] = [];
-  const tables = await getTableNames(connection);
-
-  for (const table of tables) {
-    // Skip migration log table
-    if (table === 'migration_log') {
-      continue;
-    }
-
-    const columns = await getTableSchema(connection, table);
-    const foreignKeys = await getForeignKeys(connection, table);
-    
-    // Convert table name to model name (e.g., cats -> Cat)
-    const modelName = table.slice(0, -1).charAt(0).toUpperCase() + table.slice(1, -1);
-    
-    const fields: FieldConfig[] = [];
-    
-    for (const column of columns) {
-      // Skip standard columns
-      if (['id', 'created_at', 'updated_at', 'deleted_at'].includes(column.Field)) {
-        continue;
-      }
-      
-      // Check if this is a foreign key
-      const fk = foreignKeys.find(fk => fk.COLUMN_NAME === column.Field);
-      
-      if (fk) {
-        // This is a foreign key - extract the relationship field name
-        const fieldName = column.Field.endsWith('Id')
-          ? column.Field.slice(0, -2)
-          : column.Field;
-        
-        // Convert referenced table to model name
-        const refModelName = fk.REFERENCED_TABLE_NAME.slice(0, -1).charAt(0).toUpperCase() +
-                            fk.REFERENCED_TABLE_NAME.slice(1, -1);
-        
-        fields.push({
-          name: fieldName,
-          type: refModelName,
-          required: column.Null === 'NO'
-        });
-      } else {
-        // Regular field
-        fields.push({
-          name: column.Field,
-          type: sqlTypeToYamlType(column.Type),
-          required: column.Null === 'NO'
-        });
-      }
-    }
-    
-    models.push({
-      name: modelName,
-      fields
-    });
-  }
-
-  return models;
-}
-*/
-/*
-export async function executeMigration(connection: mysql.Connection, migrationSQL: string): Promise<void> {
-  // Split by semicolons and execute each statement
-  const statements = migrationSQL
-    .split(';')
-    .map(s => s.trim())
-    .filter(s => s.length > 0 && !s.startsWith('--'));
-
-  for (const statement of statements) {
-    await connection.query(statement);
-  }
-}
-
-export async function ensureMigrationLogTable(connection: mysql.Connection): Promise<void> {
-  await connection.query(`
-    CREATE TABLE IF NOT EXISTS migration_log (
-      id INT AUTO_INCREMENT PRIMARY KEY,
-      filename VARCHAR(255) NOT NULL UNIQUE,
-      applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-  `);
-}
-
-export async function getAppliedMigrations(connection: mysql.Connection): Promise<string[]> {
-  await ensureMigrationLogTable(connection);
-  const [rows] = await connection.query('SELECT filename FROM migration_log ORDER BY applied_at');
-  return (rows as any[]).map(row => row.filename);
-}
-
-export async function recordMigration(connection: mysql.Connection, filename: string): Promise<void> {
-  await connection.query('INSERT INTO migration_log (filename) VALUES (?)', [filename]);
-}
-*/