metal-orm 1.1.11 → 1.1.16

package/src/query/index.ts

@@ -1,74 +1,74 @@
-import { TableDef } from '../schema/table.js';
-import { SelectQueryBuilder } from '../query-builder/select.js';
-import { InsertQueryBuilder } from '../query-builder/insert.js';
-import { UpdateQueryBuilder } from '../query-builder/update.js';
+import { TableDef } from '../schema/table.js';
+import { SelectQueryBuilder } from '../query-builder/select.js';
+import { InsertQueryBuilder } from '../query-builder/insert.js';
+import { UpdateQueryBuilder } from '../query-builder/update.js';
 import { DeleteQueryBuilder } from '../query-builder/delete.js';
 import { callProcedure } from '../query-builder/procedure-call.js';
-import { QueryTarget, resolveTable } from './target.js';
-
-/**
- * Creates a SELECT query builder for the specified table or entity.
- *
- * @template TTable - The table definition type
- * @param target - The table definition or entity constructor to query from
- * @returns A new SelectQueryBuilder instance for building SELECT queries
- *
- * @example
- * ```typescript
- * const query = selectFrom(UserTable).select('id', 'name');
- * ```
- */
-export const selectFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): SelectQueryBuilder<unknown, TTable> => {
-    const table = resolveTable(target);
-    return new SelectQueryBuilder(table);
-};
-
-/**
- * Creates an INSERT query builder for the specified table or entity.
- *
- * @template TTable - The table definition type
- * @param target - The table definition or entity constructor to insert into
- * @returns A new InsertQueryBuilder instance for building INSERT queries
- *
- * @example
- * ```typescript
- * const query = insertInto(UserTable).values({ name: 'John', email: 'john@example.com' });
- * ```
- */
-export const insertInto = <TTable extends TableDef>(target: QueryTarget<TTable>): InsertQueryBuilder<unknown> => {
-    const table = resolveTable(target);
-    return new InsertQueryBuilder(table);
-};
-
-/**
- * Creates an UPDATE query builder for the specified table or entity.
- *
- * @template TTable - The table definition type
- * @param target - The table definition or entity constructor to update
- * @returns A new UpdateQueryBuilder instance for building UPDATE queries
- *
- * @example
- * ```typescript
- * const query = update(UserTable).set({ name: 'Jane' }).where(eq(UserTable.id, 1));
- * ```
- */
-export const update = <TTable extends TableDef>(target: QueryTarget<TTable>): UpdateQueryBuilder<unknown> => {
-    const table = resolveTable(target);
-    return new UpdateQueryBuilder(table);
-};
-
-/**
- * Creates a DELETE query builder for the specified table or entity.
- *
- * @template TTable - The table definition type
- * @param target - The table definition or entity constructor to delete from
- * @returns A new DeleteQueryBuilder instance for building DELETE queries
- *
- * @example
- * ```typescript
- * const query = deleteFrom(UserTable).where(eq(UserTable.id, 1));
- * ```
- */
+import { QueryTarget, resolveTable } from './target.js';
+
+/**
+ * Creates a SELECT query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to query from
+ * @returns A new SelectQueryBuilder instance for building SELECT queries
+ *
+ * @example
+ * ```typescript
+ * const query = selectFrom(UserTable).select('id', 'name');
+ * ```
+ */
+export const selectFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): SelectQueryBuilder<unknown, TTable> => {
+    const table = resolveTable(target);
+    return new SelectQueryBuilder(table);
+};
+
+/**
+ * Creates an INSERT query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to insert into
+ * @returns A new InsertQueryBuilder instance for building INSERT queries
+ *
+ * @example
+ * ```typescript
+ * const query = insertInto(UserTable).values({ name: 'John', email: 'john@example.com' });
+ * ```
+ */
+export const insertInto = <TTable extends TableDef>(target: QueryTarget<TTable>): InsertQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new InsertQueryBuilder(table);
+};
+
+/**
+ * Creates an UPDATE query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to update
+ * @returns A new UpdateQueryBuilder instance for building UPDATE queries
+ *
+ * @example
+ * ```typescript
+ * const query = update(UserTable).set({ name: 'Jane' }).where(eq(UserTable.id, 1));
+ * ```
+ */
+export const update = <TTable extends TableDef>(target: QueryTarget<TTable>): UpdateQueryBuilder<unknown> => {
+    const table = resolveTable(target);
+    return new UpdateQueryBuilder(table);
+};
+
+/**
+ * Creates a DELETE query builder for the specified table or entity.
+ *
+ * @template TTable - The table definition type
+ * @param target - The table definition or entity constructor to delete from
+ * @returns A new DeleteQueryBuilder instance for building DELETE queries
+ *
+ * @example
+ * ```typescript
+ * const query = deleteFrom(UserTable).where(eq(UserTable.id, 1));
+ * ```
+ */
 export const deleteFrom = <TTable extends TableDef>(target: QueryTarget<TTable>): DeleteQueryBuilder<unknown> => {
     const table = resolveTable(target);
     return new DeleteQueryBuilder(table);

package/src/query/target.ts

@@ -1,46 +1,46 @@
-import { TableDef } from '../schema/table.js';
-import { isTableDef } from '../schema/table-guards.js';
-import { EntityConstructor } from '../orm/entity-metadata.js';
-import { getTableDefFromEntity } from '../decorators/bootstrap.js';
-
-/**
- * Represents a target for query operations, which can be either a table definition
- * or an entity constructor. This type allows flexible targeting of database tables
- * through either direct table definitions or entity classes decorated with ORM metadata.
- *
- * @template TTable - The table definition type, defaults to TableDef
- */
-export type QueryTarget<TTable extends TableDef = TableDef> = TTable | EntityConstructor;
-
-const resolveEntityTarget = <TTable extends TableDef>(ctor: EntityConstructor): TTable => {
-    const table = getTableDefFromEntity(ctor);
-    if (!table) {
-        throw new Error(`Entity '${ctor.name}' is not registered with decorators`);
-    }
-    return table as TTable;
-};
-
-/**
- * Resolves a QueryTarget to its corresponding table definition.
- *
- * If the target is already a TableDef, it returns it directly.
- * If the target is an EntityConstructor, it retrieves the associated table definition
- * from the entity's metadata.
- *
- * @template TTable - The table definition type
- * @param target - The query target to resolve
- * @returns The resolved table definition
- * @throws Error if the entity constructor is not registered with decorators
- *
- * @example
- * ```typescript
- * const table = resolveTable(UserTable); // Returns UserTable directly
- * const table2 = resolveTable(UserEntity); // Returns table def from UserEntity metadata
- * ```
- */
-export const resolveTable = <TTable extends TableDef>(target: QueryTarget<TTable>): TTable => {
-    if (isTableDef(target)) {
-        return target as TTable;
-    }
-    return resolveEntityTarget(target as EntityConstructor);
-};
+import { TableDef } from '../schema/table.js';
+import { isTableDef } from '../schema/table-guards.js';
+import { EntityConstructor } from '../orm/entity-metadata.js';
+import { getTableDefFromEntity } from '../decorators/bootstrap.js';
+
+/**
+ * Represents a target for query operations, which can be either a table definition
+ * or an entity constructor. This type allows flexible targeting of database tables
+ * through either direct table definitions or entity classes decorated with ORM metadata.
+ *
+ * @template TTable - The table definition type, defaults to TableDef
+ */
+export type QueryTarget<TTable extends TableDef = TableDef> = TTable | EntityConstructor;
+
+const resolveEntityTarget = <TTable extends TableDef>(ctor: EntityConstructor): TTable => {
+    const table = getTableDefFromEntity(ctor);
+    if (!table) {
+        throw new Error(`Entity '${ctor.name}' is not registered with decorators`);
+    }
+    return table as TTable;
+};
+
+/**
+ * Resolves a QueryTarget to its corresponding table definition.
+ *
+ * If the target is already a TableDef, it returns it directly.
+ * If the target is an EntityConstructor, it retrieves the associated table definition
+ * from the entity's metadata.
+ *
+ * @template TTable - The table definition type
+ * @param target - The query target to resolve
+ * @returns The resolved table definition
+ * @throws Error if the entity constructor is not registered with decorators
+ *
+ * @example
+ * ```typescript
+ * const table = resolveTable(UserTable); // Returns UserTable directly
+ * const table2 = resolveTable(UserEntity); // Returns table def from UserEntity metadata
+ * ```
+ */
+export const resolveTable = <TTable extends TableDef>(target: QueryTarget<TTable>): TTable => {
+    if (isTableDef(target)) {
+        return target as TTable;
+    }
+    return resolveEntityTarget(target as EntityConstructor);
+};

package/src/query-builder/column-selector.ts

@@ -1,81 +1,81 @@
-import { ColumnDef } from '../schema/column-types.js';
-import { CaseExpressionNode, ColumnNode, FunctionNode, WindowFunctionNode } from '../core/ast/expression.js';
-import { SelectQueryNode } from '../core/ast/query.js';
-import { buildColumnNode } from '../core/ast/builders.js';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from './select-query-builder-deps.js';
-
-/**
- * Type for column selection input
- */
-type ColumnSelectionInput = Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>;
-
-/**
- * Handles column selection operations for the query builder
- */
-export class ColumnSelector {
-  /**
-   * Creates a new ColumnSelector instance
-   * @param env - Query builder environment
-   */
-  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
-
-  /**
-   * 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: ColumnSelectionInput): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const { state: nextState, addedColumns } = astService.select(columns);
-    return {
-      state: nextState,
-      hydration: context.hydration.onColumnsSelected(nextState, addedColumns)
-    };
-  }
-
-  /**
-   * Selects raw column expressions
-   * @param context - Current query context
-   * @param columns - Raw column expressions
-   * @returns Updated query context with raw column selections
-   */
-  selectRaw(context: SelectQueryBuilderContext, columns: string[]): SelectQueryBuilderContext {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.selectRaw(columns).state;
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * 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 {
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.selectSubquery(alias, query);
-    return { state: nextState, hydration: context.hydration };
-  }
-
-  /**
-   * Adds DISTINCT clause to the query
-   * @param context - Current query context
-   * @param columns - Columns to make distinct
-   * @returns Updated query context with DISTINCT clause
-   */
-  distinct(context: SelectQueryBuilderContext, columns: (ColumnDef | ColumnNode)[]): SelectQueryBuilderContext {
-    const from = context.state.ast.from;
-    const tableRef = from.type === 'Table' && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
-    const nodes = columns.map(col => buildColumnNode(tableRef, col));
-    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
-    const nextState = astService.withDistinct(nodes);
-    return { state: nextState, hydration: context.hydration };
-  }
-}
-
+import { ColumnDef } from '../schema/column-types.js';
+import { CaseExpressionNode, ColumnNode, FunctionNode, WindowFunctionNode } from '../core/ast/expression.js';
+import { SelectQueryNode } from '../core/ast/query.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from './select-query-builder-deps.js';
+
+/**
+ * Type for column selection input
+ */
+type ColumnSelectionInput = Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>;
+
+/**
+ * Handles column selection operations for the query builder
+ */
+export class ColumnSelector {
+  /**
+   * Creates a new ColumnSelector instance
+   * @param env - Query builder environment
+   */
+  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
+
+  /**
+   * 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: ColumnSelectionInput): SelectQueryBuilderContext {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const { state: nextState, addedColumns } = astService.select(columns);
+    return {
+      state: nextState,
+      hydration: context.hydration.onColumnsSelected(nextState, addedColumns)
+    };
+  }
+
+  /**
+   * Selects raw column expressions
+   * @param context - Current query context
+   * @param columns - Raw column expressions
+   * @returns Updated query context with raw column selections
+   */
+  selectRaw(context: SelectQueryBuilderContext, columns: string[]): SelectQueryBuilderContext {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.selectRaw(columns).state;
+    return { state: nextState, hydration: context.hydration };
+  }
+
+  /**
+   * 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 {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.selectSubquery(alias, query);
+    return { state: nextState, hydration: context.hydration };
+  }
+
+  /**
+   * Adds DISTINCT clause to the query
+   * @param context - Current query context
+   * @param columns - Columns to make distinct
+   * @returns Updated query context with DISTINCT clause
+   */
+  distinct(context: SelectQueryBuilderContext, columns: (ColumnDef | ColumnNode)[]): SelectQueryBuilderContext {
+    const from = context.state.ast.from;
+    const tableRef = from.type === 'Table' && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
+    const nodes = columns.map(col => buildColumnNode(tableRef, col));
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.withDistinct(nodes);
+    return { state: nextState, hydration: context.hydration };
+  }
+}
+