@currentjs/gen 0.3.1 → 0.5.0

package/dist/utils/diResolver.js

@@ -0,0 +1,204 @@
+"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.parseClassFile = parseClassFile;
+exports.scanModuleClasses = scanModuleClasses;
+exports.buildInstantiationOrder = buildInstantiationOrder;
+exports.resolveProviderImport = resolveProviderImport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const INJECTABLE_RE = /@Injectable\s*\(/;
+const CONTROLLER_RE = /@Controller\s*\(/;
+const EXPORT_CLASS_RE = /export\s+class\s+(\w+)/;
+const CONSTRUCTOR_PARAMS_RE = /constructor\s*\(([^)]*)\)/s;
+const PARAM_RE = /(?:private|protected|public)\s+(\w+)\s*:\s*([A-Za-z_]\w*)/g;
+function parseClassFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const classMatch = content.match(EXPORT_CLASS_RE);
+    if (!classMatch)
+        return null;
+    const isInjectable = INJECTABLE_RE.test(content);
+    const isController = CONTROLLER_RE.test(content);
+    if (!isInjectable && !isController)
+        return null;
+    const className = classMatch[1];
+    const constructorParams = [];
+    const ctorMatch = content.match(CONSTRUCTOR_PARAMS_RE);
+    if (ctorMatch) {
+        const paramsSrc = ctorMatch[1].replace(/\n/g, ' ');
+        let match;
+        const paramRe = new RegExp(PARAM_RE.source, PARAM_RE.flags);
+        while ((match = paramRe.exec(paramsSrc))) {
+            constructorParams.push({ name: match[1], type: match[2] });
+        }
+    }
+    return { className, filePath, isController, isInjectable, constructorParams };
+}
+function walkTsFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkTsFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.ts')) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+function scanModuleClasses(moduleDir) {
+    const tsFiles = walkTsFiles(moduleDir);
+    const classes = [];
+    for (const file of tsFiles) {
+        const info = parseClassFile(file);
+        if (info)
+            classes.push(info);
+    }
+    return classes;
+}
+/**
+ * @param classes - All discovered @Injectable and @Controller classes
+ * @param providerVarByType - Default mapping from interface type to variable name (e.g., ISqlProvider -> dbMysql)
+ * @param classProviderVar - Per-class override for provider variable (className -> varName).
+ *   Used when different modules use different database providers.
+ * @param srcDir - Absolute path to src/ directory (for computing relative import paths)
+ */
+function buildInstantiationOrder(classes, providerVarByType, classProviderVar, srcDir) {
+    const classMap = new Map();
+    for (const cls of classes) {
+        if (!classMap.has(cls.className)) {
+            classMap.set(cls.className, cls);
+        }
+    }
+    const graph = new Map();
+    for (const cls of classMap.values()) {
+        const deps = [];
+        for (const param of cls.constructorParams) {
+            if (classMap.has(param.type)) {
+                deps.push(param.type);
+            }
+        }
+        graph.set(cls.className, deps);
+    }
+    const sorted = topologicalSort(graph);
+    const steps = [];
+    const varNames = new Map();
+    for (const className of sorted) {
+        const cls = classMap.get(className);
+        const varName = className.charAt(0).toLowerCase() + className.slice(1);
+        varNames.set(className, varName);
+        const constructorArgs = [];
+        for (const param of cls.constructorParams) {
+            if (classProviderVar.has(className) && providerVarByType.has(param.type)) {
+                constructorArgs.push(classProviderVar.get(className));
+            }
+            else if (providerVarByType.has(param.type)) {
+                constructorArgs.push(providerVarByType.get(param.type));
+            }
+            else if (varNames.has(param.type)) {
+                constructorArgs.push(varNames.get(param.type));
+            }
+        }
+        const relPath = path.relative(srcDir, cls.filePath)
+            .replace(/\\/g, '/')
+            .replace(/\.ts$/, '');
+        const importPath = relPath.startsWith('.') ? relPath : `./${relPath}`;
+        steps.push({
+            className,
+            varName,
+            importPath,
+            constructorArgs,
+            isController: cls.isController
+        });
+    }
+    return steps;
+}
+function topologicalSort(graph) {
+    const visited = new Set();
+    const visiting = new Set();
+    const result = [];
+    function visit(node) {
+        if (visited.has(node))
+            return;
+        if (visiting.has(node)) {
+            throw new Error(`Circular dependency detected involving: ${node}`);
+        }
+        visiting.add(node);
+        const deps = graph.get(node) || [];
+        for (const dep of deps) {
+            if (graph.has(dep)) {
+                visit(dep);
+            }
+        }
+        visiting.delete(node);
+        visited.add(node);
+        result.push(node);
+    }
+    for (const node of graph.keys()) {
+        visit(node);
+    }
+    return result;
+}
+function resolveProviderImport(importSpec, appTsDir) {
+    const baseName = importSpec.split('/').pop() || 'provider';
+    const className = baseName
+        .replace(/^[^a-zA-Z_]*/g, '')
+        .split(/[-_]/)
+        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
+    const isLocal = importSpec.startsWith('.') || importSpec.startsWith('/');
+    if (isLocal) {
+        const absPath = path.resolve(appTsDir, importSpec);
+        let relPath = path.relative(appTsDir, absPath).replace(/\\/g, '/');
+        if (!relPath.startsWith('.'))
+            relPath = `./${relPath}`;
+        return { importPath: relPath, className };
+    }
+    return { importPath: importSpec, className };
+}

