metal-orm 1.1.3 → 1.1.5

package/package.json

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

package/scripts/generate-entities/render.mjs

@@ -277,6 +277,8 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
   lines.push(`@Entity(${entityOpts})`);
   lines.push(`export class ${className} {`);
 
+  const columnPropertyNames = new Set(table.columns.map(col => sanitizePropertyName(col.name)));
+
   for (const col of table.columns) {
     const propertyName = sanitizePropertyName(col.name);
     const rendered = renderColumnExpression(col, table.primaryKey, table.schema, defaultSchema, propertyName);
@@ -298,10 +300,31 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
   const isSelfRefHasMany = (rel) =>
     treeConfig && rel.kind === 'hasMany' && rel.foreignKey === treeParentFK && isSelfRef(rel.target);
 
+  // Track used relation property names to avoid duplicates among relations themselves
+  const usedRelationProps = new Set();
+
   for (const rel of relations) {
     const targetClass = resolveClassName(rel.target);
     if (!targetClass) continue;
-    const propName = naming.applyRelationOverride(className, rel.property);
+    let propName = naming.applyRelationOverride(className, rel.property);
+
+    // If the generated property name conflicts with a column property, fall back to
+    // using the camelCased target class name. This happens when a FK column has no
+    // "_id" suffix (e.g. "instancia", "criador") so the naming strategy derives the
+    // same name for both the column and the relation.
+    if (columnPropertyNames.has(propName)) {
+      const fallback = naming.toCamelCase(
+        naming.singularize(naming.normalizeTableName(rel.target))
+      );
+      propName = fallback;
+    }
+
+    // Resolve any remaining duplicate among relation properties by appending the FK name
+    if (usedRelationProps.has(propName)) {
+      propName = `${propName}_${naming.toCamelCase(rel.foreignKey)}`;
+    }
+    usedRelationProps.add(propName);
+
     switch (rel.kind) {
       case 'belongsTo':
         // For tree tables, replace @BelongsTo for parent with @TreeParent

package/scripts/naming-strategy.mjs

@@ -95,10 +95,25 @@ export class BaseNamingStrategy {
 
   belongsToProperty(foreignKeyName, targetTable) {
     const trimmed = foreignKeyName.replace(/_?id$/i, '');
-    const base = trimmed && trimmed !== foreignKeyName ? trimmed : this.singularize(targetTable);
+    const targetBase = this.singularize(this.normalizeTableName(targetTable));
+    // If FK name ends with _id, use the trimmed version
+    // If FK name doesn't end with _id but is different from target table name, use the FK name (e.g., "criador", "responsavel_judicial")
+    // Otherwise fallback to target table name
+    const base = trimmed && trimmed !== foreignKeyName
+      ? trimmed
+      : trimmed && this.toCamelCase(trimmed) !== this.toCamelCase(targetBase)
+        ? trimmed
+        : targetBase;
     return this.toCamelCase(base);
   }
 
+  normalizeTableName(tableName) {
+    // Strip schema prefix if present (e.g., "dbo.usuario" -> "usuario")
+    return typeof tableName === 'string' && tableName.includes('.')
+      ? tableName.split('.').pop()
+      : tableName;
+  }
+
   hasManyProperty(targetTable) {
     const base = this.singularize(targetTable);
     const plural = this.inflector.pluralizeRelationProperty

package/src/core/ast/procedure.ts

@@ -0,0 +1,21 @@
+import type { OperandNode } from './expression.js';
+
+export type ProcedureDirection = 'in' | 'out' | 'inout';
+
+export interface ProcedureRefNode {
+  name: string;
+  schema?: string;
+}
+
+export interface ProcedureParamNode {
+  name: string;
+  direction: ProcedureDirection;
+  value?: OperandNode;
+  dbType?: string;
+}
+
+export interface ProcedureCallNode {
+  type: 'ProcedureCall';
+  ref: ProcedureRefNode;
+  params: ProcedureParamNode[];
+}

package/src/core/ast/query.ts

@@ -161,25 +161,53 @@ export interface InsertValuesSourceNode {
   rows: OperandNode[][];
 }
 
-export interface InsertSelectSourceNode {
-  type: 'InsertSelect';
-  /** SELECT query providing rows */
-  query: SelectQueryNode;
-}
-
-export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
-
-export interface InsertQueryNode {
-  type: 'InsertQuery';
-  /** Target table */
-  into: TableNode;
-  /** Column order for inserted values */
-  columns: ColumnNode[];
-  /** Source of inserted rows (either literal values or a SELECT query) */
-  source: InsertSourceNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
+export interface InsertSelectSourceNode {
+  type: 'InsertSelect';
+  /** SELECT query providing rows */
+  query: SelectQueryNode;
+}
+
+export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
+
+export interface UpsertConflictTarget {
+  /** Conflict columns (primary key or unique columns) */
+  columns: ColumnNode[];
+  /** Named constraint (PostgreSQL only) */
+  constraint?: string;
+}
+
+export interface UpsertUpdateAction {
+  type: 'DoUpdate';
+  /** Assignments to apply on conflict */
+  set: UpdateAssignmentNode[];
+  /** Optional condition for the update branch */
+  where?: ExpressionNode;
+}
+
+export interface UpsertDoNothingAction {
+  type: 'DoNothing';
+}
+
+export type UpsertAction = UpsertUpdateAction | UpsertDoNothingAction;
+
+export interface UpsertClause {
+  target: UpsertConflictTarget;
+  action: UpsertAction;
+}
+
+export interface InsertQueryNode {
+  type: 'InsertQuery';
+  /** Target table */
+  into: TableNode;
+  /** Column order for inserted values */
+  columns: ColumnNode[];
+  /** Source of inserted rows (either literal values or a SELECT query) */
+  source: InsertSourceNode;
+  /** Optional dialect-specific UPSERT clause */
+  onConflict?: UpsertClause;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}
 
 export interface UpdateAssignmentNode {
   /** Column to update */

package/src/core/ddl/introspect/utils.ts

@@ -1,56 +1,56 @@
-import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
-import { IntrospectOptions } from './types.js';
-
-/**
- * Converts a query result to an array of row objects.
- * @param result - The query result.
- * @returns The array of rows.
- */
-export const toRows = (result: QueryResult | undefined): Record<string, unknown>[] => {
-  if (!result) return [];
-  return result.values.map(row =>
-    result.columns.reduce<Record<string, unknown>>((acc, col, idx) => {
-      acc[col] = row[idx];
-      return acc;
-    }, {})
-  );
-};
-
-/**
- * Executes a SQL query and returns the rows.
- * @param executor - The database executor.
- * @param sql - The SQL query.
- * @param params - The query parameters.
- * @returns The array of rows.
- */
-export const queryRows = async (
-  executor: DbExecutor,
-  sql: string,
-  params: unknown[] = []
-): Promise<Record<string, unknown>[]> => {
-  const [first] = await executor.executeSql(sql, params);
-  return toRows(first);
-};
-
-/**
- * Checks if a table should be included in introspection based on options.
- * @param name - The table name.
- * @param options - The introspection options.
- * @returns True if the table should be included.
- */
-export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
-  if (options.includeTables && !options.includeTables.includes(name)) return false;
-  if (options.excludeTables && options.excludeTables.includes(name)) return false;
-  return true;
-};
-
-/**
- * Checks if a view should be included in introspection based on options.
- * @param name - The view name.
- * @param options - The introspection options.
- * @returns True if the view should be included.
- */
-export const shouldIncludeView = (name: string, options: IntrospectOptions): boolean => {
-  if (options.excludeViews && options.excludeViews.includes(name)) return false;
-  return true;
-};
+import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
+import { IntrospectOptions } from './types.js';
+
+/**
+ * Converts a query result to an array of row objects.
+ * @param result - The query result.
+ * @returns The array of rows.
+ */
+export const toRows = (result: QueryResult | undefined): Record<string, unknown>[] => {
+  if (!result) return [];
+  return result.values.map(row =>
+    result.columns.reduce<Record<string, unknown>>((acc, col, idx) => {
+      acc[col] = row[idx];
+      return acc;
+    }, {})
+  );
+};
+
+/**
+ * Executes a SQL query and returns the rows.
+ * @param executor - The database executor.
+ * @param sql - The SQL query.
+ * @param params - The query parameters.
+ * @returns The array of rows.
+ */
+export const queryRows = async (
+  executor: DbExecutor,
+  sql: string,
+  params: unknown[] = []
+): Promise<Record<string, unknown>[]> => {
+  const [first] = await executor.executeSql(sql, params);
+  return toRows(first);
+};
+
+/**
+ * Checks if a table should be included in introspection based on options.
+ * @param name - The table name.
+ * @param options - The introspection options.
+ * @returns True if the table should be included.
+ */
+export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
+  if (options.includeTables && !options.includeTables.includes(name)) return false;
+  if (options.excludeTables && options.excludeTables.includes(name)) return false;
+  return true;
+};
+
+/**
+ * Checks if a view should be included in introspection based on options.
+ * @param name - The view name.
+ * @param options - The introspection options.
+ * @returns True if the view should be included.
+ */
+export const shouldIncludeView = (name: string, options: IntrospectOptions): boolean => {
+  if (options.excludeViews && options.excludeViews.includes(name)) return false;
+  return true;
+};