metal-orm 1.0.58 → 1.0.60

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

@@ -1,5 +1,8 @@
-import { ExpressionNode } from '../core/ast/expression.js';
-import { JOIN_KINDS } from '../core/sql/sql.js';
+import { ExpressionNode } from '../core/ast/expression.js';
+import { JOIN_KINDS } from '../core/sql/sql.js';
+import { TableDef } from '../schema/table.js';
+import { BelongsToManyRelation, RelationDef } from '../schema/relation.js';
+import { RelationTargetTable } from '../schema/types.js';
 
 /**
  * Join kinds allowed when including a relation using `.include(...)`.
@@ -11,11 +14,39 @@ export type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS
  */
 export interface RelationIncludeOptions {
   columns?: readonly string[];
-  aliasPrefix?: string;
-  filter?: ExpressionNode;
-  joinKind?: RelationIncludeJoinKind;
-  pivot?: {
-    columns?: string[];
-    aliasPrefix?: string;
-  };
-}
+  aliasPrefix?: string;
+  filter?: ExpressionNode;
+  joinKind?: RelationIncludeJoinKind;
+  pivot?: {
+    columns?: readonly string[];
+    aliasPrefix?: string;
+  };
+}
+
+type ColumnKeys<T> =
+  T extends { columns: infer Columns }
+    ? keyof Columns & string
+    : string;
+
+type PivotColumnKeys<TPivot> = ColumnKeys<TPivot> extends never ? string : ColumnKeys<TPivot>;
+
+export type RelationTargetColumns<TRel extends RelationDef> =
+  ColumnKeys<RelationTargetTable<TRel>>;
+
+export type BelongsToManyPivotColumns<TRel extends RelationDef> =
+  TRel extends BelongsToManyRelation<TableDef, infer TPivot>
+    ? PivotColumnKeys<TPivot>
+    : never;
+
+export type TypedRelationIncludeOptions<TRel extends RelationDef> =
+  TRel extends BelongsToManyRelation
+    ? Omit<RelationIncludeOptions, 'columns' | 'pivot'> & {
+        columns?: readonly RelationTargetColumns<TRel>[];
+        pivot?: {
+          columns?: readonly BelongsToManyPivotColumns<TRel>[];
+          aliasPrefix?: string;
+        };
+      }
+    : Omit<RelationIncludeOptions, 'columns' | 'pivot'> & {
+        columns?: readonly RelationTargetColumns<TRel>[];
+      };

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 { ...context, state: this.columnSelector.select(context, columns).state };
-    }
+    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 { ...context, state: this.columnSelector.selectRaw(context, cols).state };
-    }
+    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 { ...context, state: this.columnSelector.selectSubquery(context, alias, query).state };
-    }
+    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 { ...context, state: this.columnSelector.distinct(context, cols).state };
-    }
-}
+    distinct(
+        context: SelectQueryBuilderContext,
+        cols: (ColumnDef | ColumnNode)[]
+    ): SelectQueryBuilderContext {
+        return this.columnSelector.distinct(context, cols);
+    }
+}
 

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

@@ -0,0 +1,145 @@
+import { TableDef } from '../../schema/table.js';
+import { ColumnDef } from '../../schema/column-types.js';
+import { OrderingTerm, SelectQueryNode } from '../../core/ast/query.js';
+import { FunctionNode, ExpressionNode, exists, notExists } from '../../core/ast/expression.js';
+import { derivedTable } from '../../core/ast/builders.js';
+import { SelectQueryState } from '../select-query-state.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { SelectPredicateFacet } from './predicate-facet.js';
+import { SelectRelationFacet } from './relation-facet.js';
+import { ORDER_DIRECTIONS, OrderDirection } from '../../core/sql/sql.js';
+import { OrmSession } from '../../orm/orm-session.js';
+import { EntityInstance } from '../../schema/types.js';
+import type { SelectQueryBuilder } from '../select.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 async function executeCount(
+  context: SelectQueryBuilderContext,
+  env: SelectQueryBuilderEnvironment,
+  session: OrmSession
+): Promise<number> {
+  const unpagedAst: SelectQueryNode = {
+    ...context.state.ast,
+    orderBy: undefined,
+    limit: undefined,
+    offset: undefined
+  };
+
+  const nextState = new SelectQueryState(env.table as TableDef, unpagedAst);
+  const nextContext: SelectQueryBuilderContext = {
+    ...context,
+    state: nextState
+  };
+
+  const subAst = nextContext.hydration.applyToAst(nextState.ast);
+  const countQuery: SelectQueryNode = {
+    type: 'SelectQuery',
+    from: derivedTable(subAst, '__metal_count'),
+    columns: [{ type: 'Function', name: 'COUNT', args: [], alias: 'total' } as FunctionNode],
+    joins: []
+  };
+
+  const execCtx = session.getExecutionContext();
+  const compiled = execCtx.dialect.compileSelect(countQuery);
+  const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  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);
+  return value === null || value === undefined ? 0 : Number(value);
+}
+
+/**
+ * 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<{ items: EntityInstance<TTable>[]; totalItems: number }> {
+  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 [items, totalItems] = await Promise.all([
+    builder.limit(pageSize).offset(offset).execute(session),
+    countCallback(session)
+  ]);
+
+  return { items, totalItems };
+}
+
+/**
+ * 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);
+}