metal-orm 1.1.11 → 1.1.18

package/package.json

@@ -1,96 +1,100 @@
-{
-  "name": "metal-orm",
-  "version": "1.1.11",
-  "type": "module",
-  "types": "./dist/index.d.ts",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "bin": {
-    "metal-orm-gen": "./scripts/generate-entities.mjs"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "files": [
-    "dist",
-    "src",
-    "global.d.ts",
-    "scripts"
-  ],
-  "scripts": {
-    "prepublishOnly": "npm run build",
-    "build": "tsup",
-    "check": "tsc --noEmit",
-    "gen:entities": "node scripts/generate-entities.mjs",
-    "test": "vitest --run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:mysql": "vitest --run tests/e2e/mysql-memory.test.ts tests/e2e/decorators-mysql-memory.test.ts tests/e2e/save-graph-mysql-memory.test.ts",
-    "test:mysql:optimized": "vitest --run --config tests/e2e/mysql/vitest.config.ts",
-    "test:sqlite": "vitest --run tests/e2e/sqlite-memory.test.ts tests/e2e/decorators-sqlite-memory.test.ts tests/e2e/save-graph-sqlite-memory.test.ts",
-    "test:pglite": "vitest --run tests/e2e/pglite-memory.test.ts",
-    "test:e2e": "vitest --run tests/e2e",
-    "show-sql": "node scripts/show-sql.mjs",
-    "lint": "node scripts/run-eslint.mjs",
-    "lint:fix": "node scripts/run-eslint.mjs --fix"
-  },
-  "peerDependencies": {
-    "better-sqlite3": "^11.0.0",
-    "ioredis": "^5.0.0",
-    "keyv": "^5.6.0",
-    "mysql2": "^3.9.0",
-    "pg": "^8.0.0",
-    "sqlite3": "^5.1.6",
-    "tedious": "^19.0.0"
-  },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    },
-    "sqlite3": {
-      "optional": true
-    },
-    "tedious": {
-      "optional": true
-    },
-    "keyv": {
-      "optional": true
-    },
-    "ioredis": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@electric-sql/pglite": "^0.4.2",
-    "@typescript-eslint/eslint-plugin": "^8.58.0",
-    "@typescript-eslint/parser": "^8.58.0",
-    "@vitest/ui": "^4.1.2",
-    "better-sqlite3": "^12.8.0",
-    "eslint": "^10.1.0",
-    "express": "^5.2.1",
-    "ioredis": "^5.10.1",
-    "ioredis-mock": "^8.13.1",
-    "keyv": "^5.6.0",
-    "mysql-memory-server": "^1.14.1",
-    "mysql2": "^3.20.0",
-    "pg": "^8.20.0",
-    "sqlite3": "^6.0.1",
-    "supertest": "^7.2.2",
-    "tedious": "^19.2.1",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.2"
-  }
-}
+{
+  "name": "metal-orm",
+  "version": "1.1.18",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/celsowm/metal-orm"
+  },
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bin": {
+    "metal-orm-gen": "./scripts/generate-entities.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "global.d.ts",
+    "scripts"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsup",
+    "check": "tsc --noEmit -p tsconfig.check.json",
+    "gen:entities": "node scripts/generate-entities.mjs",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:mysql": "vitest --run tests/e2e/mysql-memory.test.ts tests/e2e/decorators-mysql-memory.test.ts tests/e2e/save-graph-mysql-memory.test.ts",
+    "test:mysql:optimized": "vitest --run --config tests/e2e/mysql/vitest.config.ts",
+    "test:sqlite": "vitest --run tests/e2e/sqlite-memory.test.ts tests/e2e/decorators-sqlite-memory.test.ts tests/e2e/save-graph-sqlite-memory.test.ts",
+    "test:pglite": "vitest --run tests/e2e/pglite-memory.test.ts",
+    "test:e2e": "vitest --run tests/e2e",
+    "show-sql": "node scripts/show-sql.mjs",
+    "lint": "node scripts/run-eslint.mjs",
+    "lint:fix": "node scripts/run-eslint.mjs --fix"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^12.11.1",
+    "ioredis": "^5.11.1",
+    "keyv": "^5.6.0",
+    "mysql2": "^3.22.5",
+    "pg": "^8.22.0",
+    "sqlite3": "^6.0.1",
+    "tedious": "^19.2.1"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    },
+    "tedious": {
+      "optional": true
+    },
+    "keyv": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.5.3",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
+    "@vitest/ui": "^4.1.9",
+    "better-sqlite3": "^12.11.1",
+    "eslint": "^10.6.0",
+    "express": "^5.2.1",
+    "ioredis": "^5.11.1",
+    "ioredis-mock": "^8.13.1",
+    "keyv": "^5.6.0",
+    "mysql-memory-server": "^1.14.1",
+    "mysql2": "^3.22.5",
+    "pg": "^8.22.0",
+    "sqlite3": "^6.0.1",
+    "supertest": "^7.2.2",
+    "tedious": "^19.2.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  }
+}

package/scripts/generate-entities/schema.mjs

@@ -26,9 +26,9 @@ export const mapRelations = (tables, naming) => {
         list.push(col);
         fkIndex.set(table.name, list);
       }
-    }
-
-    const uniqueCols = new Set();
+    }
+
+    const uniqueCols = new Set();
     if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
       uniqueCols.add(table.primaryKey[0]);
     }
@@ -37,16 +37,16 @@ export const mapRelations = (tables, naming) => {
     }
     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);
+      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 => {
@@ -64,81 +64,81 @@ export const mapRelations = (tables, naming) => {
       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
-          });
-        }
-      }
-    }
+      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 normalizedTables) {
     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
-        });
-      }
-
-      // Skip generating HasMany/HasOne relations TO pivot tables
-      // (pivot data is accessible via _pivot on BelongsToMany)
-      if (pivotTables.has(table.name)) continue;
-
-      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;
-};
-
+      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
+        });
+      }
+
+      // Skip generating HasMany/HasOne relations TO pivot tables
+      // (pivot data is accessible via _pivot on BelongsToMany)
+      if (pivotTables.has(table.name)) continue;
+
+      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 = normalizeTables(schema?.tables)
     .filter(t => t && typeof t.name === 'string' && t.name.trim().length > 0)
@@ -177,42 +177,42 @@ export const buildSchemaMetadata = (schema, naming) => {
       definition: v.definition,
       comment: v.comment
     }));
-
-  const allEntities = [...tables, ...views];
-
-  const classNames = new Map();
-  allEntities.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);
-  
-  // Detect tree tables
-  const treeConfigs = mapTreeTables(tables, naming);
-
-  return {
-    tables,
-    views,
-    classNames,
-    relations,
-    resolveClassName,
-    treeConfigs
-  };
-};
+
+  const allEntities = [...tables, ...views];
+
+  const classNames = new Map();
+  allEntities.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);
+  
+  // Detect tree tables
+  const treeConfigs = mapTreeTables(tables, naming);
+
+  return {
+    tables,
+    views,
+    classNames,
+    relations,
+    resolveClassName,
+    treeConfigs
+  };
+};