metal-orm 1.0.7 → 1.0.9

package/src/{builder → query-builder}/insert.ts

@@ -1,59 +1,48 @@
-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;
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { ColumnNode } from '../core/ast/expression.js';
+import { CompiledQuery, InsertCompiler } from '../core/dialect/abstract.js';
+import { InsertQueryNode } from '../core/ast/query.js';
+import { InsertQueryState } from './insert-query-state.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+
+/**
+ * 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 → query-builder}/query-ast-service.ts

@@ -1,226 +1,208 @@
-import { TableDef } from '../schema/table';
-import { ColumnDef } from '../schema/column';
-import { SelectQueryNode, CommonTableExpressionNode } from '../ast/query';
-import {
-  ColumnNode,
-  ExpressionNode,
-  FunctionNode,
-  CaseExpressionNode,
-  WindowFunctionNode,
-  ScalarSubqueryNode,
-  and,
-  isExpressionSelectionNode
-} from '../ast/expression';
-import { JoinNode } from '../ast/join';
-import { SelectQueryState, ProjectionNode } from './select-query-state';
-import { OrderDirection } from '../constants/sql';
-import { parseRawColumn } from '../utils/raw-column-parser';
-
-/**
- * Builds a column node from a column definition or existing column node
- * @param table - Table definition
- * @param col - Column definition or column node
- * @returns Column node
- */
-export const buildColumnNode = (table: TableDef, col: ColumnDef | ColumnNode): ColumnNode => {
-  if ((col as ColumnNode).type === 'Column') {
-    return col as ColumnNode;
-  }
-
-  const def = col as ColumnDef;
-  return {
-    type: 'Column',
-    table: def.table || table.name,
-    name: def.name
-  };
-};
-
-/**
- * Result of column selection operation
- */
-export interface ColumnSelectionResult {
-  /**
-   * Updated query state
-   */
-  state: SelectQueryState;
-  /**
-   * Columns that were added
-   */
-  addedColumns: ProjectionNode[];
-}
-
-/**
- * Service for manipulating query AST (Abstract Syntax Tree)
- */
-export class QueryAstService {
-  /**
-   * Creates a new QueryAstService instance
-   * @param table - Table definition
-   * @param state - Current query state
-   */
-  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) {}
-
-  /**
-   * Selects columns for the query
-   * @param columns - Columns to select (key: alias, value: column definition or expression)
-   * @returns Column selection result with updated state and added columns
-   */
-  select(
-    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
-  ): ColumnSelectionResult {
-    const existingAliases = new Set(
-      this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
-    );
-
-    const newCols = Object.entries(columns).reduce<ProjectionNode[]>((acc, [alias, val]) => {
-      if (existingAliases.has(alias)) return acc;
-
-      if (isExpressionSelectionNode(val)) {
-        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
-        return acc;
-      }
-
-      const colDef = val as ColumnDef;
-      acc.push({
-        type: 'Column',
-        table: colDef.table || this.table.name,
-        name: colDef.name,
-        alias
-      } as ColumnNode);
-      return acc;
-    }, []);
-
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
-
-  /**
-   * Selects raw column expressions (best-effort parser for simple references/functions)
-   * @param cols - Raw column expressions
-   * @returns Column selection result with updated state and added columns
-   */
-  selectRaw(cols: string[]): ColumnSelectionResult {
-    const newCols = cols.map(col => parseRawColumn(col, this.table.name, this.state.ast.ctes));
-    const nextState = this.state.withColumns(newCols);
-    return { state: nextState, addedColumns: newCols };
-  }
-
-  /**
-   * Adds a Common Table Expression (CTE) to the query
-   * @param name - Name of the CTE
-   * @param query - Query for the CTE
-   * @param columns - Optional column names for the CTE
-   * @param recursive - Whether the CTE is recursive
-   * @returns Updated query state with CTE
-   */
-  withCte(name: string, query: SelectQueryNode, columns?: string[], recursive = false): SelectQueryState {
-    const cte: CommonTableExpressionNode = {
-      type: 'CommonTableExpression',
-      name,
-      query,
-      columns,
-      recursive
-    };
-
-    return this.state.withCte(cte);
-  }
-
-  /**
-   * Selects a subquery as a column
-   * @param alias - Alias for the subquery
-   * @param query - Subquery to select
-   * @returns Updated query state with subquery selection
-   */
-  selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState {
-    const node: ScalarSubqueryNode = { type: 'ScalarSubquery', query, alias };
-    return this.state.withColumns([node]);
-  }
-
-  /**
-   * Adds a JOIN clause to the query
-   * @param join - Join node to add
-   * @returns Updated query state with JOIN
-   */
-  withJoin(join: JoinNode): SelectQueryState {
-    return this.state.withJoin(join);
-  }
-
-  /**
-   * Adds a WHERE clause to the query
-   * @param expr - Expression for the WHERE clause
-   * @returns Updated query state with WHERE clause
-   */
-  withWhere(expr: ExpressionNode): SelectQueryState {
-    const combined = this.combineExpressions(this.state.ast.where, expr);
-    return this.state.withWhere(combined);
-  }
-
-  /**
-   * Adds a GROUP BY clause to the query
-   * @param col - Column to group by
-   * @returns Updated query state with GROUP BY clause
-   */
-  withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState {
-    const node = buildColumnNode(this.table, col);
-    return this.state.withGroupBy([node]);
-  }
-
-  /**
-   * Adds a HAVING clause to the query
-   * @param expr - Expression for the HAVING clause
-   * @returns Updated query state with HAVING clause
-   */
-  withHaving(expr: ExpressionNode): SelectQueryState {
-    const combined = this.combineExpressions(this.state.ast.having, expr);
-    return this.state.withHaving(combined);
-  }
-
-  /**
-   * Adds an ORDER BY clause to the query
-   * @param col - Column to order by
-   * @param direction - Order direction (ASC/DESC)
-   * @returns Updated query state with ORDER BY clause
-   */
-  withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState {
-    const node = buildColumnNode(this.table, col);
-    return this.state.withOrderBy([{ type: 'OrderBy', column: node, direction }]);
-  }
-
-  /**
-   * Adds a DISTINCT clause to the query
-   * @param cols - Columns to make distinct
-   * @returns Updated query state with DISTINCT clause
-   */
-  withDistinct(cols: ColumnNode[]): SelectQueryState {
-    return this.state.withDistinct(cols);
-  }
-
-  /**
-   * Adds a LIMIT clause to the query
-   * @param limit - Maximum number of rows to return
-   * @returns Updated query state with LIMIT clause
-   */
-  withLimit(limit: number): SelectQueryState {
-    return this.state.withLimit(limit);
-  }
-
-  /**
-   * Adds an OFFSET clause to the query
-   * @param offset - Number of rows to skip
-   * @returns Updated query state with OFFSET clause
-   */
-  withOffset(offset: number): SelectQueryState {
-    return this.state.withOffset(offset);
-  }
-
-  /**
-   * Combines expressions with AND operator
-   * @param existing - Existing expression
-   * @param next - New expression to combine
-   * @returns Combined expression
-   */
-  private combineExpressions(existing: ExpressionNode | undefined, next: ExpressionNode): ExpressionNode {
-    return existing ? and(existing, next) : next;
-  }
-
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { SelectQueryNode, CommonTableExpressionNode } from '../core/ast/query.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+import {
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  CaseExpressionNode,
+  WindowFunctionNode,
+  ScalarSubqueryNode,
+  and,
+  isExpressionSelectionNode
+} from '../core/ast/expression.js';
+import { JoinNode } from '../core/ast/join.js';
+import { SelectQueryState, ProjectionNode } from './select-query-state.js';
+import { OrderDirection } from '../core/sql/sql.js';
+import { parseRawColumn } from './raw-column-parser.js';
+
+/**
+ * Result of column selection operation
+ */
+export interface ColumnSelectionResult {
+  /**
+   * Updated query state
+   */
+  state: SelectQueryState;
+  /**
+   * Columns that were added
+   */
+  addedColumns: ProjectionNode[];
+}
+
+/**
+ * Service for manipulating query AST (Abstract Syntax Tree)
+ */
+export class QueryAstService {
+  /**
+   * Creates a new QueryAstService instance
+   * @param table - Table definition
+   * @param state - Current query state
+   */
+  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) {}
+
+  /**
+   * Selects columns for the query
+   * @param columns - Columns to select (key: alias, value: column definition or expression)
+   * @returns Column selection result with updated state and added columns
+   */
+  select(
+    columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>
+  ): ColumnSelectionResult {
+    const existingAliases = new Set(
+      this.state.ast.columns.map(c => (c as ColumnNode).alias || (c as ColumnNode).name)
+    );
+
+    const newCols = Object.entries(columns).reduce<ProjectionNode[]>((acc, [alias, val]) => {
+      if (existingAliases.has(alias)) return acc;
+
+      if (isExpressionSelectionNode(val)) {
+        acc.push({ ...(val as FunctionNode | CaseExpressionNode | WindowFunctionNode), alias } as ProjectionNode);
+        return acc;
+      }
+
+      const colDef = val as ColumnDef;
+      acc.push({
+        type: 'Column',
+        table: colDef.table || this.table.name,
+        name: colDef.name,
+        alias
+      } as ColumnNode);
+      return acc;
+    }, []);
+
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
+
+  /**
+   * Selects raw column expressions (best-effort parser for simple references/functions)
+   * @param cols - Raw column expressions
+   * @returns Column selection result with updated state and added columns
+   */
+  selectRaw(cols: string[]): ColumnSelectionResult {
+    const newCols = cols.map(col => parseRawColumn(col, this.table.name, this.state.ast.ctes));
+    const nextState = this.state.withColumns(newCols);
+    return { state: nextState, addedColumns: newCols };
+  }
+
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param name - Name of the CTE
+   * @param query - Query for the CTE
+   * @param columns - Optional column names for the CTE
+   * @param recursive - Whether the CTE is recursive
+   * @returns Updated query state with CTE
+   */
+  withCte(name: string, query: SelectQueryNode, columns?: string[], recursive = false): SelectQueryState {
+    const cte: CommonTableExpressionNode = {
+      type: 'CommonTableExpression',
+      name,
+      query,
+      columns,
+      recursive
+    };
+
+    return this.state.withCte(cte);
+  }
+
+  /**
+   * Selects a subquery as a column
+   * @param alias - Alias for the subquery
+   * @param query - Subquery to select
+   * @returns Updated query state with subquery selection
+   */
+  selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState {
+    const node: ScalarSubqueryNode = { type: 'ScalarSubquery', query, alias };
+    return this.state.withColumns([node]);
+  }
+
+  /**
+   * Adds a JOIN clause to the query
+   * @param join - Join node to add
+   * @returns Updated query state with JOIN
+   */
+  withJoin(join: JoinNode): SelectQueryState {
+    return this.state.withJoin(join);
+  }
+
+  /**
+   * Adds a WHERE clause to the query
+   * @param expr - Expression for the WHERE clause
+   * @returns Updated query state with WHERE clause
+   */
+  withWhere(expr: ExpressionNode): SelectQueryState {
+    const combined = this.combineExpressions(this.state.ast.where, expr);
+    return this.state.withWhere(combined);
+  }
+
+  /**
+   * Adds a GROUP BY clause to the query
+   * @param col - Column to group by
+   * @returns Updated query state with GROUP BY clause
+   */
+  withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState {
+    const node = buildColumnNode(this.table, col);
+    return this.state.withGroupBy([node]);
+  }
+
+  /**
+   * Adds a HAVING clause to the query
+   * @param expr - Expression for the HAVING clause
+   * @returns Updated query state with HAVING clause
+   */
+  withHaving(expr: ExpressionNode): SelectQueryState {
+    const combined = this.combineExpressions(this.state.ast.having, expr);
+    return this.state.withHaving(combined);
+  }
+
+  /**
+   * Adds an ORDER BY clause to the query
+   * @param col - Column to order by
+   * @param direction - Order direction (ASC/DESC)
+   * @returns Updated query state with ORDER BY clause
+   */
+  withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState {
+    const node = buildColumnNode(this.table, col);
+    return this.state.withOrderBy([{ type: 'OrderBy', column: node, direction }]);
+  }
+
+  /**
+   * Adds a DISTINCT clause to the query
+   * @param cols - Columns to make distinct
+   * @returns Updated query state with DISTINCT clause
+   */
+  withDistinct(cols: ColumnNode[]): SelectQueryState {
+    return this.state.withDistinct(cols);
+  }
+
+  /**
+   * Adds a LIMIT clause to the query
+   * @param limit - Maximum number of rows to return
+   * @returns Updated query state with LIMIT clause
+   */
+  withLimit(limit: number): SelectQueryState {
+    return this.state.withLimit(limit);
+  }
+
+  /**
+   * Adds an OFFSET clause to the query
+   * @param offset - Number of rows to skip
+   * @returns Updated query state with OFFSET clause
+   */
+  withOffset(offset: number): SelectQueryState {
+    return this.state.withOffset(offset);
+  }
+
+  /**
+   * Combines expressions with AND operator
+   * @param existing - Existing expression
+   * @param next - New expression to combine
+   * @returns Combined expression
+   */
+  private combineExpressions(existing: ExpressionNode | undefined, next: ExpressionNode): ExpressionNode {
+    return existing ? and(existing, next) : next;
+  }
+
+}

