metal-orm 1.0.4 → 1.0.6

package/src/builder/insert.ts

@@ -0,0 +1,59 @@
+import { TableDef } from '../schema/table';
+import { ColumnDef } from '../schema/column';
+import { ColumnNode } from '../ast/expression';
+import { CompiledQuery, InsertCompiler } from '../dialect/abstract';
+import { InsertQueryNode } from '../ast/query';
+import { InsertQueryState } from './insert-query-state';
+
+const buildColumnNode = (table: TableDef, column: ColumnDef | ColumnNode): ColumnNode => {
+  if ((column as ColumnNode).type === 'Column') {
+    return column as ColumnNode;
+  }
+  const def = column as ColumnDef;
+  return {
+    type: 'Column',
+    table: def.table || table.name,
+    name: def.name
+  };
+};
+
+/**
+ * Builder for INSERT queries
+ */
+export class InsertQueryBuilder<T> {
+  private readonly table: TableDef;
+  private readonly state: InsertQueryState;
+
+  constructor(table: TableDef, state?: InsertQueryState) {
+    this.table = table;
+    this.state = state ?? new InsertQueryState(table);
+  }
+
+  private clone(state: InsertQueryState): InsertQueryBuilder<T> {
+    return new InsertQueryBuilder(this.table, state);
+  }
+
+  values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T> {
+    const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
+    if (!rows.length) return this;
+    return this.clone(this.state.withValues(rows));
+  }
+
+  returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T> {
+    if (!columns.length) return this;
+    const nodes = columns.map(column => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+
+  compile(compiler: InsertCompiler): CompiledQuery {
+    return compiler.compileInsert(this.state.ast);
+  }
+
+  toSql(compiler: InsertCompiler): string {
+    return this.compile(compiler).sql;
+  }
+
+  getAST(): InsertQueryNode {
+    return this.state.ast;
+  }
+}

package/src/builder/operations/relation-manager.ts

@@ -2,29 +2,7 @@ import { ExpressionNode } from '../../ast/expression';
 import { SelectQueryNode } from '../../ast/query';
 import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
 import { JoinKind } from '../../constants/sql';
-import { RelationIncludeJoinKind } from '../relation-types';
-
-/**
- * Options for including relations in queries
- */
-export interface RelationIncludeOptions {
-  /**
-   * Columns to include from the related table
-   */
-  columns?: string[];
-  /**
-   * Alias prefix for the relation columns
-   */
-  aliasPrefix?: string;
-  /**
-   * Filter expression to apply to the relation
-   */
-  filter?: ExpressionNode;
-  /**
-   * Type of join to use for the relation
-   */
-  joinKind?: RelationIncludeJoinKind;
-}
+import { RelationIncludeOptions } from '../relation-types';
 
 /**
  * Manages relation operations (joins, includes, etc.) for query building

package/src/builder/relation-conditions.ts

@@ -1,7 +1,10 @@
 import { TableDef } from '../schema/table';
-import { RelationDef, RelationKinds } from '../schema/relation';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation';
 import { ExpressionNode, eq, and } from '../ast/expression';
 import { findPrimaryKey } from './hydration-planner';
+import { JoinNode } from '../ast/join';
+import { JoinKind } from '../constants/sql';
+import { createJoinNode } from '../utils/join-node';
 
 /**
  * Utility function to handle unreachable code paths
@@ -36,11 +39,52 @@ const baseRelationCondition = (root: TableDef, relation: RelationDef): Expressio
         { type: 'Column', table: relation.target.name, name: localKey },
         { type: 'Column', table: root.name, 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.
+ */
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: root.name, name: rootKey }
+  );
+
+  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
+
+  let targetCondition: ExpressionNode = eq(
+    { type: 'Column', table: relation.target.name, name: targetKey },
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
+  );
+
+  if (extra) {
+    targetCondition = and(targetCondition, extra);
+  }
+
+  const targetJoin = createJoinNode(
+    joinKind,
+    relation.target.name,
+    targetCondition,
+    relationName
+  );
+
+  return [pivotJoin, targetJoin];
+};
+
 /**
  * Builds a relation join condition with optional extra conditions
  * @param root - Root table definition

package/src/builder/relation-service.ts

@@ -1,6 +1,6 @@
 import { TableDef } from '../schema/table';
 import { ColumnDef } from '../schema/column';
-import { RelationDef } from '../schema/relation';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation';
 import { SelectQueryNode } from '../ast/query';
 import {
   ColumnNode,
@@ -13,11 +13,16 @@ import { QueryAstService } from './query-ast-service';
 import { findPrimaryKey } from './hydration-planner';
 import { RelationProjectionHelper } from './relation-projection-helper';
 import type { RelationResult } from './relation-projection-helper';
-import { buildRelationJoinCondition, buildRelationCorrelation } from './relation-conditions';
+import {
+  buildRelationJoinCondition,
+  buildRelationCorrelation,
+  buildBelongsToManyJoins
+} from './relation-conditions';
 import { JoinKind, JOIN_KINDS } from '../constants/sql';
-import { RelationIncludeJoinKind } from './relation-types';
+import { RelationIncludeOptions } from './relation-types';
 import { createJoinNode } from '../utils/join-node';
 import { makeRelationAlias } from '../utils/relation-alias';
+import { buildDefaultPivotColumns } from './relation-utils';
 
 /**
  * Service for handling relation operations (joins, includes, etc.)
@@ -82,10 +87,7 @@ export class RelationService {
    * @param options - Options for relation inclusion
    * @returns Relation result with updated state and hydration
    */
