joist-core 2.3.0 → 2.4.0

package/build/PluginManager.d.cts

@@ -0,0 +1,112 @@
+import { JoinRowTodo, Todo } from "./flush/Todo.cjs";
+import { ParsedFindQuery } from "./queries/find/QueryParser.cjs";
+import { RowData } from "./RowData.cjs";
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { EntityManager, FindOperation } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/PluginManager.d.ts
+interface PluginMethods {
+  /**
+   * Called before a field value is retrieved from an entity via getField.
+   *
+   * @param entity The entity instance being accessed
+   * @param field The field name being retrieved
+   */
+  beforeGetField?(entity: Entity, field: string): void;
+  /**
+   * Called before a field value is set on an entity via setField.
+   *
+   * @param entity The entity instance being modified
+   * @param field The field name being set
+   * @param newValue The new value being assigned to the field
+   */
+  beforeSetField?(entity: Entity, field: string, newValue: any): void;
+  /**
+   * Called before a find operation is executed.
+   *
+   * @param meta Metadata for the entity type being queried
+   * @param operation The type of find operation being performed
+   * @param query The parsed query conditions
+   * @param settings Query settings including limit and offset
+   */
+  beforeFind?(meta: EntityMetadata, operation: FindOperation, query: ParsedFindQuery, settings: {
+    limit?: number;
+    offset?: number;
+    allowMultipleLeftJoins?: boolean;
+    optimizeJoinsToExists?: boolean;
+    pruneJoins?: boolean;
+    keepAliases?: string[];
+  }): void;
+  /**
+   * Called after a find operation has been executed to observe the raw database rows.
+   *
+   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,
+   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.
+   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;
+   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is
+   * unsupported and is not guaranteed to affect entity hydration.
+   *
+   * @param meta Metadata for the entity type that was queried
+   * @param operation The type of find operation that was performed
+   * @param rows A read-only view of the raw database rows returned from the query
+   */
+  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;
+  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;
+  afterValidate?(entities: readonly Entity[]): Promise<void> | void;
+  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
+}
+declare const emsSymbol: unique symbol;
+/**
+ * Base class for plugins that hook into entity lifecycle events.
+ *
+ * Plugins can implement any of the PluginMethods to intercept entity operations
+ * and are automatically registered with the EntityManager when added via PluginManager.
+ */
+declare abstract class Plugin {
+  [emsSymbol]: WeakRef<EntityManager>[];
+  maybeCloneForNewEm(): this | undefined;
+  get ems(): readonly EntityManager[];
+}
+interface Plugin extends PluginMethods {}
+/**
+ * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
+ *
+ * The PluginManager optimizes callback dispatch by only creating dispatcher methods
+ * for callbacks that have at least one registered plugin, making unused plugin hooks
+ * zero-cost at runtime.
+ */
+declare class PluginManager implements Required<PluginMethods> {
+  #private;
+  readonly em: EntityManager;
+  constructor(em: EntityManager);
+  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */
+  hasHook(method: keyof PluginMethods): boolean;
+  /**
+   * Registers a plugin with this EntityManager.
+   *
+   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,
+   * enabling lazy initialization of only the hooks that are actually used.
+   *
+   * @throws Error if the plugin is already registered with another EntityManager
+   */
+  addPlugin(plugin: Plugin): void;
+  get plugins(): readonly Plugin[];
+  cloneTo(other: PluginManager): void;
+  beforeGetField(entity: Entity, field: string): void;
+  beforeSetField(entity: Entity, field: string, newValue: any): void;
+  beforeFind(meta: EntityMetadata, operation: FindOperation, query: ParsedFindQuery, settings: {
+    limit?: number;
+    offset?: number;
+    allowMultipleLeftJoins?: boolean;
+    optimizeJoinsToExists?: boolean;
+    pruneJoins?: boolean;
+    keepAliases?: string[];
+  }): void;
+  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;
+  beforeValidate(entities: readonly Entity[]): Promise<void> | void;
+  afterValidate(entities: readonly Entity[]): Promise<void> | void;
+  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
+}
+//#endregion
+export { Plugin, PluginManager };
+//# sourceMappingURL=PluginManager.d.cts.map