package/src/{utils → query-builder}/raw-column-parser.ts

@@ -1,32 +1,32 @@
-import { ColumnNode } from '../ast/expression';
-import { CommonTableExpressionNode } from '../ast/query';
-
-/**
- * Best-effort helper that tries to convert a raw column expression into a `ColumnNode`.
- * This parser is intentionally limited; use it only for simple references or function calls.
- */
-export const parseRawColumn = (
-  col: string,
-  tableName: string,
-  ctes?: CommonTableExpressionNode[]
-): ColumnNode => {
-  if (col.includes('(')) {
-    const [fn, rest] = col.split('(');
-    const colName = rest.replace(')', '');
-    const [table, name] = colName.includes('.') ? colName.split('.') : [tableName, colName];
-    return { type: 'Column', table, name, alias: col };
-  }
-
-  if (col.includes('.')) {
-    const [potentialCteName, columnName] = col.split('.');
-    const hasCte = ctes?.some(cte => cte.name === potentialCteName);
-
-    if (hasCte) {
-      return { type: 'Column', table: tableName, name: col };
-    }
-
-    return { type: 'Column', table: potentialCteName, name: columnName };
-  }
-
-  return { type: 'Column', table: tableName, name: col };
-};
+import { ColumnNode } from '../core/ast/expression.js';
+import { CommonTableExpressionNode } from '../core/ast/query.js';
+
+/**
+ * Best-effort helper that tries to convert a raw column expression into a `ColumnNode`.
+ * This parser is intentionally limited; use it only for simple references or function calls.
+ */
+export const parseRawColumn = (
+  col: string,
+  tableName: string,
+  ctes?: CommonTableExpressionNode[]
+): ColumnNode => {
+  if (col.includes('(')) {
+    const [fn, rest] = col.split('(');
+    const colName = rest.replace(')', '');
+    const [table, name] = colName.includes('.') ? colName.split('.') : [tableName, colName];
+    return { type: 'Column', table, name, alias: col };
+  }
+
+  if (col.includes('.')) {
+    const [potentialCteName, columnName] = col.split('.');
+    const hasCte = ctes?.some(cte => cte.name === potentialCteName);
+
+    if (hasCte) {
+      return { type: 'Column', table: tableName, name: col };
+    }
+
+    return { type: 'Column', table: potentialCteName, name: columnName };
+  }
+
+  return { type: 'Column', table: tableName, name: col };
+};