metal-orm 1.1.9 → 1.1.11

package/src/query-builder/relation-conditions.ts

@@ -1,151 +1,171 @@
-import { TableDef } from '../schema/table.js';
-import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
-import { ExpressionNode, eq, and } from '../core/ast/expression.js';
-import { TableSourceNode } from '../core/ast/query.js';
-import { findPrimaryKey } from './hydration-planner.js';
-import { JoinNode } from '../core/ast/join.js';
-import { JoinKind } from '../core/sql/sql.js';
-import { createJoinNode } from '../core/ast/join-node.js';
-
-/**
- * Utility function to handle unreachable code paths
- * @param value - Value that should never occur
- * @throws Error indicating unhandled relation type
- */
-const assertNever = (value: never): never => {
-  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
-};
-
-/**
- * Builds the base condition for a relation join
- * @param root - Root table definition
- * @param relation - Relation definition
- * @returns Expression node representing the join condition
- */
-const baseRelationCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  rootAlias?: string,
-  targetTableName?: string
-): ExpressionNode => {
-  const rootTable = rootAlias || root.name;
-  const targetTable = targetTableName ?? relation.target.name;
-  const defaultLocalKey =
-    relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
-      ? findPrimaryKey(root)
-      : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
-
-  switch (relation.type) {
-    case RelationKinds.HasMany:
-    case RelationKinds.HasOne:
-      return eq(
-        { type: 'Column', table: targetTable, name: relation.foreignKey },
-        { type: 'Column', table: rootTable, name: localKey }
-      );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: 'Column', table: targetTable, name: localKey },
-        { type: 'Column', table: rootTable, name: relation.foreignKey }
-      );
-    case RelationKinds.BelongsToMany:
-      throw new Error('BelongsToMany relations do not support the standard join condition builder');
-    default:
-      return assertNever(relation);
-  }
-};
-
-/**
- * Builds the join nodes required to include a BelongsToMany relation.
- * @param root - The root table definition
- * @param relationName - Name of the relation being joined
- * @param relation - The BelongsToMany relation definition
- * @param joinKind - The type of join to perform
- * @param extra - Optional additional conditions for the target join
- * @param rootAlias - Optional alias for the root table
- * @returns Array of join nodes for the pivot and target tables
- */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode,
-  rootAlias?: string,
-  targetTable?: TableSourceNode,
-  targetTableName?: string
-): JoinNode[] => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const rootTable = rootAlias || root.name;
-
-  const pivotCondition = eq(
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: 'Column', table: rootTable, name: rootKey }
-  );
-
-  const pivotJoin = createJoinNode(
-    joinKind,
-    { type: 'Table', name: relation.pivotTable.name, schema: relation.pivotTable.schema },
-    pivotCondition
-  );
-
-  const targetSource: TableSourceNode = targetTable ?? {
-    type: 'Table',
-    name: relation.target.name,
-    schema: relation.target.schema
-  };
-  const effectiveTargetName = targetTableName ?? relation.target.name;
-  let targetCondition: ExpressionNode = eq(
-    { type: 'Column', table: effectiveTargetName, name: targetKey },
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
-  );
-
-  if (extra) {
-    targetCondition = and(targetCondition, extra);
-  }
-
-  const targetJoin = createJoinNode(
-    joinKind,
-    targetSource,
-    targetCondition,
-    relationName
-  );
-
-  return [pivotJoin, targetJoin];
-};
-
-/**
- * Builds a relation join condition with optional extra conditions
- * @param root - Root table definition
- * @param relation - Relation definition
- * @param extra - Optional additional expression to combine with AND
- * @param rootAlias - Optional alias for the root table
- * @returns Expression node representing the complete join condition
- */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode,
-  rootAlias?: string,
-  targetTableName?: string
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation, rootAlias, targetTableName);
-  return extra ? and(base, extra) : base;
-};
-
-/**
- * Builds a relation correlation condition for subqueries
- * @param root - Root table definition
- * @param relation - Relation definition
- * @param rootAlias - Optional alias for the root table
- * @returns Expression node representing the correlation condition
- */
-export const buildRelationCorrelation = (
-  root: TableDef,
-  relation: RelationDef,
-  rootAlias?: string,
-  targetTableName?: string
-): ExpressionNode => {
-  return baseRelationCondition(root, relation, rootAlias, targetTableName);
-};
+import { TableDef } from '../schema/table.js';
+import { RelationDef, RelationKinds, BelongsToManyRelation, MorphOneRelation, MorphManyRelation } from '../schema/relation.js';
+import { ExpressionNode, eq, and } from '../core/ast/expression.js';
+import { TableSourceNode } from '../core/ast/query.js';
+import { findPrimaryKey } from './hydration-planner.js';
+import { JoinNode } from '../core/ast/join.js';
+import { JoinKind } from '../core/sql/sql.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+
+/**
+ * Utility function to handle unreachable code paths
+ * @param value - Value that should never occur
+ * @throws Error indicating unhandled relation type
+ */
+const assertNever = (value: never): never => {
+  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
+};
+
+/**
+ * Builds the base condition for a relation join
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @returns Expression node representing the join condition
+ */
+const baseRelationCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  const rootTable = rootAlias || root.name;
+
+  if (relation.type === RelationKinds.MorphTo) {
+    throw new Error('MorphTo relations do not support the standard join condition builder');
+  }
+
+  const targetTable = targetTableName ?? relation.target.name;
+
+  switch (relation.type) {
+    case RelationKinds.HasMany:
+    case RelationKinds.HasOne: {
+      const defaultLocalKey = findPrimaryKey(root);
+      const localKey = relation.localKey || defaultLocalKey;
+      return eq(
+        { type: 'Column', table: targetTable, name: relation.foreignKey },
+        { type: 'Column', table: rootTable, name: localKey }
+      );
+    }
+    case RelationKinds.BelongsTo: {
+      const defaultLocalKey = findPrimaryKey(relation.target);
+      const localKey = relation.localKey || defaultLocalKey;
+      return eq(
+        { type: 'Column', table: targetTable, name: localKey },
+        { type: 'Column', table: rootTable, name: relation.foreignKey }
+      );
+    }
+    case RelationKinds.BelongsToMany:
+      throw new Error('BelongsToMany relations do not support the standard join condition builder');
+    case RelationKinds.MorphOne:
+    case RelationKinds.MorphMany: {
+      const morphRel = relation as MorphOneRelation | MorphManyRelation;
+      const morphLocalKey = morphRel.localKey || findPrimaryKey(root);
+      const baseCondition = eq(
+        { type: 'Column', table: targetTable, name: morphRel.idField },
+        { type: 'Column', table: rootTable, name: morphLocalKey }
+      );
+      const discriminatorCondition = eq(
+        { type: 'Column', table: targetTable, name: morphRel.typeField },
+        { type: 'Literal', value: morphRel.typeValue }
+      );
+      return and(baseCondition, discriminatorCondition);
+    }
+    default:
+      return assertNever(relation);
+  }
+};
+
+/**
+ * Builds the join nodes required to include a BelongsToMany relation.
+ * @param root - The root table definition
+ * @param relationName - Name of the relation being joined
+ * @param relation - The BelongsToMany relation definition
+ * @param joinKind - The type of join to perform
+ * @param extra - Optional additional conditions for the target join
+ * @param rootAlias - Optional alias for the root table
+ * @returns Array of join nodes for the pivot and target tables
+ */
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode,
+  rootAlias?: string,
+  targetTable?: TableSourceNode,
+  targetTableName?: string
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const rootTable = rootAlias || root.name;
+
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: rootTable, name: rootKey }
+  );
+
+  const pivotJoin = createJoinNode(
+    joinKind,
+    { type: 'Table', name: relation.pivotTable.name, schema: relation.pivotTable.schema },
+    pivotCondition
+  );
+
+  const targetSource: TableSourceNode = targetTable ?? {
+    type: 'Table',
+    name: relation.target.name,
+    schema: relation.target.schema
+  };
+  const effectiveTargetName = targetTableName ?? relation.target.name;
+  let targetCondition: ExpressionNode = eq(
+    { type: 'Column', table: effectiveTargetName, name: targetKey },
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
+  );
+
+  if (extra) {
+    targetCondition = and(targetCondition, extra);
+  }
+
+  const targetJoin = createJoinNode(
+    joinKind,
+    targetSource,
+    targetCondition,
+    relationName
+  );
+
+  return [pivotJoin, targetJoin];
+};
+
+/**
+ * Builds a relation join condition with optional extra conditions
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @param extra - Optional additional expression to combine with AND
+ * @param rootAlias - Optional alias for the root table
+ * @returns Expression node representing the complete join condition
+ */
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation, rootAlias, targetTableName);
+  return extra ? and(base, extra) : base;
+};
+
+/**
+ * Builds a relation correlation condition for subqueries
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @param rootAlias - Optional alias for the root table
+ * @returns Expression node representing the correlation condition
+ */
+export const buildRelationCorrelation = (
+  root: TableDef,
+  relation: RelationDef,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias, targetTableName);
+};

