metal-orm 1.0.47 → 1.0.49

package/scripts/generate-entities/render.mjs

@@ -0,0 +1,442 @@
+import path from 'node:path';
+import { createNamingStrategy } from '../naming-strategy.mjs';
+import { buildSchemaMetadata } from './schema.mjs';
+
+const escapeJsString = value => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+
+const parseColumnType = colTypeRaw => {
+  const type = (colTypeRaw || '').toLowerCase();
+  const lengthMatch = type.match(/\((\d+)(?:\s*,\s*(\d+))?\)/);
+  const length = lengthMatch ? Number(lengthMatch[1]) : undefined;
+  const scale = lengthMatch && lengthMatch[2] ? Number(lengthMatch[2]) : undefined;
+
+  const base = type.replace(/\(.*\)/, '');
+
+  if (base === 'bit') return { factory: 'col.boolean()', ts: 'boolean' };
+  if (base.includes('bigint')) return { factory: 'col.bigint()', ts: 'number' };
+  if (base.includes('int')) return { factory: 'col.int()', ts: 'number' };
+  if (base.includes('uuid') || base.includes('uniqueidentifier')) return { factory: 'col.uuid()', ts: 'string' };
+  if (base === 'date') return { factory: 'col.date<Date>()', ts: 'Date' };
+  if (base.includes('datetime') || base === 'time') return { factory: 'col.datetime<Date>()', ts: 'Date' };
+  if (base.includes('char') || base.includes('text')) {
+    const lenArg = length ? `${length}` : '255';
+    return { factory: `col.varchar(${lenArg})`, ts: 'string' };
+  }
+  if (base.includes('json')) return { factory: 'col.json()', ts: 'any' };
+  if (base.includes('bool') || (base.includes('tinyint') && length === 1)) {
+    return { factory: 'col.boolean()', ts: 'boolean' };
+  }
+  if (base.includes('date') || base.includes('time')) return { factory: 'col.datetime<Date>()', ts: 'Date' };
+  if (base.includes('decimal') || base.includes('numeric')) {
+    const precision = length ?? 10;
+    const scaleVal = scale ?? 0;
+    return { factory: `col.decimal(${precision}, ${scaleVal})`, ts: 'number' };
+  }
+  if (base.includes('double')) return { factory: 'col.float()', ts: 'number' };
+  if (base.includes('float') || base.includes('real')) return { factory: 'col.float()', ts: 'number' };
+  if (base.includes('blob') || base.includes('binary') || base.includes('bytea')) {
+    return { factory: 'col.blob()', ts: 'Buffer' };
+  }
+
+  return { factory: `col.varchar(255) /* TODO: review type ${colTypeRaw} */`, ts: 'any' };
+};
+
+const normalizeDefault = value => {
+  if (value === undefined) return undefined;
+  if (value === null) return { kind: 'value', code: 'null' };
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return { kind: 'value', code: JSON.stringify(value) };
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (/^[-]?\d+(\.\d+)?$/.test(trimmed)) return { kind: 'value', code: trimmed };
+    if (/^(true|false)$/i.test(trimmed)) return { kind: 'value', code: trimmed.toLowerCase() };
+    if (/^null$/i.test(trimmed)) return { kind: 'value', code: 'null' };
+    if (/current_|now\(\)|uuid_generate_v4|uuid\(\)/i.test(trimmed) || trimmed.includes('(')) {
+      return { kind: 'raw', code: `'${escapeJsString(trimmed)}'` };
+    }
+    if (/^'.*'$/.test(trimmed) || /^".*"$/.test(trimmed)) {
+      const unquoted = trimmed.slice(1, -1);
+      return { kind: 'value', code: `'${escapeJsString(unquoted)}'` };
+    }
+    return { kind: 'raw', code: `'${escapeJsString(trimmed)}'` };
+  }
+  return { kind: 'value', code: JSON.stringify(value) };
+};
+
+const renderColumnExpression = (column, tablePk) => {
+  const base = parseColumnType(column.type);
+  let expr = base.factory;
+
+  if (column.autoIncrement) {
+    expr = `col.autoIncrement(${expr})`;
+  }
+  if (column.notNull) {
+    expr = `col.notNull(${expr})`;
+  }
+  if (column.unique) {
+    const name = typeof column.unique === 'string' ? `, '${escapeJsString(column.unique)}'` : '';
+    expr = `col.unique(${expr}${name})`;
+  }
+  if (column.default !== undefined) {
+    const def = normalizeDefault(column.default);
+    if (def) {
+      expr =
+        def.kind === 'raw'
+          ? `col.defaultRaw(${expr}, ${def.code})`
+          : `col.default(${expr}, ${def.code})`;
+    }
+  }
+  if (column.references) {
+    const refParts = [
+      `table: '${escapeJsString(column.references.table)}'`,
+      `column: '${escapeJsString(column.references.column)}'`
+    ];
+    if (column.references.onDelete) refParts.push(`onDelete: '${escapeJsString(column.references.onDelete)}'`);
+    if (column.references.onUpdate) refParts.push(`onUpdate: '${escapeJsString(column.references.onUpdate)}'`);
+    expr = `col.references(${expr}, { ${refParts.join(', ')} })`;
+  }
+
+  const isPrimary = Array.isArray(tablePk) && tablePk.includes(column.name);
+  const decorator = isPrimary ? 'PrimaryKey' : 'Column';
+  const tsType = base.ts || 'any';
+  const optional = !column.notNull;
+
+  return {
+    decorator,
+    expr,
+    tsType,
+    optional
+  };
+};
+
+const METAL_ORM_IMPORT_ORDER = [
+  'col',
+  'Entity',
+  'Column',
+  'PrimaryKey',
+  'HasMany',
+  'HasOne',
+  'BelongsTo',
+  'BelongsToMany',
+  'HasManyCollection',
+  'HasOneReference',
+  'ManyToManyCollection',
+  'bootstrapEntities',
+  'getTableDefFromEntity'
+];
+
+const renderEntityClassLines = ({ table, className, naming, relations, resolveClassName }) => {
+  const lines = [];
+  const derivedDefault = naming.defaultTableNameFromClass(className);
+  const needsTableNameOption = table.name !== derivedDefault;
+  const entityOpts = needsTableNameOption ? `{ tableName: '${escapeJsString(table.name)}' }` : '';
+  lines.push(`@Entity(${entityOpts})`);
+  lines.push(`export class ${className} {`);
+
+  for (const col of table.columns) {
+    const rendered = renderColumnExpression(col, table.primaryKey);
+    lines.push(`  @${rendered.decorator}(${rendered.expr})`);
+    lines.push(`  ${col.name}${rendered.optional ? '?:' : '!:'} ${rendered.tsType};`);
+    lines.push('');
+  }
+
+  for (const rel of relations) {
+    const targetClass = resolveClassName(rel.target);
+    if (!targetClass) continue;
+    switch (rel.kind) {
+      case 'belongsTo':
+        lines.push(
+          `  @BelongsTo({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
+        );
+        lines.push(`  ${rel.property}?: ${targetClass};`);
+        lines.push('');
+        break;
+      case 'hasMany':
+        lines.push(
+          `  @HasMany({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
+        );
+        lines.push(`  ${rel.property}!: HasManyCollection<${targetClass}>;`);
+        lines.push('');
+        break;
+      case 'hasOne':
+        lines.push(
+          `  @HasOne({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
+        );
+        lines.push(`  ${rel.property}!: HasOneReference<${targetClass}>;`);
+        lines.push('');
+        break;
+      case 'belongsToMany': {
+        const pivotClass = resolveClassName(rel.pivotTable);
+        if (!pivotClass) break;
+        lines.push(
+          `  @BelongsToMany({ target: () => ${targetClass}, pivotTable: () => ${pivotClass}, pivotForeignKeyToRoot: '${escapeJsString(
+            rel.pivotForeignKeyToRoot
+          )}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
+        );
+        lines.push(`  ${rel.property}!: ManyToManyCollection<${targetClass}>;`);
+        lines.push('');
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  lines.push('}');
+  lines.push('');
+  return lines;
+};
+
+const computeTableUsage = (table, relations) => {
+  const usage = {
+    needsCol: false,
+    needsEntity: true,
+    needsColumnDecorator: false,
+    needsPrimaryKeyDecorator: false,
+    needsHasManyDecorator: false,
+    needsHasOneDecorator: false,
+    needsBelongsToDecorator: false,
+    needsBelongsToManyDecorator: false,
+    needsHasManyCollection: false,
+    needsHasOneReference: false,
+    needsManyToManyCollection: false
+  };
+
+  for (const col of table.columns) {
+    usage.needsCol = true;
+    const rendered = renderColumnExpression(col, table.primaryKey);
+    if (rendered.decorator === 'PrimaryKey') {
+      usage.needsPrimaryKeyDecorator = true;
+    } else {
+      usage.needsColumnDecorator = true;
+    }
+  }
+
+  for (const rel of relations) {
+    if (rel.kind === 'hasMany') {
+      usage.needsHasManyDecorator = true;
+      usage.needsHasManyCollection = true;
+    }
+    if (rel.kind === 'hasOne') {
+      usage.needsHasOneDecorator = true;
+      usage.needsHasOneReference = true;
+    }
+    if (rel.kind === 'belongsTo') {
+      usage.needsBelongsToDecorator = true;
+    }
+    if (rel.kind === 'belongsToMany') {
+      usage.needsBelongsToManyDecorator = true;
+      usage.needsManyToManyCollection = true;
+    }
+  }
+
+  return usage;
+};
+
+const getMetalOrmImportNamesFromUsage = usage => {
+  const names = new Set();
+  if (usage.needsCol) names.add('col');
+  if (usage.needsEntity) names.add('Entity');
+  if (usage.needsColumnDecorator) names.add('Column');
+  if (usage.needsPrimaryKeyDecorator) names.add('PrimaryKey');
+  if (usage.needsHasManyDecorator) names.add('HasMany');
+  if (usage.needsHasOneDecorator) names.add('HasOne');
+  if (usage.needsBelongsToDecorator) names.add('BelongsTo');
+  if (usage.needsBelongsToManyDecorator) names.add('BelongsToMany');
+  if (usage.needsHasManyCollection) names.add('HasManyCollection');
+  if (usage.needsHasOneReference) names.add('HasOneReference');
+  if (usage.needsManyToManyCollection) names.add('ManyToManyCollection');
+  return names;
+};
+
+const buildMetalOrmImportStatement = names => {
+  if (!names || names.size === 0) return '';
+  const ordered = METAL_ORM_IMPORT_ORDER.filter(name => names.has(name));
+  if (!ordered.length) return '';
+  return `import { ${ordered.join(', ')} } from 'metal-orm';`;
+};
+
+const getRelativeModuleSpecifier = (from, to) => {
+  const rel = path.relative(path.dirname(from), to).replace(/\\/g, '/');
+  if (!rel) return './';
+  const withoutExt = rel.replace(/\.ts$/i, '');
+  return withoutExt.startsWith('.') ? withoutExt : `./${withoutExt}`;
+};
+
+export const renderEntityFile = (schema, options) => {
+  const naming = options.naming || createNamingStrategy('en');
+  const metadata = buildSchemaMetadata(schema, naming);
+  const { tables, relations } = metadata;
+
+  const aggregateUsage = {
+    needsCol: false,
+    needsEntity: tables.length > 0,
+    needsColumnDecorator: false,
+    needsPrimaryKeyDecorator: false,
+    needsHasManyDecorator: false,
+    needsHasOneDecorator: false,
+    needsBelongsToDecorator: false,
+    needsBelongsToManyDecorator: false,
+    needsHasManyCollection: false,
+    needsHasOneReference: false,
+    needsManyToManyCollection: false
+  };
+
+  for (const table of tables) {
+    const rels = relations.get(table.name) || [];
+    const tableUsage = computeTableUsage(table, rels);
+    aggregateUsage.needsCol ||= tableUsage.needsCol;
+    aggregateUsage.needsColumnDecorator ||= tableUsage.needsColumnDecorator;
+    aggregateUsage.needsPrimaryKeyDecorator ||= tableUsage.needsPrimaryKeyDecorator;
+    aggregateUsage.needsHasManyDecorator ||= tableUsage.needsHasManyDecorator;
+    aggregateUsage.needsHasOneDecorator ||= tableUsage.needsHasOneDecorator;
+    aggregateUsage.needsBelongsToDecorator ||= tableUsage.needsBelongsToDecorator;
+    aggregateUsage.needsBelongsToManyDecorator ||= tableUsage.needsBelongsToManyDecorator;
+    aggregateUsage.needsHasManyCollection ||= tableUsage.needsHasManyCollection;
+    aggregateUsage.needsHasOneReference ||= tableUsage.needsHasOneReference;
+    aggregateUsage.needsManyToManyCollection ||= tableUsage.needsManyToManyCollection;
+  }
+
+  const importNames = getMetalOrmImportNamesFromUsage(aggregateUsage);
+  importNames.add('bootstrapEntities');
+  importNames.add('getTableDefFromEntity');
+  const importStatement = buildMetalOrmImportStatement(importNames);
+
+  const lines = [
+    '// AUTO-GENERATED by scripts/generate-entities.mjs',
+    '// Regenerate after schema changes.'
+  ];
+  if (importStatement) {
+    lines.push(importStatement, '');
+  }
+
+  for (const table of tables) {
+    const className = metadata.classNames.get(table.name);
+    const classLines = renderEntityClassLines({
+      table,
+      className,
+      naming,
+      relations: relations.get(table.name) || [],
+      resolveClassName: metadata.resolveClassName
+    });
+    lines.push(...classLines);
+  }
+
+  lines.push(
+    'export const bootstrapEntityTables = () => {',
+    '  const tables = bootstrapEntities();',
+    '  return {',
+    ...tables.map(t => `    ${metadata.classNames.get(t.name)}: getTableDefFromEntity(${metadata.classNames.get(t.name)})!,`),
+    '  };',
+    '};',
+    '',
+    'export const allTables = () => bootstrapEntities();'
+  );
+
+  return lines.join('\n');
+};
+
+export const renderSplitEntityFiles = (schema, options) => {
+  const naming = options.naming || createNamingStrategy('en');
+  const metadata = buildSchemaMetadata(schema, naming);
+  const tableFiles = [];
+
+  for (const table of metadata.tables) {
+    const className = metadata.classNames.get(table.name);
+    const relations = metadata.relations.get(table.name) || [];
+    const usage = computeTableUsage(table, relations);
+    const metalImportNames = getMetalOrmImportNamesFromUsage(usage);
+    const metalImportStatement = buildMetalOrmImportStatement(metalImportNames);
+
+    const relationImports = new Set();
+    for (const rel of relations) {
+      const targetClass = metadata.resolveClassName(rel.target);
+      if (targetClass && targetClass !== className) {
+        relationImports.add(targetClass);
+      }
+      if (rel.kind === 'belongsToMany') {
+        const pivotClass = metadata.resolveClassName(rel.pivotTable);
+        if (pivotClass && pivotClass !== className) {
+          relationImports.add(pivotClass);
+        }
+      }
+    }
+
+    const importLines = [];
+    if (metalImportStatement) {
+      importLines.push(metalImportStatement);
+    }
+    for (const targetClass of Array.from(relationImports).sort()) {
+      importLines.push(`import { ${targetClass} } from './${targetClass}';`);
+    }
+
+    const lines = [
+      '// AUTO-GENERATED by scripts/generate-entities.mjs',
+      '// Regenerate after schema changes.'
+    ];
+    if (importLines.length) {
+      lines.push(...importLines, '');
+    }
+
+    const classLines = renderEntityClassLines({
+      table,
+      className,
+      naming,
+      relations,
+      resolveClassName: metadata.resolveClassName
+    });
+    lines.push(...classLines);
+
+    tableFiles.push({
+      path: path.join(options.outDir, `${className}.ts`),
+      code: lines.join('\n')
+    });
+  }
+
+  return { tableFiles, metadata };
+};
+
+export const renderSplitIndexFile = (metadata, options) => {
+  const importLines = ["import { bootstrapEntities, getTableDefFromEntity } from 'metal-orm';"];
+
+  const exportedClasses = [];
+  for (const table of metadata.tables) {
+    const className = metadata.classNames.get(table.name);
+    const filePath = path.join(options.outDir, `${className}.ts`);
+    const moduleSpecifier = getRelativeModuleSpecifier(options.out, filePath);
+    importLines.push(`import { ${className} } from '${moduleSpecifier}';`);
+    exportedClasses.push(className);
+  }
+
+  const lines = [
+    '// AUTO-GENERATED by scripts/generate-entities.mjs',
+    '// Regenerate after schema changes.',
+    ...importLines,
+    ''
+  ];
+
+  if (exportedClasses.length) {
+    lines.push('export {');
+    for (const className of exportedClasses) {
+      lines.push(`  ${className},`);
+    }
+    lines.push('};', '');
+  }
+
+  lines.push(
+    'export const bootstrapEntityTables = () => {',
+    '  const tables = bootstrapEntities();',
+    '  return {',
+    ...metadata.tables.map(
+      t =>
+        `    ${metadata.classNames.get(t.name)}: getTableDefFromEntity(${metadata.classNames.get(t.name)})!,`
+    ),
+    '  };',
+    '};',
+    '',
+    'export const allTables = () => bootstrapEntities();'
+  );
+
+  return lines.join('\n');
+};

package/scripts/generate-entities/schema.mjs

@@ -0,0 +1,178 @@
+const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
+
+export const mapRelations = (tables, naming) => {
+  const relationMap = new Map();
+  const relationKeys = new Map();
+  const fkIndex = new Map();
+  const uniqueSingleColumns = new Map();
+
+  for (const table of tables) {
+    relationMap.set(table.name, []);
+    relationKeys.set(table.name, new Set());
+    for (const col of table.columns) {
+      if (col.references) {
+        const list = fkIndex.get(table.name) || [];
+        list.push(col);
+        fkIndex.set(table.name, list);
+      }
+    }
+
+    const uniqueCols = new Set();
+    if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
+      uniqueCols.add(table.primaryKey[0]);
+    }
+    for (const col of table.columns) {
+      if (col.unique) uniqueCols.add(col.name);
+    }
+    for (const idx of table.indexes || []) {
+      if (!idx?.unique) continue;
+      if (!Array.isArray(idx.columns) || idx.columns.length !== 1 || !idx.columns[0]?.column) continue;
+      const columnName = idx.columns[0].column;
+      if (idx.where) {
+        const predicate = String(idx.where);
+        const isNotNullOnly = new RegExp(`\\b${columnName}\\b\\s+is\\s+not\\s+null\\b`, 'i').test(predicate);
+        if (!isNotNullOnly) continue;
+      }
+      uniqueCols.add(columnName);
+    }
+    uniqueSingleColumns.set(table.name, uniqueCols);
+  }
+
+  const findTable = name => {
+    const norm = normalizeName(name);
+    return tables.find(t => t.name === name || t.name === norm);
+  };
+
+  const pivotTables = new Set();
+  for (const table of tables) {
+    const fkCols = fkIndex.get(table.name) || [];
+    const distinctTargets = Array.from(new Set(fkCols.map(c => normalizeName(c.references.table))));
+    if (fkCols.length === 2 && distinctTargets.length === 2) {
+      const [a, b] = fkCols;
+      pivotTables.add(table.name);
+      const targetA = findTable(a.references.table);
+      const targetB = findTable(b.references.table);
+      if (targetA && targetB) {
+        const aKey = relationKeys.get(targetA.name);
+        const bKey = relationKeys.get(targetB.name);
+        const aProp = naming.belongsToManyProperty(targetB.name);
+        const bProp = naming.belongsToManyProperty(targetA.name);
+        if (!aKey.has(aProp)) {
+          aKey.add(aProp);
+          relationMap.get(targetA.name)?.push({
+            kind: 'belongsToMany',
+            property: aProp,
+            target: targetB.name,
+            pivotTable: table.name,
+            pivotForeignKeyToRoot: a.name,
+            pivotForeignKeyToTarget: b.name
+          });
+        }
+        if (!bKey.has(bProp)) {
+          bKey.add(bProp);
+          relationMap.get(targetB.name)?.push({
+            kind: 'belongsToMany',
+            property: bProp,
+            target: targetA.name,
+            pivotTable: table.name,
+            pivotForeignKeyToRoot: b.name,
+            pivotForeignKeyToTarget: a.name
+          });
+        }
+      }
+    }
+  }
+
+  for (const table of tables) {
+    const fkCols = fkIndex.get(table.name) || [];
+    for (const fk of fkCols) {
+      const targetTable = fk.references.table;
+      const targetKey = normalizeName(targetTable);
+      const belongsKey = relationKeys.get(table.name);
+      const hasManyKey = targetKey ? relationKeys.get(targetKey) : undefined;
+
+      if (!belongsKey || !hasManyKey) continue;
+
+      const belongsProp = naming.belongsToProperty(fk.name, targetTable);
+      if (!belongsKey.has(belongsProp)) {
+        belongsKey.add(belongsProp);
+        relationMap.get(table.name)?.push({
+          kind: 'belongsTo',
+          property: belongsProp,
+          target: targetTable,
+          foreignKey: fk.name
+        });
+      }
+
+      const uniqueCols = uniqueSingleColumns.get(table.name);
+      const isHasOne = Boolean(uniqueCols?.has(fk.name));
+      const relationKind = isHasOne ? 'hasOne' : 'hasMany';
+      const inverseProp = isHasOne ? naming.hasOneProperty(table.name) : naming.hasManyProperty(table.name);
+      if (!hasManyKey.has(inverseProp)) {
+        hasManyKey.add(inverseProp);
+        relationMap.get(targetKey)?.push({
+          kind: relationKind,
+          property: inverseProp,
+          target: table.name,
+          foreignKey: fk.name
+        });
+      }
+    }
+  }
+
+  return relationMap;
+};
+
+export const buildSchemaMetadata = (schema, naming) => {
+  const tables = schema.tables.map(t => {
+    const indexes = Array.isArray(t.indexes) ? t.indexes.map(idx => ({ ...idx })) : [];
+    const uniqueSingleColumns = new Set(
+      indexes
+        .filter(idx => idx?.unique && !idx?.where && Array.isArray(idx.columns) && idx.columns.length === 1)
+        .map(idx => idx.columns[0]?.column)
+        .filter(Boolean)
+    );
+
+    return {
+      name: t.name,
+      schema: t.schema,
+      columns: (t.columns || []).map(col => {
+        const unique = col.unique !== undefined ? col.unique : uniqueSingleColumns.has(col.name) ? true : undefined;
+        return { ...col, unique };
+      }),
+      primaryKey: t.primaryKey || [],
+      indexes
+    };
+  });
+
+  const classNames = new Map();
+  tables.forEach(t => {
+    const className = naming.classNameFromTable(t.name);
+    classNames.set(t.name, className);
+    if (t.schema) {
+      const qualified = `${t.schema}.${t.name}`;
+      if (!classNames.has(qualified)) {
+        classNames.set(qualified, className);
+      }
+    }
+  });
+
+  const resolveClassName = target => {
+    if (!target) return undefined;
+    if (classNames.has(target)) return classNames.get(target);
+    const fallback = target.split('.').pop();
+    if (fallback && classNames.has(fallback)) {
+      return classNames.get(fallback);
+    }
+    return undefined;
+  };
+
+  const relations = mapRelations(tables, naming);
+
+  return {
+    tables,
+    classNames,
+    relations,
+    resolveClassName
+  };
+};