metal-orm 1.1.9 → 1.1.10

package/src/query-builder/select/select-operations.ts

@@ -1,4 +1,5 @@
 import { TableDef } from '../../schema/table.js';
+import { isSingleTargetRelation } from '../../schema/relation.js';
 import { ColumnDef } from '../../schema/column-types.js';
 import { OrderingTerm, SelectQueryNode } from '../../core/ast/query.js';
 import { ColumnNode, FunctionNode, ExpressionNode, exists, notExists } from '../../core/ast/expression.js';
@@ -12,35 +13,35 @@ import { OrmSession } from '../../orm/orm-session.js';
 import type { SelectQueryBuilder } from '../select.js';
 import { findPrimaryKey } from '../hydration-planner.js';
 import { payloadResultSets } from '../../core/execution/db-executor.js';
-
-export type WhereHasOptions = {
-  correlate?: ExpressionNode;
-};
-
-export type RelationCallback = <TChildTable extends TableDef>(
-  qb: SelectQueryBuilder<unknown, TChildTable>
-) => SelectQueryBuilder<unknown, TChildTable>;
-
-type ChildBuilderFactory = <R, TChild extends TableDef>(table: TChild) => SelectQueryBuilder<R, TChild>;
-
-/**
- * Builds a new query context with an ORDER BY clause applied.
- */
-export function applyOrderBy(
-  context: SelectQueryBuilderContext,
-  predicateFacet: SelectPredicateFacet,
-  term: ColumnDef | OrderingTerm,
-  directionOrOptions: OrderDirection | { direction?: OrderDirection; nulls?: 'FIRST' | 'LAST'; collation?: string }
-): SelectQueryBuilderContext {
-  const options =
-    typeof directionOrOptions === 'string' ? { direction: directionOrOptions } : directionOrOptions;
-  const dir = options.direction ?? ORDER_DIRECTIONS.ASC;
-  return predicateFacet.orderBy(context, term, dir, options.nulls, options.collation);
-}
-
-/**
- * Runs the count query for the provided context and session.
- */
+
+export type WhereHasOptions = {
+  correlate?: ExpressionNode;
+};
+
+export type RelationCallback = <TChildTable extends TableDef>(
+  qb: SelectQueryBuilder<unknown, TChildTable>
+) => SelectQueryBuilder<unknown, TChildTable>;
+
+type ChildBuilderFactory = <R, TChild extends TableDef>(table: TChild) => SelectQueryBuilder<R, TChild>;
+
+/**
+ * Builds a new query context with an ORDER BY clause applied.
+ */
+export function applyOrderBy(
+  context: SelectQueryBuilderContext,
+  predicateFacet: SelectPredicateFacet,
+  term: ColumnDef | OrderingTerm,
+  directionOrOptions: OrderDirection | { direction?: OrderDirection; nulls?: 'FIRST' | 'LAST'; collation?: string }
+): SelectQueryBuilderContext {
+  const options =
+    typeof directionOrOptions === 'string' ? { direction: directionOrOptions } : directionOrOptions;
+  const dir = options.direction ?? ORDER_DIRECTIONS.ASC;
+  return predicateFacet.orderBy(context, term, dir, options.nulls, options.collation);
+}
+
+/**
+ * Runs the count query for the provided context and session.
+ */
 export async function executeCount(
   context: SelectQueryBuilderContext,
   env: SelectQueryBuilderEnvironment,
@@ -103,10 +104,10 @@ export async function executeCount(
   const payload = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const results = payloadResultSets(payload);
   const value = results[0]?.values?.[0]?.[0];
-
-  if (typeof value === 'number') return value;
-  if (typeof value === 'bigint') return Number(value);
-  if (typeof value === 'string') return Number(value);
+
+  if (typeof value === 'number') return value;
+  if (typeof value === 'bigint') return Number(value);
+  if (typeof value === 'string') return Number(value);
   return value === null || value === undefined ? 0 : Number(value);
 }
 
@@ -156,75 +157,79 @@ export async function executeCountRows(
   if (typeof value === 'string') return Number(value);
   return value === null || value === undefined ? 0 : Number(value);
 }
-
-export interface PaginatedResult<T> {
-  items: T[];
-  totalItems: number;
-  page: number;
-  pageSize: number;
-}
-
-/**
- * Executes paged queries using the provided builder helpers.
- */
-export async function executePagedQuery<T, TTable extends TableDef>(
-  builder: SelectQueryBuilder<T, TTable>,
-  session: OrmSession,
-  options: { page: number; pageSize: number },
-  countCallback: (session: OrmSession) => Promise<number>
-): Promise<PaginatedResult<T>> {
-  const { page, pageSize } = options;
-
-  if (!Number.isInteger(page) || page < 1) {
-    throw new Error('executePaged: page must be an integer >= 1');
-  }
-  if (!Number.isInteger(pageSize) || pageSize < 1) {
-    throw new Error('executePaged: pageSize must be an integer >= 1');
-  }
-
-  const offset = (page - 1) * pageSize;
-
-  const totalItems = await countCallback(session);
-  const items = await builder.limit(pageSize).offset(offset).execute(session);
-
-  return { items, totalItems, page, pageSize };
-}
-
-/**
- * Builds an EXISTS or NOT EXISTS predicate for a related table.
- */
-export function buildWhereHasPredicate<TTable extends TableDef>(
-  env: SelectQueryBuilderEnvironment,
-  context: SelectQueryBuilderContext,
-  relationFacet: SelectRelationFacet,
-  createChildBuilder: ChildBuilderFactory,
-  relationName: keyof TTable['relations'] & string,
-  callbackOrOptions?: RelationCallback | WhereHasOptions,
-  maybeOptions?: WhereHasOptions,
-  negate = false
-): ExpressionNode {
-  const relation = env.table.relations[relationName as string];
-  if (!relation) {
-    throw new Error(`Relation '${relationName}' not found on table '${env.table.name}'`);
-  }
-
-  const callback = typeof callbackOrOptions === 'function' ? callbackOrOptions : undefined;
-  const options = (typeof callbackOrOptions === 'function' ? maybeOptions : callbackOrOptions) as
-    | WhereHasOptions
-    | undefined;
-
-  let subQb = createChildBuilder<unknown, TableDef>(relation.target);
-  if (callback) {
-    subQb = callback(subQb);
-  }
-
-  const subAst = subQb.getAST();
-  const finalSubAst = relationFacet.applyRelationCorrelation(
-    context,
-    relationName,
-    subAst,
-    options?.correlate
-  );
-
-  return negate ? notExists(finalSubAst) : exists(finalSubAst);
-}
+
+export interface PaginatedResult<T> {
+  items: T[];
+  totalItems: number;
+  page: number;
+  pageSize: number;
+}
+
+/**
+ * Executes paged queries using the provided builder helpers.
+ */
+export async function executePagedQuery<T, TTable extends TableDef>(
+  builder: SelectQueryBuilder<T, TTable>,
+  session: OrmSession,
+  options: { page: number; pageSize: number },
+  countCallback: (session: OrmSession) => Promise<number>
+): Promise<PaginatedResult<T>> {
+  const { page, pageSize } = options;
+
+  if (!Number.isInteger(page) || page < 1) {
+    throw new Error('executePaged: page must be an integer >= 1');
+  }
+  if (!Number.isInteger(pageSize) || pageSize < 1) {
+    throw new Error('executePaged: pageSize must be an integer >= 1');
+  }
+
+  const offset = (page - 1) * pageSize;
+
+  const totalItems = await countCallback(session);
+  const items = await builder.limit(pageSize).offset(offset).execute(session);
+
+  return { items, totalItems, page, pageSize };
+}
+
+/**
+ * Builds an EXISTS or NOT EXISTS predicate for a related table.
+ */
+export function buildWhereHasPredicate<TTable extends TableDef>(
+  env: SelectQueryBuilderEnvironment,
+  context: SelectQueryBuilderContext,
+  relationFacet: SelectRelationFacet,
+  createChildBuilder: ChildBuilderFactory,
+  relationName: keyof TTable['relations'] & string,
+  callbackOrOptions?: RelationCallback | WhereHasOptions,
+  maybeOptions?: WhereHasOptions,
+  negate = false
+): ExpressionNode {
+  const relation = env.table.relations[relationName as string];
+  if (!relation) {
+    throw new Error(`Relation '${relationName}' not found on table '${env.table.name}'`);
+  }
+
+  const callback = typeof callbackOrOptions === 'function' ? callbackOrOptions : undefined;
+  const options = (typeof callbackOrOptions === 'function' ? maybeOptions : callbackOrOptions) as
+    | WhereHasOptions
+    | undefined;
+
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error(`Polymorphic relation '${relationName}' does not support whereHas/whereHasNot`);
+  }
+
+  let subQb = createChildBuilder<unknown, TableDef>(relation.target);
+  if (callback) {
+    subQb = callback(subQb);
+  }
+
+  const subAst = subQb.getAST();
+  const finalSubAst = relationFacet.applyRelationCorrelation(
+    context,
+    relationName,
+    subAst,
+    options?.correlate
+  );
+
+  return negate ? notExists(finalSubAst) : exists(finalSubAst);
+}

package/src/query-builder/update-include.ts

@@ -1,5 +1,6 @@
 import { JOIN_KINDS } from '../core/sql/sql.js';
 import type { TableDef } from '../schema/table.js';
+import { isSingleTargetRelation } from '../schema/relation.js';
 import { findJoinByRelationKey, findJoinIndexByRelationKey } from './join-utils.js';
 import { addRelationJoin, updateRelationJoin } from './relation-join-strategies.js';
 import { getExposedName } from './table-alias-utils.js';
@@ -92,6 +93,9 @@ export const updateInclude = <T, TTable extends TableDef>(
       });
     }
 
+    if (!isSingleTargetRelation(relation)) {
+      continue;
+    }
     const joinForSegment = findJoinByRelationKey(state.ast.joins, relationKey);
     currentAlias = joinForSegment ? (getExposedName(joinForSegment.table) ?? relation.target.name) : relation.target.name;
     currentTable = relation.target;