package/src/query-builder/relation-cte-builder.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { RelationDef } from '../schema/relation.js';
+import { RelationDef, isSingleTargetRelation } from '../schema/relation.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
 import { SelectQueryNode, TableNode } from '../core/ast/query.js';
 import { SelectQueryState } from './select-query-state.js';
@@ -22,6 +22,10 @@ export class RelationCteBuilder {
       throw new Error('Unable to build filter CTE without predicates.');
     }
 
+    if (!isSingleTargetRelation(relation)) {
+      throw new Error('Polymorphic MorphTo relations do not support filter CTEs');
+    }
+
     const columns: ColumnNode[] = Object.keys(relation.target.columns).map(name => ({
       type: 'Column',
       table: relation.target.name,

package/src/query-builder/relation-filter-utils.ts

@@ -65,12 +65,15 @@ const collectFromExpression = (expr: ExpressionNode, collector: FilterTableColle
       collectFromOperand(expr.left, collector);
       collectFromOperand(expr.right, collector);
       break;
-    case 'LogicalExpression':
-      expr.operands.forEach(operand => collectFromExpression(operand, collector));
-      break;
-    case 'NullExpression':
-      collectFromOperand(expr.left, collector);
-      break;
+    case 'LogicalExpression':
+      expr.operands.forEach(operand => collectFromExpression(operand, collector));
+      break;
+    case 'NotExpression':
+      collectFromExpression(expr.operand, collector);
+      break;
+    case 'NullExpression':
+      collectFromOperand(expr.left, collector);
+      break;
     case 'InExpression':
       collectFromOperand(expr.left, collector);
       if (Array.isArray(expr.right)) {

package/src/query-builder/relation-include-strategies.ts

@@ -6,7 +6,10 @@ import {
   BelongsToManyRelation,
   HasManyRelation,
   HasOneRelation,
-  BelongsToRelation
+  BelongsToRelation,
+  MorphOneRelation,
+  MorphManyRelation,
+  isSingleTargetRelation
 } from '../schema/relation.js';
 import { ColumnNode } from '../core/ast/expression.js';
 import { SelectQueryState } from './select-query-state.js';
@@ -61,6 +64,9 @@ const buildTypedSelection = (
 };
 
 const resolveTargetColumns = (relation: RelationDef, options?: RelationIncludeOptions): string[] => {
+  if (!isSingleTargetRelation(relation)) {
+    return [];
+  }
   const requestedColumns = options?.columns?.length
     ? [...options.columns]
     : Object.keys(relation.target.columns);
@@ -180,9 +186,45 @@ const belongsToManyStrategy: IncludeStrategy = context => {
   return { state, hydration };
 };
 
+const morphIncludeStrategy: IncludeStrategy = context => {
+  let { state, hydration } = context;
+
+  const relation = context.relation as MorphOneRelation | MorphManyRelation;
+  const targetColumns = resolveTargetColumns(relation, context.options);
+  const tableOverride = getJoinCorrelationName(state, context.relationName, relation.target.name);
+  const targetSelection = buildTypedSelection(
+    relation.target.columns as Record<string, ColumnDef>,
+    context.aliasPrefix,
+    targetColumns,
+    key => `Column '${key}' not found on relation '${context.relationName}'`,
+    tableOverride
+  );
+
+  const relationSelectionResult = context.selectColumns(state, hydration, targetSelection);
+  state = relationSelectionResult.state;
+  hydration = relationSelectionResult.hydration;
+
+  hydration = hydration.onRelationIncluded(
+    state,
+    relation,
+    context.relationName,
+    context.aliasPrefix,
+    targetColumns
+  );
+
+  return { state, hydration };
+};
+
+const morphToIncludeStrategy: IncludeStrategy = () => {
+  throw new Error('MorphTo relations do not support JOIN-based include. Use lazy loading instead.');
+};
+
 export const relationIncludeStrategies: Record<RelationDef['type'], IncludeStrategy> = {
   [RelationKinds.HasMany]: standardIncludeStrategy,
   [RelationKinds.HasOne]: standardIncludeStrategy,
   [RelationKinds.BelongsTo]: standardIncludeStrategy,
-  [RelationKinds.BelongsToMany]: belongsToManyStrategy
+  [RelationKinds.BelongsToMany]: belongsToManyStrategy,
+  [RelationKinds.MorphOne]: morphIncludeStrategy,
+  [RelationKinds.MorphMany]: morphIncludeStrategy,
+  [RelationKinds.MorphTo]: morphToIncludeStrategy
 };

package/src/query-builder/relation-join-strategies.ts

@@ -3,7 +3,7 @@ import type { JoinNode } from '../core/ast/join.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 import type { TableSourceNode } from '../core/ast/query.js';
 import { JoinKind } from '../core/sql/sql.js';
-import { RelationDef, RelationKinds, type BelongsToManyRelation } from '../schema/relation.js';
+import { RelationDef, RelationKinds, type BelongsToManyRelation, isSingleTargetRelation } from '../schema/relation.js';
 import type { TableDef } from '../schema/table.js';
 import { findPrimaryKey } from './hydration-planner.js';
 import { buildBelongsToManyJoins, buildRelationJoinCondition } from './relation-conditions.js';
@@ -64,6 +64,10 @@ export const addRelationJoin = (params: AddRelationJoinParams): SelectQueryState
     return joins.reduce((curr, join) => curr.withJoin(join), state);
   }
 
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error('Polymorphic MorphTo relations do not support join-based strategies');
+  }
+
   let targetSource: TableSourceNode = tableSource ?? {
     type: 'Table',
     name: relation.target.name,
@@ -89,6 +93,9 @@ type UpdateRelationJoinParams = {
 export const updateRelationJoin = (params: UpdateRelationJoinParams): JoinNode[] => {
   const { joins, joinIndex, relation, currentTable, currentAlias, options } = params;
   const join = joins[joinIndex];
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error('Polymorphic MorphTo relations do not support join updates');
+  }
   const targetName = resolveTargetTableName(join.table, relation.target.name);
   const extra = remapExpressionTable(options.filter, relation.target.name, targetName);