metal-orm 1.0.15 → 1.0.17

package/src/query-builder/update-query-state.ts

@@ -1,7 +1,21 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnNode, ExpressionNode, valueToOperand } from '../core/ast/expression.js';
+import { ColumnNode, ExpressionNode, OperandNode, isOperandNode, valueToOperand } from '../core/ast/expression.js';
 import { TableNode, UpdateQueryNode, UpdateAssignmentNode } from '../core/ast/query.js';
 import { createTableNode } from '../core/ast/builders.js';
+type LiteralValue = string | number | boolean | null;
+type UpdateValue = OperandNode | LiteralValue;
+
+const isUpdateValue = (value: unknown): value is UpdateValue => {
+  if (value === null) return true;
+  switch (typeof value) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+      return true;
+    default:
+      return isOperandNode(value);
+  }
+};
 
 /**
  * Immutable state for UPDATE queries
@@ -24,14 +38,22 @@ export class UpdateQueryState {
   }
 
   withSet(values: Record<string, unknown>): UpdateQueryState {
-    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, value]) => ({
-      column: {
-        type: 'Column',
-        table: this.table.name,
-        name: column
-      },
-      value: valueToOperand(value)
-    }));
+    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, rawValue]) => {
+      if (!isUpdateValue(rawValue)) {
+        throw new Error(
+          `Invalid update value for column "${column}": only primitives, null, or OperandNodes are allowed`
+        );
+      }
+
+      return {
+        column: {
+          type: 'Column',
+          table: this.table.name,
+          name: column
+        },
+        value: valueToOperand(rawValue)
+      };
+    });
 
     return this.clone({
       ...this.ast,

package/src/schema/types.ts

@@ -1,5 +1,5 @@
-import { ColumnDef } from './column.js';
-import { TableDef } from './table.js';
+import { ColumnDef } from './column.js';
+import { TableDef } from './table.js';
 import {
   RelationDef,
   HasManyRelation,
@@ -7,10 +7,20 @@ import {
   BelongsToRelation,
   BelongsToManyRelation
 } from './relation.js';
-
-/**
- * Maps a ColumnDef to its TypeScript type representation
- */
+
+/**
+ * Resolves a relation definition to its target table type.
+ */
+export type RelationTargetTable<TRel extends RelationDef> =
+  TRel extends HasManyRelation<infer TTarget> ? TTarget :
+  TRel extends HasOneRelation<infer TTarget> ? TTarget :
+  TRel extends BelongsToRelation<infer TTarget> ? TTarget :
+  TRel extends BelongsToManyRelation<infer TTarget> ? TTarget :
+  never;
+
+/**
+ * Maps a ColumnDef to its TypeScript type representation
+ */
 export type ColumnToTs<T extends ColumnDef> =
   T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
   T['type'] extends 'BIGINT' | 'bigint' ? number | bigint :

package/src/orm/orm-context.ts

