metal-orm 1.0.101 → 1.0.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.101",
+  "version": "1.0.103",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/scripts/generate-entities/cli.mjs

@@ -188,7 +188,7 @@ Flags:
   --include=tbl1,tbl2   Only include these tables
   --exclude=tbl3,tbl4   Exclude these tables
   --locale=pt-BR        Naming locale for class/relation names (default: en)
-  --naming-overrides    Path to JSON map of irregular plurals { "singular": "plural" }
+  --naming-overrides    Path to JSON config for naming customizations (see docs)
   --dry-run             Print to stdout instead of writing a file
   --out=<file>          Override the generated file (defaults to generated-entities.ts or the index inside --out-dir)
   --out-dir=<dir>       Emit one file per entity inside this directory plus the shared index

package/scripts/generate-entities/generate.mjs

@@ -5,7 +5,7 @@ import { loadDriver } from './drivers.mjs';
 import { renderEntityFile, renderSplitEntityFiles, renderSplitIndexFile } from './render.mjs';
 import { printDryRun, writeSingleFile, writeSplitFiles } from './emit.mjs';
 
-const loadIrregulars = async (filePath, fsPromises) => {
+const loadNamingOverrides = async (filePath, fsPromises) => {
   const raw = await fsPromises.readFile(filePath, 'utf8');
   let parsed;
   try {
@@ -13,22 +13,31 @@ const loadIrregulars = async (filePath, fsPromises) => {
   } catch (err) {
     throw new Error(`Failed to parse naming overrides at ${filePath}: ${err.message || err}`);
   }
-  const irregulars =
-    parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? parsed.irregulars && typeof parsed.irregulars === 'object' && !Array.isArray(parsed.irregulars)
-        ? parsed.irregulars
-        : parsed
-      : undefined;
-  if (!irregulars) {
-    throw new Error(`Naming overrides at ${filePath} must be an object or { "irregulars": { ... } }`);
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Naming overrides at ${filePath} must be an object`);
   }
-  return irregulars;
+
+  // Support both flat format { "singular": "plural" } and structured { irregulars: {...}, relationOverrides: {...} }
+  const hasStructuredFormat = parsed.irregulars || parsed.relationOverrides;
+
+  const irregulars = hasStructuredFormat
+    ? (parsed.irregulars && typeof parsed.irregulars === 'object' ? parsed.irregulars : {})
+    : parsed;
+
+  const relationOverrides = hasStructuredFormat && parsed.relationOverrides && typeof parsed.relationOverrides === 'object'
+    ? parsed.relationOverrides
+    : {};
+
+  return { irregulars, relationOverrides };
 };
 
 export const generateEntities = async (opts, context = {}) => {
   const { fs: fsPromises = fs, logger = console } = context;
-  const irregulars = opts.namingOverrides ? await loadIrregulars(opts.namingOverrides, fsPromises) : undefined;
-  const naming = createNamingStrategy(opts.locale, irregulars);
+  const { irregulars, relationOverrides } = opts.namingOverrides
+    ? await loadNamingOverrides(opts.namingOverrides, fsPromises)
+    : { irregulars: undefined, relationOverrides: {} };
+  const naming = createNamingStrategy(opts.locale, irregulars, relationOverrides);
 
   const { executor, cleanup } = await loadDriver(opts.dialect, opts.url, opts.dbPath);
   let schema;

package/scripts/generate-entities/render.mjs

@@ -259,26 +259,27 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
   for (const rel of relations) {
     const targetClass = resolveClassName(rel.target);
     if (!targetClass) continue;
+    const propName = naming.applyRelationOverride(className, rel.property);
     switch (rel.kind) {
       case 'belongsTo':
         lines.push(
           `  @BelongsTo({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
         );
-        lines.push(`  ${rel.property}!: BelongsToReference<${targetClass}>;`);
+        lines.push(`  ${propName}!: BelongsToReference<${targetClass}>;`);
         lines.push('');
         break;
       case 'hasMany':
         lines.push(
           `  @HasMany({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
         );
-        lines.push(`  ${rel.property}!: HasManyCollection<${targetClass}>;`);
+        lines.push(`  ${propName}!: HasManyCollection<${targetClass}>;`);
         lines.push('');
         break;
       case 'hasOne':
         lines.push(
           `  @HasOne({ target: () => ${targetClass}, foreignKey: '${escapeJsString(rel.foreignKey)}' })`
         );
-        lines.push(`  ${rel.property}!: HasOneReference<${targetClass}>;`);
+        lines.push(`  ${propName}!: HasOneReference<${targetClass}>;`);
         lines.push('');
         break;
       case 'belongsToMany': {
@@ -289,7 +290,7 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
             rel.pivotForeignKeyToRoot
           )}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
         );
-        lines.push(`  ${rel.property}!: ManyToManyCollection<${targetClass}>;`);
+        lines.push(`  ${propName}!: ManyToManyCollection<${targetClass}>;`);
         lines.push('');
         break;
       }