metal-orm 1.0.8 → 1.0.9

package/src/orm/unit-of-work.ts

@@ -0,0 +1,232 @@
+import { eq } from '../core/ast/expression.js';
+import type { Dialect, CompiledQuery } from '../core/dialect/abstract.js';
+import { InsertQueryBuilder } from '../query-builder/insert.js';
+import { UpdateQueryBuilder } from '../query-builder/update.js';
+import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import type { TableDef, TableHooks } from '../schema/table.js';
+import type { DbExecutor } from './db-executor.js';
+import { IdentityMap } from './identity-map.js';
+import { EntityStatus } from './runtime-types.js';
+import type { TrackedEntity } from './runtime-types.js';
+
+export class UnitOfWork {
+  private readonly trackedEntities = new Map<any, TrackedEntity>();
+
+  constructor(
+    private readonly dialect: Dialect,
+    private readonly executor: DbExecutor,
+    private readonly identityMap: IdentityMap,
+    private readonly hookContext: () => unknown
+  ) {}
+
+  get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
+    return this.identityMap.bucketsMap;
+  }
+
+  getTracked(): TrackedEntity[] {
+    return Array.from(this.trackedEntities.values());
+  }
+
+  getEntity(table: TableDef, pk: string | number): any | undefined {
+    return this.identityMap.getEntity(table, pk);
+  }
+
+  getEntitiesForTable(table: TableDef): TrackedEntity[] {
+    return this.identityMap.getEntitiesForTable(table);
+  }
+
+  findTracked(entity: any): TrackedEntity | undefined {
+    return this.trackedEntities.get(entity);
+  }
+
+  setEntity(table: TableDef, pk: string | number, entity: any): void {
+    if (pk === null || pk === undefined) return;
+    let tracked = this.trackedEntities.get(entity);
+    if (!tracked) {
+      tracked = {
+        table,
+        entity,
+        pk,
+        status: EntityStatus.Managed,
+        original: this.createSnapshot(table, entity)
+      };
+      this.trackedEntities.set(entity, tracked);
+    } else {
+      tracked.pk = pk;
+    }
+
+    this.registerIdentity(tracked);
+  }
+
+  trackNew(table: TableDef, entity: any, pk?: string | number): void {
+    const tracked: TrackedEntity = {
+      table,
+      entity,
+      pk: pk ?? null,
+      status: EntityStatus.New,
+      original: null
+    };
+    this.trackedEntities.set(entity, tracked);
+    if (pk != null) {
+      this.registerIdentity(tracked);
+    }
+  }
+
+  trackManaged(table: TableDef, pk: string | number, entity: any): void {
+    const tracked: TrackedEntity = {
+      table,
+      entity,
+      pk,
+      status: EntityStatus.Managed,
+      original: this.createSnapshot(table, entity)
+    };
+    this.trackedEntities.set(entity, tracked);
+    this.registerIdentity(tracked);
+  }
+
+  markDirty(entity: any): void {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    if (tracked.status === EntityStatus.New || tracked.status === EntityStatus.Removed) return;
+    tracked.status = EntityStatus.Dirty;
+  }
+
+  markRemoved(entity: any): void {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    tracked.status = EntityStatus.Removed;
+  }
+
+  async flush(): Promise<void> {
+    const toFlush = Array.from(this.trackedEntities.values());
+    for (const tracked of toFlush) {
+      switch (tracked.status) {
+        case EntityStatus.New:
+          await this.flushInsert(tracked);
+          break;
+        case EntityStatus.Dirty:
+          await this.flushUpdate(tracked);
+          break;
+        case EntityStatus.Removed:
+          await this.flushDelete(tracked);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  private async flushInsert(tracked: TrackedEntity): Promise<void> {
+    await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
+
+    const payload = this.extractColumns(tracked.table, tracked.entity);
+    const builder = new InsertQueryBuilder(tracked.table).values(payload);
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+
+    tracked.status = EntityStatus.Managed;
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    tracked.pk = this.getPrimaryKeyValue(tracked);
+    this.registerIdentity(tracked);
+
+    await this.runHook(tracked.table.hooks?.afterInsert, tracked);
+  }
+
+  private async flushUpdate(tracked: TrackedEntity): Promise<void> {
+    if (tracked.pk == null) return;
+    const changes = this.computeChanges(tracked);
+    if (!Object.keys(changes).length) {
+      tracked.status = EntityStatus.Managed;
+      return;
+    }
+
+    await this.runHook(tracked.table.hooks?.beforeUpdate, tracked);
+
+    const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
+    if (!pkColumn) return;
+
+    const builder = new UpdateQueryBuilder(tracked.table)
+      .set(changes)
+      .where(eq(pkColumn, tracked.pk));
+
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+
+    tracked.status = EntityStatus.Managed;
+    tracked.original = this.createSnapshot(tracked.table, tracked.entity);
+    this.registerIdentity(tracked);
+
+    await this.runHook(tracked.table.hooks?.afterUpdate, tracked);
+  }
+
+  private async flushDelete(tracked: TrackedEntity): Promise<void> {
+    if (tracked.pk == null) return;
+    await this.runHook(tracked.table.hooks?.beforeDelete, tracked);
+
+    const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
+    if (!pkColumn) return;
+
+    const builder = new DeleteQueryBuilder(tracked.table).where(eq(pkColumn, tracked.pk));
+    const compiled = builder.compile(this.dialect);
+    await this.executeCompiled(compiled);
+
+    tracked.status = EntityStatus.Detached;
+    this.trackedEntities.delete(tracked.entity);
+    this.identityMap.remove(tracked);
+
+    await this.runHook(tracked.table.hooks?.afterDelete, tracked);
+  }
+
+  private async runHook(
+    hook: TableHooks[keyof TableHooks] | undefined,
+    tracked: TrackedEntity
+  ): Promise<void> {
+    if (!hook) return;
+    await hook(this.hookContext() as any, tracked.entity);
+  }
+
+  private computeChanges(tracked: TrackedEntity): Record<string, unknown> {
+    const snapshot = tracked.original ?? {};
+    const changes: Record<string, unknown> = {};
+    for (const column of Object.keys(tracked.table.columns)) {
+      const current = tracked.entity[column];
+      if (snapshot[column] !== current) {
+        changes[column] = current;
+      }
+    }
+    return changes;
+  }
+
+  private extractColumns(table: TableDef, entity: any): Record<string, unknown> {
+    const payload: Record<string, unknown> = {};
+    for (const column of Object.keys(table.columns)) {
+      payload[column] = entity[column];
+    }
+    return payload;
+  }
+
+  private async executeCompiled(compiled: CompiledQuery): Promise<void> {
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+
+  private registerIdentity(tracked: TrackedEntity): void {
+    if (tracked.pk == null) return;
+    this.identityMap.register(tracked);
+  }
+
+  private createSnapshot(table: TableDef, entity: any): Record<string, any> {
+    const snapshot: Record<string, any> = {};
+    for (const column of Object.keys(table.columns)) {
+      snapshot[column] = entity[column];
+    }
+    return snapshot;
+  }
+
+  private getPrimaryKeyValue(tracked: TrackedEntity): string | number | null {
+    const key = findPrimaryKey(tracked.table);
+    const val = tracked.entity[key];
+    if (val === undefined || val === null) return null;
+    return val;
+  }
+}

package/src/{builder/operations → query-builder}/column-selector.ts

@@ -1,78 +1,78 @@
-import { ColumnDef } from '../../schema/column';
-import { CaseExpressionNode, ColumnNode, FunctionNode, WindowFunctionNode } from '../../ast/expression';
-import { SelectQueryNode } from '../../ast/query';
-import { buildColumnNode } from '../query-ast-service';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
-
-/**
- * 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 nodes = columns.map(col => buildColumnNode(this.env.table, 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.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 nodes = columns.map(col => buildColumnNode(this.env.table, col));
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = astService.withDistinct(nodes);
+    return { state: nextState, hydration: context.hydration };
+  }
+}

package/src/{builder → query-builder}/delete-query-state.ts

@@ -1,42 +1,38 @@
-import { TableDef } from '../schema/table';
-import { ColumnNode, ExpressionNode } from '../ast/expression';
-import { TableNode, DeleteQueryNode } from '../ast/query';
-
-const createTableNode = (table: TableDef): TableNode => ({
-  type: 'Table',
-  name: table.name
-});
-
-/**
- * Maintains immutable state for DELETE queries
- */
-export class DeleteQueryState {
-  public readonly table: TableDef;
-  public readonly ast: DeleteQueryNode;
-
-  constructor(table: TableDef, ast?: DeleteQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'DeleteQuery',
-      from: createTableNode(table)
-    };
-  }
-
-  private clone(nextAst: DeleteQueryNode): DeleteQueryState {
-    return new DeleteQueryState(this.table, nextAst);
-  }
-
-  withWhere(expr: ExpressionNode): DeleteQueryState {
-    return this.clone({
-      ...this.ast,
-      where: expr
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): DeleteQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { TableNode, DeleteQueryNode } from '../core/ast/query.js';
+import { createTableNode } from '../core/ast/builders.js';
+
+/**
+ * Maintains immutable state for DELETE queries
+ */
+export class DeleteQueryState {
+  public readonly table: TableDef;
+  public readonly ast: DeleteQueryNode;
+
+  constructor(table: TableDef, ast?: DeleteQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'DeleteQuery',
+      from: createTableNode(table)
+    };
+  }
+
+  private clone(nextAst: DeleteQueryNode): DeleteQueryState {
+    return new DeleteQueryState(this.table, nextAst);
+  }
+
+  withWhere(expr: ExpressionNode): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}

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

@@ -1,57 +1,46 @@
-import { TableDef } from '../schema/table';
-import { ColumnDef } from '../schema/column';
-import { ColumnNode, ExpressionNode } from '../ast/expression';
-import { CompiledQuery, DeleteCompiler } from '../dialect/abstract';
-import { DeleteQueryNode } from '../ast/query';
-import { DeleteQueryState } from './delete-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 DELETE queries
- */
-export class DeleteQueryBuilder<T> {
-  private readonly table: TableDef;
-  private readonly state: DeleteQueryState;
-
-  constructor(table: TableDef, state?: DeleteQueryState) {
-    this.table = table;
-    this.state = state ?? new DeleteQueryState(table);
-  }
-
-  private clone(state: DeleteQueryState): DeleteQueryBuilder<T> {
-    return new DeleteQueryBuilder(this.table, state);
-  }
-
-  where(expr: ExpressionNode): DeleteQueryBuilder<T> {
-    return this.clone(this.state.withWhere(expr));
-  }
-
-  returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T> {
-    if (!columns.length) return this;
-    const nodes = columns.map(column => buildColumnNode(this.table, column));
-    return this.clone(this.state.withReturning(nodes));
-  }
-
-  compile(compiler: DeleteCompiler): CompiledQuery {
-    return compiler.compileDelete(this.state.ast);
-  }
-
-  toSql(compiler: DeleteCompiler): string {
-    return this.compile(compiler).sql;
-  }
-
-  getAST(): DeleteQueryNode {
-    return this.state.ast;
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { CompiledQuery, DeleteCompiler } from '../core/dialect/abstract.js';
+import { DeleteQueryNode } from '../core/ast/query.js';
+import { DeleteQueryState } from './delete-query-state.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+
+/**
+ * Builder for DELETE queries
+ */
+export class DeleteQueryBuilder<T> {
+  private readonly table: TableDef;
+  private readonly state: DeleteQueryState;
+
+  constructor(table: TableDef, state?: DeleteQueryState) {
+    this.table = table;
+    this.state = state ?? new DeleteQueryState(table);
+  }
+
+  private clone(state: DeleteQueryState): DeleteQueryBuilder<T> {
+    return new DeleteQueryBuilder(this.table, state);
+  }
+
+  where(expr: ExpressionNode): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withWhere(expr));
+  }
+
+  returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T> {
+    if (!columns.length) return this;
+    const nodes = columns.map(column => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+
+  compile(compiler: DeleteCompiler): CompiledQuery {
+    return compiler.compileDelete(this.state.ast);
+  }
+
+  toSql(compiler: DeleteCompiler): string {
+    return this.compile(compiler).sql;
+  }
+
+  getAST(): DeleteQueryNode {
+    return this.state.ast;
+  }
+}