@@ -1,159 +0,0 @@
-import type { Dialect } from '../core/dialect/abstract.js';
-import type { RelationDef } from '../schema/relation.js';
-import type { TableDef } from '../schema/table.js';
-import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
-import { DomainEventBus, DomainEventHandler as DomainEventHandlerFn, addDomainEvent } from './domain-event-bus.js';
-import { IdentityMap } from './identity-map.js';
-import { RelationChangeProcessor } from './relation-change-processor.js';
-import { runInTransaction } from './transaction-runner.js';
-import { UnitOfWork } from './unit-of-work.js';
-import {
-  EntityStatus,
-  HasDomainEvents,
-  RelationChange,
-  RelationChangeEntry,
-  RelationKey,
-  TrackedEntity
-} from './runtime-types.js';
-import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
-
-export interface OrmInterceptor {
-  beforeFlush?(ctx: OrmContext): Promise<void> | void;
-  afterFlush?(ctx: OrmContext): Promise<void> | void;
-}
-
-export type DomainEventHandler = DomainEventHandlerFn<OrmContext>;
-
-export interface OrmContextOptions {
-  dialect: Dialect;
-  executor: DbExecutor;
-  interceptors?: OrmInterceptor[];
-  domainEventHandlers?: Record<string, DomainEventHandler[]>;
-  queryLogger?: QueryLogger;
-}
-
-export class OrmContext {
-  private readonly identityMap = new IdentityMap();
-  private readonly executorWithLogging: DbExecutor;
-  private readonly unitOfWork: UnitOfWork;
-  private readonly relationChanges: RelationChangeProcessor;
-  private readonly interceptors: OrmInterceptor[];
-  private readonly domainEvents: DomainEventBus<OrmContext>;
-
-  constructor(private readonly options: OrmContextOptions) {
-    this.interceptors = [...(options.interceptors ?? [])];
-    this.executorWithLogging = createQueryLoggingExecutor(options.executor, options.queryLogger);
-    this.unitOfWork = new UnitOfWork(
-      options.dialect,
-      this.executorWithLogging,
-      this.identityMap,
-      () => this
-    );
-    this.relationChanges = new RelationChangeProcessor(
-      this.unitOfWork,
-      options.dialect,
-      this.executorWithLogging
-    );
-    this.domainEvents = new DomainEventBus<OrmContext>(options.domainEventHandlers);
-  }
-
-  get dialect(): Dialect {
-    return this.options.dialect;
-  }
-
-  get executor(): DbExecutor {
-    return this.executorWithLogging;
-  }
-
-  get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
-    return this.unitOfWork.identityBuckets;
-  }
-
-  get tracked(): TrackedEntity[] {
-    return this.unitOfWork.getTracked();
-  }
-
-  getEntity(table: TableDef, pk: string | number): any | undefined {
-    return this.unitOfWork.getEntity(table, pk);
-  }
-
-  setEntity(table: TableDef, pk: string | number, entity: any): void {
-    this.unitOfWork.setEntity(table, pk, entity);
-  }
-
-  trackNew(table: TableDef, entity: any, pk?: string | number): void {
-    this.unitOfWork.trackNew(table, entity, pk);
-  }
-
-  trackManaged(table: TableDef, pk: string | number, entity: any): void {
-    this.unitOfWork.trackManaged(table, pk, entity);
-  }
-
-  markDirty(entity: any): void {
-    this.unitOfWork.markDirty(entity);
-  }
-
-  markRemoved(entity: any): void {
-    this.unitOfWork.markRemoved(entity);
-  }
-
-  registerRelationChange(
-    root: any,
-    relationKey: RelationKey,
-    rootTable: TableDef,
-    relationName: string,
-    relation: RelationDef,
-    change: RelationChange<any>
-  ): void {
-    const entry: RelationChangeEntry = {
-      root,
-      relationKey,
-      rootTable,
-      relationName,
-      relation,
-      change
-    };
-    this.relationChanges.registerChange(entry);
-  }
-
-  registerInterceptor(interceptor: OrmInterceptor): void {
-    this.interceptors.push(interceptor);
-  }
-
-  registerDomainEventHandler(name: string, handler: DomainEventHandler): void {
-    this.domainEvents.register(name, handler);
-  }
-
-  async saveChanges(): Promise<void> {
-    await runInTransaction(this.executor, async () => {
-      for (const interceptor of this.interceptors) {
-        await interceptor.beforeFlush?.(this);
-      }
-
-      await this.unitOfWork.flush();
-      await this.relationChanges.process();
-      await this.unitOfWork.flush();
-
-      for (const interceptor of this.interceptors) {
-        await interceptor.afterFlush?.(this);
-      }
-    });
-
-    await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
-  }
-
-  getEntitiesForTable(table: TableDef): TrackedEntity[] {
-    return this.unitOfWork.getEntitiesForTable(table);
-  }
-}
-
-export { addDomainEvent };
-export { EntityStatus };
-export type {
-  QueryResult,
-  DbExecutor,
-  RelationKey,
-  RelationChange,
-  HasDomainEvents
-};
-export type { QueryLogEntry, QueryLogger } from './query-logger.js';