metal-orm 1.1.11 → 1.1.16

package/src/orm/als.ts

@@ -1,58 +1,58 @@
-// In a real Node environment: import { AsyncLocalStorage } from 'node:async_hooks';
-
-/**
- * Browser-compatible implementation of AsyncLocalStorage.
- * Provides a simple in-memory store for browser environments while maintaining
- * Node.js AsyncLocalStorage API compatibility.
- * 
- * @template T Type of the data stored in the async context
- */
-export class AsyncLocalStorage<T> {
-  private store: T | undefined;
-
-  /**
-   * Executes a callback function within a context containing the specified store value.
-   * The store value is only available during the callback's execution and is automatically
-   * cleared afterward.
-   * 
-   * @param store - The context value to make available during callback execution
-   * @param callback - Function to execute with the store value available
-   * @returns Result of the callback function execution
-   * 
-   * @example
-   * ```
-   * const als = new AsyncLocalStorage<number>();
-   * als.run(42, () => {
-   *   console.log(als.getStore()); // Outputs: 42
-   * });
-   * ```
-   */
-  run<R>(store: T, callback: () => R): R {
-    this.store = store;
-    try {
-      return callback();
-    } finally {
-      this.store = undefined;
-    }
-  }
-
-  /**
-   * Retrieves the current store value from the async context.
-   * Returns undefined if called outside of a `run()` callback execution.
-   * 
-   * @returns Current store value or undefined if no context exists
-   * 
-   * @example
-   * ```
-   * const als = new AsyncLocalStorage<string>();
-   * console.log(als.getStore()); // Outputs: undefined
-   * 
-   * als.run('hello', () => {
-   *   console.log(als.getStore()); // Outputs: 'hello'
-   * });
-   * ```
-   */
-  getStore(): T | undefined {
-    return this.store;
-  }
-}
+// In a real Node environment: import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Browser-compatible implementation of AsyncLocalStorage.
+ * Provides a simple in-memory store for browser environments while maintaining
+ * Node.js AsyncLocalStorage API compatibility.
+ * 
+ * @template T Type of the data stored in the async context
+ */
+export class AsyncLocalStorage<T> {
+  private store: T | undefined;
+
+  /**
+   * Executes a callback function within a context containing the specified store value.
+   * The store value is only available during the callback's execution and is automatically
+   * cleared afterward.
+   * 
+   * @param store - The context value to make available during callback execution
+   * @param callback - Function to execute with the store value available
+   * @returns Result of the callback function execution
+   * 
+   * @example
+   * ```
+   * const als = new AsyncLocalStorage<number>();
+   * als.run(42, () => {
+   *   console.log(als.getStore()); // Outputs: 42
+   * });
+   * ```
+   */
+  run<R>(store: T, callback: () => R): R {
+    this.store = store;
+    try {
+      return callback();
+    } finally {
+      this.store = undefined;
+    }
+  }
+
+  /**
+   * Retrieves the current store value from the async context.
+   * Returns undefined if called outside of a `run()` callback execution.
+   * 
+   * @returns Current store value or undefined if no context exists
+   * 
+   * @example
+   * ```
+   * const als = new AsyncLocalStorage<string>();
+   * console.log(als.getStore()); // Outputs: undefined
+   * 
+   * als.run('hello', () => {
+   *   console.log(als.getStore()); // Outputs: 'hello'
+   * });
+   * ```
+   */
+  getStore(): T | undefined {
+    return this.store;
+  }
+}

package/src/orm/domain-event-bus.ts