package/build/PluginManager.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginManager.d.cts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;uBAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;UASL,eAAe;;;;;;;;cASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}

package/build/PluginManager.d.mts

@@ -0,0 +1,112 @@
+import { JoinRowTodo, Todo } from "./flush/Todo.mjs";
+import { ParsedFindQuery } from "./queries/find/QueryParser.mjs";
+import { RowData } from "./RowData.mjs";
+import { EntityMetadata } from "./EntityMetadata.mjs";
+import { EntityManager, FindOperation } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/PluginManager.d.ts
+interface PluginMethods {
+  /**
+   * Called before a field value is retrieved from an entity via getField.
+   *
+   * @param entity The entity instance being accessed
+   * @param field The field name being retrieved
+   */
+  beforeGetField?(entity: Entity, field: string): void;
+  /**
+   * Called before a field value is set on an entity via setField.
+   *
+   * @param entity The entity instance being modified
+   * @param field The field name being set
+   * @param newValue The new value being assigned to the field
+   */
+  beforeSetField?(entity: Entity, field: string, newValue: any): void;
+  /**
+   * Called before a find operation is executed.
+   *
+   * @param meta Metadata for the entity type being queried
+   * @param operation The type of find operation being performed
+   * @param query The parsed query conditions
+   * @param settings Query settings including limit and offset
+   */
+  beforeFind?(meta: EntityMetadata, operation: FindOperation, query: ParsedFindQuery, settings: {
+    limit?: number;
+    offset?: number;
+    allowMultipleLeftJoins?: boolean;
+    optimizeJoinsToExists?: boolean;
+    pruneJoins?: boolean;
+    keepAliases?: string[];
+  }): void;
+  /**
+   * Called after a find operation has been executed to observe the raw database rows.
+   *
+   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,
+   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.
+   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;
+   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is
+   * unsupported and is not guaranteed to affect entity hydration.
+   *
+   * @param meta Metadata for the entity type that was queried
+   * @param operation The type of find operation that was performed
+   * @param rows A read-only view of the raw database rows returned from the query
+   */
+  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;
+  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;
+  afterValidate?(entities: readonly Entity[]): Promise<void> | void;
+  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
+}
+declare const emsSymbol: unique symbol;
+/**
+ * Base class for plugins that hook into entity lifecycle events.
+ *
+ * Plugins can implement any of the PluginMethods to intercept entity operations
+ * and are automatically registered with the EntityManager when added via PluginManager.
+ */
+declare abstract class Plugin {
+  [emsSymbol]: WeakRef<EntityManager>[];
+  maybeCloneForNewEm(): this | undefined;
+  get ems(): readonly EntityManager[];
+}
+interface Plugin extends PluginMethods {}
+/**
+ * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
+ *
+ * The PluginManager optimizes callback dispatch by only creating dispatcher methods
+ * for callbacks that have at least one registered plugin, making unused plugin hooks
+ * zero-cost at runtime.
+ */
+declare class PluginManager implements Required<PluginMethods> {
+  #private;
+  readonly em: EntityManager;
+  constructor(em: EntityManager);
+  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */
+  hasHook(method: keyof PluginMethods): boolean;
+  /**
+   * Registers a plugin with this EntityManager.
+   *
+   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,
+   * enabling lazy initialization of only the hooks that are actually used.
+   *
+   * @throws Error if the plugin is already registered with another EntityManager
+   */
+  addPlugin(plugin: Plugin): void;
+  get plugins(): readonly Plugin[];
+  cloneTo(other: PluginManager): void;
+  beforeGetField(entity: Entity, field: string): void;
+  beforeSetField(entity: Entity, field: string, newValue: any): void;
+  beforeFind(meta: EntityMetadata, operation: FindOperation, query: ParsedFindQuery, settings: {
+    limit?: number;
+    offset?: number;
+    allowMultipleLeftJoins?: boolean;
+    optimizeJoinsToExists?: boolean;
+    pruneJoins?: boolean;
+    keepAliases?: string[];
+  }): void;
+  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;
+  beforeValidate(entities: readonly Entity[]): Promise<void> | void;
+  afterValidate(entities: readonly Entity[]): Promise<void> | void;
+  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
+}
+//#endregion
+export { Plugin, PluginManager };
+//# sourceMappingURL=PluginManager.d.mts.map