-  include(
-    relationName: string,
-    options?: { columns?: string[]; aliasPrefix?: string; filter?: ExpressionNode; joinKind?: RelationIncludeJoinKind }
-  ): RelationResult {
+  include(relationName: string, options?: RelationIncludeOptions): RelationResult {
     let state = this.state;
     let hydration = this.hydration;
 
@@ -106,16 +108,66 @@ export class RelationService {
       ? options.columns
       : Object.keys(relation.target.columns);
 
-    const relationSelection = targetColumns.reduce((acc, key) => {
-      const def = (relation.target.columns as any)[key];
-      if (!def) {
-        throw new Error(`Column '${key}' not found on relation '${relationName}'`);
-      }
-      acc[makeRelationAlias(aliasPrefix, key)] = def;
-      return acc;
-    }, {} as Record<string, ColumnDef>);
+    const buildTypedSelection = (
+      columns: Record<string, ColumnDef>,
+      prefix: string,
+      keys: string[],
+      missingMsg: (col: string) => string
+    ) : Record<string, ColumnDef> => {
+      return keys.reduce((acc, key) => {
+        const def = columns[key];
+        if (!def) {
+          throw new Error(missingMsg(key));
+        }
+        acc[makeRelationAlias(prefix, key)] = def;
+        return acc;
+      }, {} as Record<string, ColumnDef>);
+    };
+
+    const targetSelection = buildTypedSelection(
+      relation.target.columns as Record<string, ColumnDef>,
+      aliasPrefix,
+      targetColumns,
+      key => `Column '${key}' not found on relation '${relationName}'`
+    );
+
+    if (relation.type !== RelationKinds.BelongsToMany) {
+      const relationSelectionResult = this.selectColumns(state, hydration, targetSelection);
+      state = relationSelectionResult.state;
+      hydration = relationSelectionResult.hydration;
 
-    const relationSelectionResult = this.selectColumns(state, hydration, relationSelection);
+      hydration = hydration.onRelationIncluded(
+        state,
+        relation,
+        relationName,
+        aliasPrefix,
+        targetColumns
+      );
+
+      return { state, hydration };
+    }
+
+    const many = relation as BelongsToManyRelation;
+    const pivotAliasPrefix = options?.pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
+    const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
+    const pivotColumns =
+      options?.pivot?.columns ??
+      many.defaultPivotColumns ??
+      buildDefaultPivotColumns(many, pivotPk);
+
+    const pivotSelection = buildTypedSelection(
+      many.pivotTable.columns as Record<string, ColumnDef>,
+      pivotAliasPrefix,
+      pivotColumns,
+      key => `Column '${key}' not found on pivot table '${many.pivotTable.name}'`
+    );
+
+    const combinedSelection = {
+      ...targetSelection,
+      ...pivotSelection
+    };
+
+    const relationSelectionResult = this.selectColumns(state, hydration, combinedSelection);
     state = relationSelectionResult.state;
     hydration = relationSelectionResult.hydration;
 
@@ -124,7 +176,8 @@ export class RelationService {
       relation,
       relationName,
       aliasPrefix,
-      targetColumns
+      targetColumns,
+      { aliasPrefix: pivotAliasPrefix, columns: pivotColumns }
     );
 
     return { state, hydration };
@@ -167,8 +220,18 @@ export class RelationService {
     extraCondition?: ExpressionNode
   ): SelectQueryState {
     const relation = this.getRelation(relationName);
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation as BelongsToManyRelation,
+        joinKind,
+        extraCondition
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
 
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
     const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
 
     return this.astService(state).withJoin(joinNode);

package/src/builder/relation-types.ts

@@ -1,6 +1,21 @@
+import { ExpressionNode } from '../ast/expression';
 import { JOIN_KINDS } from '../constants/sql';
 
 /**
  * Join kinds allowed when including a relation using `.include(...)`.
  */
 export type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
+
+/**
+ * Options for including a relation in a query
+ */
+export interface RelationIncludeOptions {
+  columns?: string[];
+  aliasPrefix?: string;
+  filter?: ExpressionNode;
+  joinKind?: RelationIncludeJoinKind;
+  pivot?: {
+    columns?: string[];
+    aliasPrefix?: string;
+  };
+}

package/src/builder/relation-utils.ts

@@ -0,0 +1,12 @@
+import { BelongsToManyRelation } from '../schema/relation';
+
+/**
+ * Builds a default set of pivot columns, excluding keys used for joins.
+ */
+export const buildDefaultPivotColumns = (
+  rel: BelongsToManyRelation,
+  pivotPk: string
+): string[] => {
+  const excluded = new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
+  return Object.keys(rel.pivotTable.columns).filter(col => !excluded.has(col));
+};