metal-orm 1.1.10 → 1.1.16

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

@@ -1,80 +1,80 @@
-import { SelectQueryNode } from '../../core/ast/query.js';
-import { OperandNode } from '../../core/ast/expression.js';
-import { derivedTable, fnTable } from '../../core/ast/builders.js';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
-import { QueryAstService } from '../query-ast-service.js';
-import { SelectQueryState } from '../select-query-state.js';
-
-/**
- * Facet responsible for FROM clause operations
- */
-export class SelectFromFacet {
-    /**
-     * Creates a new SelectFromFacet instance
-     * @param env - Query builder environment
-     * @param createAstService - Function to create AST service
-     */
-    constructor(
-        private readonly env: SelectQueryBuilderEnvironment,
-        private readonly createAstService: (state: SelectQueryState) => QueryAstService
-    ) { }
-
-    /**
-     * Applies an alias to the FROM table
-     * @param context - Current query context
-     * @param alias - Alias to apply
-     * @returns Updated query context with aliased FROM
-     */
-    as(context: SelectQueryBuilderContext, alias: string): SelectQueryBuilderContext {
-        const from = context.state.ast.from;
-        if (from.type !== 'Table') {
-            throw new Error('Cannot alias non-table FROM sources');
-        }
-        const nextFrom = { ...from, alias };
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withFrom(nextFrom);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Sets the FROM clause to a subquery
-     * @param context - Current query context
-     * @param subAst - Subquery AST
-     * @param alias - Alias for the subquery
-     * @param columnAliases - Optional column aliases
-     * @returns Updated query context with subquery FROM
-     */
-    fromSubquery(
-        context: SelectQueryBuilderContext,
-        subAst: SelectQueryNode,
-        alias: string,
-        columnAliases?: string[]
-    ): SelectQueryBuilderContext {
-        const fromNode = derivedTable(subAst, alias, columnAliases);
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withFrom(fromNode);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Sets the FROM clause to a function table
-     * @param context - Current query context
-     * @param name - Function name
-     * @param args - Function arguments
-     * @param alias - Optional alias for the function table
-     * @param options - Optional function table options
-     * @returns Updated query context with function table FROM
-     */
-    fromFunctionTable(
-        context: SelectQueryBuilderContext,
-        name: string,
-        args: OperandNode[],
-        alias?: string,
-        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
-    ): SelectQueryBuilderContext {
-        const functionTable = fnTable(name, args, alias, options);
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withFrom(functionTable);
-        return { state: nextState, hydration: context.hydration };
-    }
-}
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { OperandNode } from '../../core/ast/expression.js';
+import { derivedTable, fnTable } from '../../core/ast/builders.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for FROM clause operations
+ */
+export class SelectFromFacet {
+    /**
+     * Creates a new SelectFromFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Applies an alias to the FROM table
+     * @param context - Current query context
+     * @param alias - Alias to apply
+     * @returns Updated query context with aliased FROM
+     */
+    as(context: SelectQueryBuilderContext, alias: string): SelectQueryBuilderContext {
+        const from = context.state.ast.from;
+        if (from.type !== 'Table') {
+            throw new Error('Cannot alias non-table FROM sources');
+        }
+        const nextFrom = { ...from, alias };
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(nextFrom);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Sets the FROM clause to a subquery
+     * @param context - Current query context
+     * @param subAst - Subquery AST
+     * @param alias - Alias for the subquery
+     * @param columnAliases - Optional column aliases
+     * @returns Updated query context with subquery FROM
+     */
+    fromSubquery(
+        context: SelectQueryBuilderContext,
+        subAst: SelectQueryNode,
+        alias: string,
+        columnAliases?: string[]
+    ): SelectQueryBuilderContext {
+        const fromNode = derivedTable(subAst, alias, columnAliases);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(fromNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Sets the FROM clause to a function table
+     * @param context - Current query context
+     * @param name - Function name
+     * @param args - Function arguments
+     * @param alias - Optional alias for the function table
+     * @param options - Optional function table options
+     * @returns Updated query context with function table FROM
+     */
+    fromFunctionTable(
+        context: SelectQueryBuilderContext,
+        name: string,
+        args: OperandNode[],
+        alias?: string,
+        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+    ): SelectQueryBuilderContext {
+        const functionTable = fnTable(name, args, alias, options);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(functionTable);
+        return { state: nextState, hydration: context.hydration };
+    }
+}

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

@@ -1,62 +1,62 @@
-import { TableDef } from '../../schema/table.js';
-import { BinaryExpressionNode } from '../../core/ast/expression.js';
-import { SelectQueryNode } from '../../core/ast/query.js';
-import { JoinKind } from '../../core/sql/sql.js';
-import { derivedTable, fnTable } from '../../core/ast/builders.js';
-import { createJoinNode } from '../../core/ast/join-node.js';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
-import { QueryAstService } from '../query-ast-service.js';
-import { OperandNode } from '../../core/ast/expression.js';
-import { SelectQueryState } from '../select-query-state.js';
-
-/**
- * Facet responsible for JOIN operations
- */
-export class SelectJoinFacet {
-    constructor(
-        private readonly env: SelectQueryBuilderEnvironment,
-        private readonly createAstService: (state: SelectQueryState) => QueryAstService
-    ) { }
-
-    applyJoin(
-        context: SelectQueryBuilderContext,
-        table: TableDef,
-        condition: BinaryExpressionNode,
-        kind: JoinKind
-    ): SelectQueryBuilderContext {
-        const joinNode = createJoinNode(kind, { type: 'Table', name: table.name, schema: table.schema }, condition);
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withJoin(joinNode);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    joinSubquery(
-        context: SelectQueryBuilderContext,
-        subAst: SelectQueryNode,
-        alias: string,
-        condition: BinaryExpressionNode,
-        joinKind: JoinKind,
-        columnAliases?: string[]
-    ): SelectQueryBuilderContext {
-        const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withJoin(joinNode);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    joinFunctionTable(
-        context: SelectQueryBuilderContext,
-        name: string,
-        args: OperandNode[],
-        alias: string,
-        condition: BinaryExpressionNode,
-        joinKind: JoinKind,
-        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
-    ): SelectQueryBuilderContext {
-        const functionTable = fnTable(name, args, alias, options);
-        const joinNode = createJoinNode(joinKind, functionTable, condition);
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withJoin(joinNode);
-        return { state: nextState, hydration: context.hydration };
-    }
-}
+import { TableDef } from '../../schema/table.js';
+import { BinaryExpressionNode } from '../../core/ast/expression.js';
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { JoinKind } from '../../core/sql/sql.js';
+import { derivedTable, fnTable } from '../../core/ast/builders.js';
+import { createJoinNode } from '../../core/ast/join-node.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { OperandNode } from '../../core/ast/expression.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for JOIN operations
+ */
+export class SelectJoinFacet {
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    applyJoin(
+        context: SelectQueryBuilderContext,
+        table: TableDef,
+        condition: BinaryExpressionNode,
+        kind: JoinKind
+    ): SelectQueryBuilderContext {
+        const joinNode = createJoinNode(kind, { type: 'Table', name: table.name, schema: table.schema }, condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    joinSubquery(
+        context: SelectQueryBuilderContext,
+        subAst: SelectQueryNode,
+        alias: string,
+        condition: BinaryExpressionNode,
+        joinKind: JoinKind,
+        columnAliases?: string[]
+    ): SelectQueryBuilderContext {
+        const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    joinFunctionTable(
+        context: SelectQueryBuilderContext,
+        name: string,
+        args: OperandNode[],
+        alias: string,
+        condition: BinaryExpressionNode,
+        joinKind: JoinKind,
+        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+    ): SelectQueryBuilderContext {
+        const functionTable = fnTable(name, args, alias, options);
+        const joinNode = createJoinNode(joinKind, functionTable, condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+}

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

@@ -1,104 +1,104 @@
-import { ColumnDef } from '../../schema/column-types.js';
-import { ExpressionNode } from '../../core/ast/expression.js';
-import { OrderingTerm } from '../../core/ast/query.js';
-import { OrderDirection } from '../../core/sql/sql.js';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
-import { QueryAstService } from '../query-ast-service.js';
-import { SelectQueryState } from '../select-query-state.js';
-
-/**
- * Facet responsible for filtering and ordering operations
- */
-export class SelectPredicateFacet {
-    /**
-     * Creates a new SelectPredicateFacet instance
-     * @param env - Query builder environment
-     * @param createAstService - Function to create AST service
-     */
-    constructor(
-        private readonly env: SelectQueryBuilderEnvironment,
-        private readonly createAstService: (state: SelectQueryState) => QueryAstService
-    ) { }
-
-    /**
-     * Adds a WHERE condition to the query
-     * @param context - Current query context
-     * @param expr - WHERE expression
-     * @returns Updated query context with WHERE condition
-     */
-    where(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withWhere(expr);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Adds a GROUP BY clause to the query
-     * @param context - Current query context
-     * @param term - Column or ordering term to group by
-     * @returns Updated query context with GROUP BY clause
-     */
-    groupBy(context: SelectQueryBuilderContext, term: ColumnDef | OrderingTerm): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withGroupBy(term);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Adds a HAVING condition to the query
-     * @param context - Current query context
-     * @param expr - HAVING expression
-     * @returns Updated query context with HAVING condition
-     */
-    having(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withHaving(expr);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Adds an ORDER BY clause to the query
-     * @param context - Current query context
-     * @param term - Column or ordering term to order by
-     * @param direction - Order direction
-     * @param nulls - Nulls ordering
-     * @param collation - Collation
-     * @returns Updated query context with ORDER BY clause
-     */
-    orderBy(
-        context: SelectQueryBuilderContext,
-        term: ColumnDef | OrderingTerm,
-        direction: OrderDirection,
-        nulls?: 'FIRST' | 'LAST',
-        collation?: string
-    ): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withOrderBy(term, direction, nulls, collation);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Adds a LIMIT clause to the query
-     * @param context - Current query context
-     * @param n - Maximum number of rows
-     * @returns Updated query context with LIMIT clause
-     */
-    limit(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withLimit(n);
-        return { state: nextState, hydration: context.hydration };
-    }
-
-    /**
-     * Adds an OFFSET clause to the query
-     * @param context - Current query context
-     * @param n - Number of rows to skip
-     * @returns Updated query context with OFFSET clause
-     */
-    offset(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withOffset(n);
-        return { state: nextState, hydration: context.hydration };
-    }
-}
-
+import { ColumnDef } from '../../schema/column-types.js';
+import { ExpressionNode } from '../../core/ast/expression.js';
+import { OrderingTerm } from '../../core/ast/query.js';
+import { OrderDirection } from '../../core/sql/sql.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for filtering and ordering operations
+ */
+export class SelectPredicateFacet {
+    /**
+     * Creates a new SelectPredicateFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Adds a WHERE condition to the query
+     * @param context - Current query context
+     * @param expr - WHERE expression
+     * @returns Updated query context with WHERE condition
+     */
+    where(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withWhere(expr);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a GROUP BY clause to the query
+     * @param context - Current query context
+     * @param term - Column or ordering term to group by
+     * @returns Updated query context with GROUP BY clause
+     */
+    groupBy(context: SelectQueryBuilderContext, term: ColumnDef | OrderingTerm): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withGroupBy(term);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a HAVING condition to the query
+     * @param context - Current query context
+     * @param expr - HAVING expression
+     * @returns Updated query context with HAVING condition
+     */
+    having(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withHaving(expr);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds an ORDER BY clause to the query
+     * @param context - Current query context
+     * @param term - Column or ordering term to order by
+     * @param direction - Order direction
+     * @param nulls - Nulls ordering
+     * @param collation - Collation
+     * @returns Updated query context with ORDER BY clause
+     */
+    orderBy(
+        context: SelectQueryBuilderContext,
+        term: ColumnDef | OrderingTerm,
+        direction: OrderDirection,
+        nulls?: 'FIRST' | 'LAST',
+        collation?: string
+    ): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withOrderBy(term, direction, nulls, collation);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a LIMIT clause to the query
+     * @param context - Current query context
+     * @param n - Maximum number of rows
+     * @returns Updated query context with LIMIT clause
+     */
+    limit(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withLimit(n);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds an OFFSET clause to the query
+     * @param context - Current query context
+     * @param n - Number of rows to skip
+     * @returns Updated query context with OFFSET clause
+     */
+    offset(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withOffset(n);
+        return { state: nextState, hydration: context.hydration };
+    }
+}
+

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

@@ -1,70 +1,70 @@
-import { ColumnDef } from '../../schema/column-types.js';
-import { ColumnNode, FunctionNode, CaseExpressionNode, WindowFunctionNode } from '../../core/ast/expression.js';
-import { SelectQueryBuilderContext } from '../select-query-builder-deps.js';
-import { ColumnSelector } from '../column-selector.js';
-import { SelectQueryNode } from '../../core/ast/query.js';
-
-type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode;
-
-/**
- * Facet responsible for projection operations (SELECT, DISTINCT, etc.)
- */
-export class SelectProjectionFacet {
-    /**
-     * Creates a new SelectProjectionFacet instance
-     * @param columnSelector - Column selector dependency
-     */
-    constructor(private readonly columnSelector: ColumnSelector) { }
-
-    /**
-     * Selects columns for the query
-     * @param context - Current query context
-     * @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);
-    }
-
-    /**
-     * Selects raw column expressions
-     * @param context - Current query context
-     * @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);
-    }
-
-    /**
-     * Selects a subquery as a column
-     * @param context - Current query context
-     * @param alias - Alias for the subquery
-     * @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);
-    }
-
-    /**
-     * Adds DISTINCT clause to the query
-     * @param context - Current query context
-     * @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);
-    }
-}
-
+import { ColumnDef } from '../../schema/column-types.js';
+import { ColumnNode, FunctionNode, CaseExpressionNode, WindowFunctionNode } from '../../core/ast/expression.js';
+import { SelectQueryBuilderContext } from '../select-query-builder-deps.js';
+import { ColumnSelector } from '../column-selector.js';
+import { SelectQueryNode } from '../../core/ast/query.js';
+
+type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode;
+
+/**
+ * Facet responsible for projection operations (SELECT, DISTINCT, etc.)
+ */
+export class SelectProjectionFacet {
+    /**
+     * Creates a new SelectProjectionFacet instance
+     * @param columnSelector - Column selector dependency
+     */
+    constructor(private readonly columnSelector: ColumnSelector) { }
+
+    /**
+     * Selects columns for the query
+     * @param context - Current query context
+     * @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);
+    }
+
+    /**
+     * Selects raw column expressions
+     * @param context - Current query context
+     * @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);
+    }
+
+    /**
+     * Selects a subquery as a column
+     * @param context - Current query context
+     * @param alias - Alias for the subquery
+     * @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);
+    }
+
+    /**
+     * Adds DISTINCT clause to the query
+     * @param context - Current query context
+     * @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);
+    }
+}
+