@@ -1,119 +1,119 @@
-import type { DomainEvent, HasDomainEvents, TrackedEntity } from './runtime-types.js';
-
-/**
- * Extracts domain events of a specific type.
- * @template E - The domain event type
- * @template TType - The specific event type
- */
-type EventOfType<E extends DomainEvent, TType extends E['type']> =
-  Extract<E, { type: TType }>;
-
-/**
- * Domain event handler function.
- * @template E - The domain event type
- * @template Context - The context type
- * @param event - The domain event
- * @param ctx - The context
- */
-export type DomainEventHandler<E extends DomainEvent, Context> =
-  (event: E, ctx: Context) => Promise<void> | void;
-
-/**
- * Initial handlers for domain events.
- * @template E - The domain event type
- * @template Context - The context type
- */
-export type InitialHandlers<E extends DomainEvent, Context> = {
-  [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
-};
-
-/**
- * Domain event bus for managing and dispatching domain events.
- * @template E - The domain event type
- * @template Context - The context type
- */
-export class DomainEventBus<E extends DomainEvent, Context> {
-  private readonly handlers = new Map<E['type'], DomainEventHandler<E, Context>[]>();
-
-  /**
-   * Creates a new DomainEventBus instance.
-   * @param initialHandlers - Optional initial event handlers
-   */
-  constructor(initialHandlers?: InitialHandlers<E, Context>) {
-    if (initialHandlers) {
-      for (const key in initialHandlers) {
-        const type = key as E['type'];
-        const list = initialHandlers[type] ?? [];
-        this.handlers.set(type, [...(list as DomainEventHandler<E, Context>[])]);
-      }
-    }
-  }
-
-  /**
-   * Registers an event handler for a specific event type.
-   * @template TType - The event type
-   * @param type - The event type
-   * @param handler - The event handler
-   */
-  on<TType extends E['type']>(
-    type: TType,
-    handler: DomainEventHandler<EventOfType<E, TType>, Context>
-  ): void {
-    const key = type as E['type'];
-    const existing = this.handlers.get(key) ?? [];
-    existing.push(handler as unknown as DomainEventHandler<E, Context>);
-    this.handlers.set(key, existing);
-  }
-
-  /**
-   * Registers an event handler for a specific event type (alias for on).
-   * @template TType - The event type
-   * @param type - The event type
-   * @param handler - The event handler
-   */
-  register<TType extends E['type']>(
-    type: TType,
-    handler: DomainEventHandler<EventOfType<E, TType>, Context>
-  ): void {
-    this.on(type, handler);
-  }
-
-  /**
-   * Dispatches domain events for tracked entities.
-   * @param trackedEntities - Iterable of tracked entities
-   * @param ctx - The context to pass to handlers
-   */
-  async dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void> {
-    for (const tracked of trackedEntities) {
-      const entity = tracked.entity as HasDomainEvents<E>;
-      if (!entity.domainEvents?.length) continue;
-
-      for (const event of entity.domainEvents) {
-        const handlers = this.handlers.get(event.type as E['type']);
-        if (!handlers?.length) continue;
-
-        for (const handler of handlers) {
-          await handler(event, ctx);
-        }
-      }
-
-      entity.domainEvents = [];
-    }
-  }
-}
-
-/**
- * Adds a domain event to an entity.
- * @template E - The domain event type
- * @param entity - The entity to add the event to
- * @param event - The domain event to add
- */
-export const addDomainEvent = <E extends DomainEvent>(
-  entity: HasDomainEvents<E>,
-  event: E
-): void => {
-  if (!entity.domainEvents) {
-    entity.domainEvents = [];
-  }
-  entity.domainEvents.push(event);
-};
+import type { DomainEvent, HasDomainEvents, TrackedEntity } from './runtime-types.js';
+
+/**
+ * Extracts domain events of a specific type.
+ * @template E - The domain event type
+ * @template TType - The specific event type
+ */
+type EventOfType<E extends DomainEvent, TType extends E['type']> =
+  Extract<E, { type: TType }>;
+
+/**
+ * Domain event handler function.
+ * @template E - The domain event type
+ * @template Context - The context type
+ * @param event - The domain event
+ * @param ctx - The context
+ */
+export type DomainEventHandler<E extends DomainEvent, Context> =
+  (event: E, ctx: Context) => Promise<void> | void;
+
+/**
+ * Initial handlers for domain events.
+ * @template E - The domain event type
+ * @template Context - The context type
+ */
+export type InitialHandlers<E extends DomainEvent, Context> = {
+  [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
+};
+
+/**
+ * Domain event bus for managing and dispatching domain events.
+ * @template E - The domain event type
+ * @template Context - The context type
+ */
+export class DomainEventBus<E extends DomainEvent, Context> {
+  private readonly handlers = new Map<E['type'], DomainEventHandler<E, Context>[]>();
+
+  /**
+   * Creates a new DomainEventBus instance.
+   * @param initialHandlers - Optional initial event handlers
+   */
+  constructor(initialHandlers?: InitialHandlers<E, Context>) {
+    if (initialHandlers) {
+      for (const key in initialHandlers) {
+        const type = key as E['type'];
+        const list = initialHandlers[type] ?? [];
+        this.handlers.set(type, [...(list as DomainEventHandler<E, Context>[])]);
+      }
+    }
+  }
+
+  /**
+   * Registers an event handler for a specific event type.
+   * @template TType - The event type
+   * @param type - The event type
+   * @param handler - The event handler
+   */
+  on<TType extends E['type']>(
+    type: TType,
+    handler: DomainEventHandler<EventOfType<E, TType>, Context>
+  ): void {
+    const key = type as E['type'];
+    const existing = this.handlers.get(key) ?? [];
+    existing.push(handler as unknown as DomainEventHandler<E, Context>);
+    this.handlers.set(key, existing);
+  }
+
+  /**
+   * Registers an event handler for a specific event type (alias for on).
+   * @template TType - The event type
+   * @param type - The event type
+   * @param handler - The event handler
+   */
+  register<TType extends E['type']>(
+    type: TType,
+    handler: DomainEventHandler<EventOfType<E, TType>, Context>
+  ): void {
+    this.on(type, handler);
+  }
+
+  /**
+   * Dispatches domain events for tracked entities.
+   * @param trackedEntities - Iterable of tracked entities
+   * @param ctx - The context to pass to handlers
+   */
+  async dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void> {
+    for (const tracked of trackedEntities) {
+      const entity = tracked.entity as HasDomainEvents<E>;
+      if (!entity.domainEvents?.length) continue;
+
+      for (const event of entity.domainEvents) {
+        const handlers = this.handlers.get(event.type as E['type']);
+        if (!handlers?.length) continue;
+
+        for (const handler of handlers) {
+          await handler(event, ctx);
+        }
+      }
+
+      entity.domainEvents = [];
+    }
+  }
+}
+
+/**
+ * Adds a domain event to an entity.
+ * @template E - The domain event type
+ * @param entity - The entity to add the event to
+ * @param event - The domain event to add
+ */
+export const addDomainEvent = <E extends DomainEvent>(
+  entity: HasDomainEvents<E>,
+  event: E
+): void => {
+  if (!entity.domainEvents) {
+    entity.domainEvents = [];
+  }
+  entity.domainEvents.push(event);
+};

package/src/orm/entity-context.ts

@@ -1,86 +1,86 @@
-import { Dialect } from '../core/dialect/abstract.js';
-import type { DbExecutor } from '../core/execution/db-executor.js';
-import { TableDef } from '../schema/table.js';
-import { RelationDef } from '../schema/relation.js';
-import { RelationChange, RelationKey, TrackedEntity } from './runtime-types.js';
-
-export type PrimaryKey = string | number;
-
-/**
- * Interface for entity context providing entity tracking and management.
- */
-export interface EntityContext {
-    /** The database dialect */
-    dialect: Dialect;
-    /** The database executor */
-    executor: DbExecutor;
-
-    /**
-     * Gets an entity by table and primary key.
-     * @param table - The table definition
-     * @param pk - The primary key value
-     * @returns The entity or undefined
-     */
-    getEntity(table: TableDef, pk: PrimaryKey): object | undefined;
-
-    /**
-     * Sets an entity in the context.
-     * @param table - The table definition
-     * @param pk - The primary key value
-     * @param entity - The entity to set
-     */
-    setEntity(table: TableDef, pk: PrimaryKey, entity: object): void;
-
-    /**
-     * Tracks a new entity.
-     * @param table - The table definition
-     * @param entity - The new entity
-     * @param pk - Optional primary key
-     */
-    trackNew(table: TableDef, entity: object, pk?: PrimaryKey): void;
-
-    /**
-     * Tracks a managed entity.
-     * @param table - The table definition
-     * @param pk - The primary key
-     * @param entity - The managed entity
-     */
-    trackManaged(table: TableDef, pk: PrimaryKey, entity: object): void;
-
-    /**
-     * Marks an entity as dirty.
-     * @param entity - The entity to mark
-     */
-    markDirty(entity: object): void;
-
-    /**
-     * Marks an entity as removed.
-     * @param entity - The entity to mark
-     */
-    markRemoved(entity: object): void;
-
-    /**
-     * Gets all tracked entities for a table.
-     * @param table - The table definition
-     * @returns Array of tracked entities
-     */
-    getEntitiesForTable(table: TableDef): TrackedEntity[];
-
-    /**
-     * Registers a relation change.
-     * @param root - The root entity
-     * @param relationKey - The relation key
-     * @param rootTable - The root table definition
-     * @param relationName - The relation name
-     * @param relation - The relation definition
-     * @param change - The relation change
-     */
-    registerRelationChange(
-        root: unknown,
-        relationKey: RelationKey,
-        rootTable: TableDef,
-        relationName: string,
-        relation: RelationDef,
-        change: RelationChange<unknown>
-    ): void;
-}
+import { Dialect } from '../core/dialect/abstract.js';
+import type { DbExecutor } from '../core/execution/db-executor.js';
+import { TableDef } from '../schema/table.js';
+import { RelationDef } from '../schema/relation.js';
+import { RelationChange, RelationKey, TrackedEntity } from './runtime-types.js';
+
+export type PrimaryKey = string | number;
+
+/**
+ * Interface for entity context providing entity tracking and management.
+ */
+export interface EntityContext {
+    /** The database dialect */
+    dialect: Dialect;
+    /** The database executor */
+    executor: DbExecutor;
+
+    /**
+     * Gets an entity by table and primary key.
+     * @param table - The table definition
+     * @param pk - The primary key value
+     * @returns The entity or undefined
+     */
+    getEntity(table: TableDef, pk: PrimaryKey): object | undefined;
+
+    /**
+     * Sets an entity in the context.
+     * @param table - The table definition
+     * @param pk - The primary key value
+     * @param entity - The entity to set
+     */
+    setEntity(table: TableDef, pk: PrimaryKey, entity: object): void;
+
+    /**
+     * Tracks a new entity.
+     * @param table - The table definition
+     * @param entity - The new entity
+     * @param pk - Optional primary key
+     */
+    trackNew(table: TableDef, entity: object, pk?: PrimaryKey): void;
+
+    /**
+     * Tracks a managed entity.
+     * @param table - The table definition
+     * @param pk - The primary key
+     * @param entity - The managed entity
+     */
+    trackManaged(table: TableDef, pk: PrimaryKey, entity: object): void;
+
+    /**
+     * Marks an entity as dirty.
+     * @param entity - The entity to mark
+     */
+    markDirty(entity: object): void;
+
+    /**
+     * Marks an entity as removed.
+     * @param entity - The entity to mark
+     */
+    markRemoved(entity: object): void;
+
+    /**
+     * Gets all tracked entities for a table.
+     * @param table - The table definition
+     * @returns Array of tracked entities
+     */
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+
+    /**
+     * Registers a relation change.
+     * @param root - The root entity
+     * @param relationKey - The relation key
+     * @param rootTable - The root table definition
+     * @param relationName - The relation name
+     * @param relation - The relation definition
+     * @param change - The relation change
+     */
+    registerRelationChange(
+        root: unknown,
+        relationKey: RelationKey,
+        rootTable: TableDef,
+        relationName: string,
+        relation: RelationDef,
+        change: RelationChange<unknown>
+    ): void;
+}