metal-orm 1.0.97 → 1.0.98

package/src/query-builder/hydration-planner.ts

@@ -1,7 +1,7 @@
 import { TableDef } from '../schema/table.js';
 import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
 import { ProjectionNode } from './select-query-state.js';
-import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
+import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
 import { isRelationAlias } from './relation-alias.js';
 import { buildDefaultPivotColumns } from './relation-utils.js';
 
@@ -31,20 +31,20 @@ export class HydrationPlanner {
    * @param columns - Columns to capture
    * @returns Updated HydrationPlanner with captured columns
    */
-  captureRootColumns(columns: ProjectionNode[]): HydrationPlanner {
-    const currentPlan = this.getPlanOrDefault();
-    const rootCols = new Set(currentPlan.rootColumns);
-    let changed = false;
-
-    columns.forEach(node => {
-      const alias = node.type === 'Column' ? (node.alias || node.name) : node.alias;
-      if (!alias || isRelationAlias(alias)) return;
-      if (node.type === 'Column' && node.table !== this.table.name) return;
-      if (!rootCols.has(alias)) {
-        rootCols.add(alias);
-        changed = true;
-      }
-    });
+  captureRootColumns(columns: ProjectionNode[]): HydrationPlanner {
+    const currentPlan = this.getPlanOrDefault();
+    const rootCols = new Set(currentPlan.rootColumns);
+    let changed = false;
+
+    columns.forEach(node => {
+      const alias = node.type === 'Column' ? (node.alias || node.name) : node.alias;
+      if (!alias || isRelationAlias(alias)) return;
+      if (node.type === 'Column' && node.table !== this.table.name) return;
+      if (!rootCols.has(alias)) {
+        rootCols.add(alias);
+        changed = true;
+      }
+    });
 
     if (!changed) return this;
     return new HydrationPlanner(this.table, {
@@ -109,13 +109,13 @@ export class HydrationPlanner {
     pivot?: { aliasPrefix: string; columns: string[] }
   ): HydrationRelationPlan {
     switch (rel.type) {
-      case RelationKinds.HasMany:
-      case RelationKinds.HasOne: {
-        const localKey = rel.localKey || findPrimaryKey(this.table);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
+      case RelationKinds.HasMany:
+      case RelationKinds.HasOne: {
+        const localKey = rel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
           targetTable: rel.target.name,
           targetPrimaryKey: findPrimaryKey(rel.target),
           foreignKey: rel.foreignKey,

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

@@ -1,11 +1,11 @@
-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';
+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
@@ -22,32 +22,32 @@ const assertNever = (value: never): never => {
  * @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 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.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:
@@ -65,16 +65,16 @@ const baseRelationCondition = (
  * @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[] => {
+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;
@@ -90,27 +90,27 @@ export const buildBelongsToManyJoins = (
     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
-  );
+  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];
 };
@@ -123,16 +123,16 @@ export const buildBelongsToManyJoins = (
  * @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;
-};
+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
@@ -141,11 +141,11 @@ export const buildRelationJoinCondition = (
  * @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);
-};
+export const buildRelationCorrelation = (
+  root: TableDef,
+  relation: RelationDef,
+  rootAlias?: string,
+  targetTableName?: string
+): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias, targetTableName);
+};

package/src/query-builder/select/projection-facet.ts

@@ -22,12 +22,12 @@ export class SelectProjectionFacet {
      * @param columns - Columns to select
      * @returns Updated query context with selected columns
      */
-    select(
-        context: SelectQueryBuilderContext,
-        columns: Record<string, ColumnSelectionValue>
-    ): SelectQueryBuilderContext {
-        return this.columnSelector.select(context, columns);
-    }
+    select(
+        context: SelectQueryBuilderContext,
+        columns: Record<string, ColumnSelectionValue>
+    ): SelectQueryBuilderContext {
+        return this.columnSelector.select(context, columns);
+    }
 
     /**
      * Selects raw column expressions
@@ -35,9 +35,9 @@ export class SelectProjectionFacet {
      * @param cols - Raw column expressions
      * @returns Updated query context with raw column selections
      */
-    selectRaw(context: SelectQueryBuilderContext, cols: string[]): SelectQueryBuilderContext {
-        return this.columnSelector.selectRaw(context, cols);
-    }
+    selectRaw(context: SelectQueryBuilderContext, cols: string[]): SelectQueryBuilderContext {
+        return this.columnSelector.selectRaw(context, cols);
+    }
 
     /**
      * Selects a subquery as a column
@@ -46,13 +46,13 @@ export class SelectProjectionFacet {
      * @param query - Subquery to select
      * @returns Updated query context with subquery selection
      */
-    selectSubquery(
-        context: SelectQueryBuilderContext,
-        alias: string,
-        query: SelectQueryNode
-    ): SelectQueryBuilderContext {
-        return this.columnSelector.selectSubquery(context, alias, query);
-    }
+    selectSubquery(
+        context: SelectQueryBuilderContext,
+        alias: string,
+        query: SelectQueryNode
+    ): SelectQueryBuilderContext {
+        return this.columnSelector.selectSubquery(context, alias, query);
+    }
 
     /**
      * Adds DISTINCT clause to the query
@@ -60,11 +60,11 @@ export class SelectProjectionFacet {
      * @param cols - Columns to make distinct
      * @returns Updated query context with DISTINCT clause
      */
-    distinct(
-        context: SelectQueryBuilderContext,
-        cols: (ColumnDef | ColumnNode)[]
-    ): SelectQueryBuilderContext {
-        return this.columnSelector.distinct(context, cols);
-    }
-}
+    distinct(
+        context: SelectQueryBuilderContext,
+        cols: (ColumnDef | ColumnNode)[]
+    ): SelectQueryBuilderContext {
+        return this.columnSelector.distinct(context, cols);
+    }
+}