package/build/PluginManager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginManager.d.mts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;uBAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;UASL,eAAe;;;;;;;;cASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}

package/build/PluginManager.js

@@ -1,113 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginManager = exports.Plugin = void 0;
-const EntityManager_1 = require("./EntityManager");
+import "./EntityMetadata.js";
+import { isDefined } from "./EntityManager.js";
+import "./Entity.js";
+//#region src/PluginManager.ts
 const syncPluginMethods = [
-    "beforeGetField",
-    "beforeSetField",
-    "beforeFind",
-    "afterFind",
-    "afterWrite",
+	"beforeGetField",
+	"beforeSetField",
+	"beforeFind",
+	"afterFind",
+	"afterWrite"
 ];
 const asyncPluginMethods = ["beforeValidate", "afterValidate"];
 const emsSymbol = Symbol("ems");
 /**
- * Base class for plugins that hook into entity lifecycle events.
- *
- * Plugins can implement any of the PluginMethods to intercept entity operations
- * and are automatically registered with the EntityManager when added via PluginManager.
- */
-class Plugin {
-    // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we
-    // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.
-    [emsSymbol] = [];
-    maybeCloneForNewEm() {
-        return undefined;
-    }
-    get ems() {
-        return this[emsSymbol]
-            .values()
-            .map((wr) => wr.deref())
-            .filter(EntityManager_1.isDefined)
-            .toArray();
-    }
-}
-exports.Plugin = Plugin;
+* Base class for plugins that hook into entity lifecycle events.
+*
+* Plugins can implement any of the PluginMethods to intercept entity operations
+* and are automatically registered with the EntityManager when added via PluginManager.
+*/
+var Plugin = class {
+	[emsSymbol] = [];
+	maybeCloneForNewEm() {}
+	get ems() {
+		return this[emsSymbol].values().map((wr) => wr.deref()).filter(isDefined).toArray();
+	}
+};
 /**
- * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
- *
- * The PluginManager optimizes callback dispatch by only creating dispatcher methods
- * for callbacks that have at least one registered plugin, making unused plugin hooks
- * zero-cost at runtime.
- */
-class PluginManager {
-    em;
-    #plugins = new Set();
-    #pluginsByCallback = {};
-    constructor(em) {
-        this.em = em;
-    }
-    /**
-     * Registers a plugin with this EntityManager.
-     *
-     * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,
-     * enabling lazy initialization of only the hooks that are actually used.
-     *
-     * @throws Error if the plugin is already registered with another EntityManager
-     */
-    addPlugin(plugin) {
-        if (this.#plugins.has(plugin))
-            return; // if we're already added, then we can just early exit
-        this.#plugins.add(plugin);
-        plugin[emsSymbol].push(new WeakRef(this.em));
-        for (const method of syncPluginMethods) {
-            if (method in plugin) {
-                (this.#pluginsByCallback[method] ??= []).push(plugin);
-                // As a performance optimization, we only create the actual implementation for each method on the plugin manager
-                // once we have at least one plugin using that method. This is to make it so any unused plugin methods are
-                // effectively no-ops when called from within the em.
-                if (!Object.hasOwn(this, method)) {
-                    this[method] = function (...args) {
-                        for (const plugin of this.#pluginsByCallback[method]) {
-                            plugin[method](...args);
-                        }
-                    };
-                }
-            }
-        }
-        for (const method of asyncPluginMethods) {
-            if (method in plugin) {
-                (this.#pluginsByCallback[method] ??= []).push(plugin);
-                // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.
-                if (!Object.hasOwn(this, method)) {
-                    this[method] = async function (...args) {
-                        for (const plugin of this.#pluginsByCallback[method]) {
-                            await plugin[method](...args);
-                        }
-                    };
-                }
-            }
-        }
-    }
-    get plugins() {
-        return [...this.#plugins];
-    }
-    cloneTo(other) {
-        this.#plugins
-            .values()
-            .map((plugin) => plugin.maybeCloneForNewEm())
-            .filter(EntityManager_1.isDefined)
-            .forEach((plugin) => other.addPlugin(plugin));
-    }
-    // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:
-    // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/
-    beforeGetField(entity, field) { }
-    beforeSetField(entity, field, newValue) { }
-    beforeFind(meta, operation, query, settings) { }
-    afterFind(meta, operation, rows) { }
-    beforeValidate(entities) { }
-    afterValidate(entities) { }
-    afterWrite(entityTodos, joinRowTodos) { }
-}
-exports.PluginManager = PluginManager;
+* Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
+*
+* The PluginManager optimizes callback dispatch by only creating dispatcher methods
+* for callbacks that have at least one registered plugin, making unused plugin hooks
+* zero-cost at runtime.
+*/
+var PluginManager = class {
+	em;
+	#plugins = /* @__PURE__ */ new Set();
+	#pluginsByCallback = {};
+	constructor(em) {
+		this.em = em;
+	}
+	/** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */
+	hasHook(method) {
+		return this.#pluginsByCallback[method] !== void 0;
+	}
+	/**
+	* Registers a plugin with this EntityManager.
+	*
+	* Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,
+	* enabling lazy initialization of only the hooks that are actually used.
+	*
+	* @throws Error if the plugin is already registered with another EntityManager
+	*/
+	addPlugin(plugin) {
+		if (this.#plugins.has(plugin)) return;
+		this.#plugins.add(plugin);
+		plugin[emsSymbol].push(new WeakRef(this.em));
+		for (const method of syncPluginMethods) if (method in plugin) {
+			(this.#pluginsByCallback[method] ??= []).push(plugin);
+			if (!Object.hasOwn(this, method)) this[method] = function(...args) {
+				for (const plugin of this.#pluginsByCallback[method]) plugin[method](...args);
+			};
+		}
+		for (const method of asyncPluginMethods) if (method in plugin) {
+			(this.#pluginsByCallback[method] ??= []).push(plugin);
+			if (!Object.hasOwn(this, method)) this[method] = async function(...args) {
+				for (const plugin of this.#pluginsByCallback[method]) await plugin[method](...args);
+			};
+		}
+	}
+	get plugins() {
+		return [...this.#plugins];
+	}
+	cloneTo(other) {
+		this.#plugins.values().map((plugin) => plugin.maybeCloneForNewEm()).filter(isDefined).forEach((plugin) => other.addPlugin(plugin));
+	}
+	beforeGetField(entity, field) {}
+	beforeSetField(entity, field, newValue) {}
+	beforeFind(meta, operation, query, settings) {}
+	afterFind(meta, operation, rows) {}
+	beforeValidate(entities) {}
+	afterValidate(entities) {}
+	afterWrite(entityTodos, joinRowTodos) {}
+};
+//#endregion
+export { Plugin, PluginManager };
+
 //# sourceMappingURL=PluginManager.js.map

package/build/PluginManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.js","sourceRoot":"","sources":["../src/PluginManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"PluginManager.js","names":["#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"src/flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { type RowData } from \"src/RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAO,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKA,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAO,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}

package/build/RowData.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/RowData.ts
+/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
+var PojoRowData = class {
+	rows;
+	constructor(rows) {
+		this.rows = rows;
+	}
+	get rowCount() {
+		return this.rows.length;
+	}
+	get(rowIndex, columnName) {
+		return this.rows[rowIndex][columnName];
+	}
+	toRow(rowIndex) {
+		return this.rows[rowIndex];
+	}
+	toRows() {
+		return this.rows;
+	}
+};
+/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
+const emptyRowData = {
+	rowCount: 0,
+	get() {},
+	toRow() {
+		return {};
+	},
+	toRows() {
+		return [];
+	}
+};
+//#endregion
+exports.PojoRowData = PojoRowData;
+exports.emptyRowData = emptyRowData;
+
+//# sourceMappingURL=RowData.cjs.map

package/build/RowData.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowData.cjs","names":[],"sources":["../src/RowData.ts"],"sourcesContent":["/**\n * A read-only view of one query's result rows; each entity references its as-loaded row as a\n * `(rowData, rowIndex)` pair on its `InstanceData`.\n *\n * Each query result gets its own individual `RowData` — results are never combined or appended\n * across queries. An entity keeps pointing at the `RowData` of whichever query first loaded it\n * (or, for `em.refresh`, the query that most recently refreshed it), and the `RowData` is never\n * written to: mutations go into the entity's `data`/`originalData` bags as usual, so a `RowData`\n * stays a snapshot of \"what the database returned for this query\".\n *\n * This is the seam that lets rows be backed by different representations:\n *\n * - `PojoRowData` wraps the classic node-pg POJO rows, i.e. for the public\n *   `em.hydrate(type, rows)` API and drivers that return materialized rows, and\n * - lazy/columnar results (`WireRowData` in joist-orm, see `JS-ROW-STORE-DESIGN.md`) keep raw\n *   wire bytes in off-heap arenas and only decode a `row × column` cell when a field is read.\n *\n * Values returned from `get` are \"driver-level\" values, i.e. whatever the pg type\n * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for\n * deferred temporals); the field serdes then convert them to domain values.\n */\nexport interface RowData {\n  /** The number of rows in this query result. */\n  readonly rowCount: number;\n  /** Returns the driver-level column value for a row, i.e. `rowData.get(0, \"first_name\")`. */\n  get(rowIndex: number, columnName: string): any;\n  /** Materializes one row as a classic POJO, i.e. for debugging and differential tests. */\n  toRow(rowIndex: number): any;\n  /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging. */\n  toRows(): any[];\n  /** Optionally marks `rowIndex` as retained by a hydrated entity; see `finalize`. */\n  retain?(rowIndex: number): void;\n  /**\n   * Optionally trims/compacts the result after hydration + sidecar reads are complete, i.e. so\n   * lazy results only retain bytes for rows whose entities were actually kept.\n   */\n  finalize?(): void;\n}\n\n/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */\nexport class PojoRowData implements RowData {\n  constructor(private rows: readonly any[]) {}\n\n  get rowCount(): number {\n    return this.rows.length;\n  }\n\n  get(rowIndex: number, columnName: string): any {\n    return this.rows[rowIndex][columnName];\n  }\n\n  toRow(rowIndex: number): any {\n    return this.rows[rowIndex];\n  }\n\n  toRows(): any[] {\n    return this.rows as any[];\n  }\n}\n\n/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */\nexport const emptyRowData: RowData = {\n  rowCount: 0,\n  get() {\n    return undefined;\n  },\n  toRow() {\n    return {};\n  },\n  toRows() {\n    return [];\n  },\n};\n"],"mappings":";;;AAwCA,IAAa,cAAb,MAA4C;CACtB;CAApB,YAAY,MAA8B;EAAtB,KAAA,OAAA;CAAuB;CAE3C,IAAI,WAAmB;EACrB,OAAO,KAAK,KAAK;CACnB;CAEA,IAAI,UAAkB,YAAyB;EAC7C,OAAO,KAAK,KAAK,SAAS,CAAC;CAC7B;CAEA,MAAM,UAAuB;EAC3B,OAAO,KAAK,KAAK;CACnB;CAEA,SAAgB;EACd,OAAO,KAAK;CACd;AACF;;AAGA,MAAa,eAAwB;CACnC,UAAU;CACV,MAAM,CAEN;CACA,QAAQ;EACN,OAAO,CAAC;CACV;CACA,SAAS;EACP,OAAO,CAAC;CACV;AACF"}

package/build/RowData.d.cts

@@ -0,0 +1,53 @@
+//#region src/RowData.d.ts
+/**
+ * A read-only view of one query's result rows; each entity references its as-loaded row as a
+ * `(rowData, rowIndex)` pair on its `InstanceData`.
+ *
+ * Each query result gets its own individual `RowData` — results are never combined or appended
+ * across queries. An entity keeps pointing at the `RowData` of whichever query first loaded it
+ * (or, for `em.refresh`, the query that most recently refreshed it), and the `RowData` is never
+ * written to: mutations go into the entity's `data`/`originalData` bags as usual, so a `RowData`
+ * stays a snapshot of "what the database returned for this query".
+ *
+ * This is the seam that lets rows be backed by different representations:
+ *
+ * - `PojoRowData` wraps the classic node-pg POJO rows, i.e. for the public
+ *   `em.hydrate(type, rows)` API and drivers that return materialized rows, and
+ * - lazy/columnar results (`WireRowData` in joist-orm, see `JS-ROW-STORE-DESIGN.md`) keep raw
+ *   wire bytes in off-heap arenas and only decode a `row × column` cell when a field is read.
+ *
+ * Values returned from `get` are "driver-level" values, i.e. whatever the pg type
+ * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for
+ * deferred temporals); the field serdes then convert them to domain values.
+ */
+interface RowData {
+  /** The number of rows in this query result. */
+  readonly rowCount: number;
+  /** Returns the driver-level column value for a row, i.e. `rowData.get(0, "first_name")`. */
+  get(rowIndex: number, columnName: string): any;
+  /** Materializes one row as a classic POJO, i.e. for debugging and differential tests. */
+  toRow(rowIndex: number): any;
+  /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging. */
+  toRows(): any[];
+  /** Optionally marks `rowIndex` as retained by a hydrated entity; see `finalize`. */
+  retain?(rowIndex: number): void;
+  /**
+   * Optionally trims/compacts the result after hydration + sidecar reads are complete, i.e. so
+   * lazy results only retain bytes for rows whose entities were actually kept.
+   */
+  finalize?(): void;
+}
+/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
+declare class PojoRowData implements RowData {
+  private rows;
+  constructor(rows: readonly any[]);
+  get rowCount(): number;
+  get(rowIndex: number, columnName: string): any;
+  toRow(rowIndex: number): any;
+  toRows(): any[];
+}
+/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
+declare const emptyRowData: RowData;
+//#endregion
+export { PojoRowData, RowData, emptyRowData };
+//# sourceMappingURL=RowData.d.cts.map

package/build/RowData.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowData.d.cts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;cAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;cAMW,cAAc"}

package/build/RowData.d.mts

@@ -0,0 +1,53 @@
+//#region src/RowData.d.ts
+/**
+ * A read-only view of one query's result rows; each entity references its as-loaded row as a
+ * `(rowData, rowIndex)` pair on its `InstanceData`.
+ *
+ * Each query result gets its own individual `RowData` — results are never combined or appended
+ * across queries. An entity keeps pointing at the `RowData` of whichever query first loaded it
+ * (or, for `em.refresh`, the query that most recently refreshed it), and the `RowData` is never
+ * written to: mutations go into the entity's `data`/`originalData` bags as usual, so a `RowData`
+ * stays a snapshot of "what the database returned for this query".
+ *
+ * This is the seam that lets rows be backed by different representations:
+ *
+ * - `PojoRowData` wraps the classic node-pg POJO rows, i.e. for the public
+ *   `em.hydrate(type, rows)` API and drivers that return materialized rows, and
+ * - lazy/columnar results (`WireRowData` in joist-orm, see `JS-ROW-STORE-DESIGN.md`) keep raw
+ *   wire bytes in off-heap arenas and only decode a `row × column` cell when a field is read.
+ *
+ * Values returned from `get` are "driver-level" values, i.e. whatever the pg type
+ * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for
+ * deferred temporals); the field serdes then convert them to domain values.
+ */
+interface RowData {
+  /** The number of rows in this query result. */
+  readonly rowCount: number;
+  /** Returns the driver-level column value for a row, i.e. `rowData.get(0, "first_name")`. */
+  get(rowIndex: number, columnName: string): any;
+  /** Materializes one row as a classic POJO, i.e. for debugging and differential tests. */
+  toRow(rowIndex: number): any;
+  /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging. */
+  toRows(): any[];
+  /** Optionally marks `rowIndex` as retained by a hydrated entity; see `finalize`. */
+  retain?(rowIndex: number): void;
+  /**
+   * Optionally trims/compacts the result after hydration + sidecar reads are complete, i.e. so
+   * lazy results only retain bytes for rows whose entities were actually kept.
+   */
+  finalize?(): void;
+}
+/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
+declare class PojoRowData implements RowData {
+  private rows;
+  constructor(rows: readonly any[]);
+  get rowCount(): number;
+  get(rowIndex: number, columnName: string): any;
+  toRow(rowIndex: number): any;
+  toRows(): any[];
+}
+/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
+declare const emptyRowData: RowData;
+//#endregion
+export { PojoRowData, RowData, emptyRowData };
+//# sourceMappingURL=RowData.d.mts.map

package/build/RowData.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowData.d.mts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;cAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;cAMW,cAAc"}