package/dist/utils/new_parts_of_migrationUtils.js

@@ -0,0 +1,164 @@
+"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]);
+}
+*/

package/dist/utils/typeUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared type mapping and string utilities used across generators.
+ */
+export interface TypeMapping {
+    [key: string]: string;
+}
+/** Standard YAML type to TypeScript (domain) type mapping. */
+export declare const TYPE_MAPPING: Record<string, string>;
+/** Store-specific: YAML type to DB row TypeScript type (e.g. datetime -> string). */
+export declare const ROW_TYPE_MAPPING: Record<string, string>;
+export declare function capitalize(str: string): string;
+/**
+ * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ */
+export declare function mapType(yamlType: string, aggregates?: Set<string> | Map<string, unknown>, valueObjects?: Set<string> | Map<string, unknown>): string;
+/**
+ * Map a YAML type to the store row TypeScript type (value objects become string).
+ */
+export declare function mapRowType(yamlType: string, valueObjects?: Set<string> | Map<string, unknown>): string;

package/dist/utils/typeUtils.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Shared type mapping and string utilities used across generators.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROW_TYPE_MAPPING = exports.TYPE_MAPPING = void 0;
+exports.capitalize = capitalize;
+exports.mapType = mapType;
+exports.mapRowType = mapRowType;
+/** Standard YAML type to TypeScript (domain) type mapping. */
+exports.TYPE_MAPPING = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    decimal: 'number',
+    boolean: 'boolean',
+    datetime: 'Date',
+    date: 'Date',
+    id: 'number',
+    json: 'any',
+    array: 'any[]',
+    object: 'object',
+    enum: 'string'
+};
+/** Store-specific: YAML type to DB row TypeScript type (e.g. datetime -> string). */
+exports.ROW_TYPE_MAPPING = {
+    string: 'string',
+    number: 'number',
+    integer: 'number',
+    decimal: 'number',
+    boolean: 'boolean',
+    datetime: 'string',
+    date: 'string',
+    id: 'number',
+    json: 'string',
+    array: 'string',
+    object: 'string',
+    enum: 'string'
+};
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ */
+function mapType(yamlType, aggregates, valueObjects) {
+    var _a;
+    if (aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType))
+        return yamlType;
+    const capitalizedType = capitalize(yamlType);
+    if (valueObjects) {
+        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
+        if (has)
+            return capitalizedType;
+    }
+    return (_a = exports.TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'any';
+}
+/**
+ * Map a YAML type to the store row TypeScript type (value objects become string).
+ */
+function mapRowType(yamlType, valueObjects) {
+    var _a;
+    if (valueObjects) {
+        const capitalizedType = capitalize(yamlType);
+        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
+        if (has)
+            return 'string';
+    }
+    return (_a = exports.ROW_TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'string';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",
@@ -29,8 +29,12 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && npm run copy-templates",
     "copy-templates": "mkdir -p dist/generators/templates/data && cp src/generators/templates/data/* dist/generators/templates/data/",
-    "clean": "rm -rf dist",
-    "prepack": "npm run build"
+    "clean": "rm -rf dist dist-test",
+    "prepack": "npm run build",
+    "test:build": "tsc -p tsconfig.test.json && mkdir -p dist-test/src/generators/templates/data && cp src/generators/templates/data/* dist-test/src/generators/templates/data/",
+    "test": "npm run test:build && node --test dist-test/tests/unit/*.test.js",
+    "test:integration": "npm run test:build && node --test dist-test/tests/integration/*.test.js",
+    "test:all": "npm run test:build && node --test dist-test/tests/unit/*.test.js dist-test/tests/integration/*.test.js"
   },
   "engines": {
     "node": ">=18"