@rudderjs/orm 1.9.1 → 1.9.3

package/dist/index.js

@@ -1,5 +1,10 @@
 import { castGet, castSet } from './cast.js';
 import { AGGREGATES_SYMBOL, aggregateKeysOf, loadCountOrExists, loadMissingRelations, loadNumericAggregate, normalizeWithCount, normalizeWithExists, normalizeWithNumericAggregate, } from './aggregate.js';
+import { attrEqual, readField, writeField, deleteField } from './utils.js';
+import { resolveBelongsToManyMeta, resolveMorphToManyMeta, resolveMorphedByManyMeta, } from './relations/pivot-meta.js';
+import { attachWhereHas, attachWithWhereHas, attachWhereBelongsTo, } from './relations/where-has.js';
+import { morphParentQuery, belongsToManyDeferredQb, morphToManyDeferredQb, morphedByManyDeferredQb, } from './relations/pivot-deferred.js';
+import { makeBelongsToManyAccessor, makeMorphToManyAccessor, makeMorphedByManyAccessor, installBelongsToManyMethods, installMorphPivotMethods, } from './relations/pivot-accessors.js';
 export { vector } from './cast.js';
 export { VectorDimensionMismatchError, VectorStorageUnsupportedError, MissingEmbedderError, } from './vector-errors.js';
 export { Attribute } from './attribute.js';
@@ -9,22 +14,27 @@ export { ModelFactory, sequence } from './factory.js';
 export { Seeder } from './seeder.js';
 export { AggregateConstraintBuilder, AGGREGATES_SYMBOL } from './aggregate.js';
 export { pruneModels } from './prune.js';
-// ─── Global ORM Registry ───────────────────────────────────
+const _g = globalThis;
+if (!_g['__rudderjs_orm_registry__']) {
+    _g['__rudderjs_orm_registry__'] = {
+        adapter: null,
+        models: new Map(),
+        listeners: new Set(),
+    };
+}
+const _store = _g['__rudderjs_orm_registry__'];
 export class ModelRegistry {
-    static adapter = null;
-    static models = new Map();
-    static listeners = new Set();
     static set(adapter) {
-        this.adapter = adapter;
+        _store.adapter = adapter;
     }
     static get() {
-        return this.adapter;
+        return _store.adapter;
     }
     static getAdapter() {
-        if (!this.adapter) {
+        if (!_store.adapter) {
             throw new Error('[RudderJS ORM] No ORM adapter registered. Did you add a database provider to your providers list?');
         }
-        return this.adapter;
+        return _store.adapter;
     }
     /**
      * Register a Model class so consumers (e.g. Telescope's model collector)
@@ -39,12 +49,12 @@ export class ModelRegistry {
      */
     static register(ModelClass) {
         const name = ModelClass.name;
-        if (!name || this.models.has(name))
+        if (!name || _store.models.has(name))
             return;
-        this.models.set(name, ModelClass);
-        _installBelongsToManyMethods(ModelClass);
-        _installMorphPivotMethods(ModelClass);
-        for (const listener of this.listeners)
+        _store.models.set(name, ModelClass);
+        installBelongsToManyMethods(ModelClass);
+        installMorphPivotMethods(ModelClass);
+        for (const listener of _store.listeners)
             listener(name, ModelClass);
     }
     /**
@@ -52,20 +62,20 @@ export class ModelRegistry {
      * model collector and any code that needs to iterate discovered models.
      */
     static all() {
-        return this.models;
+        return _store.models;
     }
     /**
      * Subscribe to model registrations. Fires once per newly registered
      * class. Returns an unsubscribe function.
      */
     static onRegister(listener) {
-        this.listeners.add(listener);
-        return () => { this.listeners.delete(listener); };
+        _store.listeners.add(listener);
+        return () => { _store.listeners.delete(listener); };
     }
     static reset() {
-        this.adapter = null;
-        this.models.clear();
-        this.listeners.clear();
+        _store.adapter = null;
+        _store.models.clear();
+        _store.listeners.clear();
     }
 }
 // ─── Errors ────────────────────────────────────────────────
@@ -356,8 +366,22 @@ export class Model {
     // Used by isDirty / isClean / wasChanged / getOriginal / getChanges /
     // getDirty. Captured by hydrate(), save(), refresh(), and increment/
     // decrement so the baseline always matches the persisted state.
-    /** @internal — own enumerable column values as of last load/save/refresh. */
-    #original = {};
+    /**
+     * @internal — materialized own-column baseline as of last load/save/refresh.
+     * Populated lazily: hydrate just stores the raw input record in
+     * {@link Model.#originalRaw} and defers the filter pass until the first
+     * dirty-tracking access. Save/refresh/etc. populate this field eagerly
+     * because they have current instance state in hand.
+     */
+    #originalSnapshot = {};
+    /**
+     * @internal — reference to the raw record passed to `hydrate()`. While
+     * non-undefined, dirty-tracking reads route through {@link Model._original}
+     * which materializes {@link Model.#originalSnapshot} on first access. Reset
+     * to `undefined` once materialized or once an explicit `_syncOriginal()`
+     * captures the post-save / post-refresh state.
+     */
+    #originalRaw = undefined;
     /** @internal — diff of attributes that changed during the most recent save. */
     #changes = {};
     // ── Scopes ─────────────────────────────────────────────
@@ -387,12 +411,27 @@ export class Model {
         this._listeners.set(event, list);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static async _fireEvent(event, ...args) {
+    // Returns `unknown` (not `Promise<unknown>`) so the common fast path stays
+    // synchronous: when a class has no observers or event listeners — the typical
+    // case for read paths like `.all()` / `.find()` — the call returns the payload
+    // directly, and `await self._fireEvent(...)` becomes a no-op in V8 (no
+    // microtask scheduling). This recovers ~1ms on `.all()` over 5000 rows where
+    // the per-row `retrieved` event would otherwise schedule 5000 empty microtasks.
+    // Slow-path observers/listeners route through `_fireEventSlow` and still get
+    // their async semantics.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _fireEvent(event, ...args) {
         if (Object.prototype.hasOwnProperty.call(this, '_eventsMuted') && this._eventsMuted) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return args[0];
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const hasObservers = Object.prototype.hasOwnProperty.call(this, '_observers') && this._observers.length > 0;
+        const hasListeners = Object.prototype.hasOwnProperty.call(this, '_listeners') && this._listeners.size > 0;
+        if (!hasObservers && !hasListeners)
+            return args[0];
+        return this._fireEventSlow(event, ...args);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async _fireEventSlow(event, ...args) {
         let result = args[0];
         const observers = Object.prototype.hasOwnProperty.call(this, '_observers') ? this._observers : [];
         for (const obs of observers) {
@@ -409,7 +448,6 @@ export class Model {
             ? (this._listeners.get(event) ?? [])
             : [];
         for (const fn of listeners) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             const ret = await fn(...args);
             if (ret === false)
                 return false;
@@ -450,7 +488,9 @@ export class Model {
         const Ctor = this;
         const instance = new Ctor();
         Object.assign(instance, record);
-        instance._syncOriginal();
+        // Defer the dirty-tracking baseline. _original() materializes the filtered
+        // snapshot on first access — typically never, for read-and-discard rows.
+        instance.#originalRaw = record;
         return instance;
     }
     /** @internal — wrap a QueryBuilder so its read methods return Model instances. */
@@ -476,6 +516,10 @@ export class Model {
                 aggregateAliases.add(r.alias);
             qb.withAggregate(reqs);
         };
+        // The Proxy's `get` handler implements the extra `HydratingQueryBuilder`
+        // methods at runtime (whereHas / withCount / etc.). TS can't verify that
+        // through the Proxy constructor, so we assert here — the assertion is
+        // contained to this one site instead of leaking to every call site.
         const proxy = new Proxy(qb, {
             get(target, prop, receiver) {
                 // ORM-side chainables that don't exist on the adapter QB itself —
@@ -483,25 +527,25 @@ export class Model {
                 // are added by this proxy, not by the adapter.
                 if (prop === 'whereHas') {
                     return (relation, constrain) => {
-                        _attachWhereHas(ModelClass, target, relation, true, constrain);
+                        attachWhereHas(ModelClass, target, relation, true, constrain);
                         return proxy;
                     };
                 }
                 if (prop === 'whereDoesntHave') {
                     return (relation, constrain) => {
-                        _attachWhereHas(ModelClass, target, relation, false, constrain);
+                        attachWhereHas(ModelClass, target, relation, false, constrain);
                         return proxy;
                     };
                 }
                 if (prop === 'withWhereHas') {
                     return (relation, constrain) => {
-                        _attachWithWhereHas(ModelClass, target, relation, constrain);
+                        attachWithWhereHas(ModelClass, target, relation, constrain);
                         return proxy;
                     };
                 }
                 if (prop === 'whereBelongsTo') {
                     return (parent, relation) => {
-                        _attachWhereBelongsTo(ModelClass, target, parent, relation);
+                        attachWhereBelongsTo(ModelClass, target, parent, relation);
                         return proxy;
                     };
                 }
@@ -565,7 +609,6 @@ export class Model {
                         // Chainable methods (where/orderBy/with/...) typically return `target` —
                         // re-wrap so `Model.where('a', 1).first()` keeps hydrating.
                         return (...args) => {
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                             const result = value.apply(target, args);
                             return result === target ? proxy : result;
                         };
@@ -606,7 +649,6 @@ export class Model {
                 excludedScopes.add(name);
                 return enhance(buildScoped());
             };
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return enhanced;
         };
         return enhance(buildScoped());
@@ -691,7 +733,7 @@ export class Model {
      * await Post.whereHas('comments').get()                                      // morphMany — adds the {morph}Type filter automatically
      */
     static whereHas(relation, constrain) {
-        return _attachWhereHas(this, Model._q(this), relation, true, constrain);
+        return attachWhereHas(this, Model._q(this), relation, true, constrain);
     }
     /**
      * Inverse of {@link Model.whereHas} — rows whose named relation has zero
@@ -700,7 +742,7 @@ export class Model {
      * matching the constraint" rather than "no children at all".
      */
     static whereDoesntHave(relation, constrain) {
-        return _attachWhereHas(this, Model._q(this), relation, false, constrain);
+        return attachWhereHas(this, Model._q(this), relation, false, constrain);
     }
     /**
      * `whereHas` + `with` — filter by the relation predicate AND eager-load the
@@ -710,7 +752,7 @@ export class Model {
      * the parent was matched on a narrower predicate.
      */
     static withWhereHas(relation, constrain) {
-        return _attachWithWhereHas(this, Model._q(this), relation, constrain);
+        return attachWithWhereHas(this, Model._q(this), relation, constrain);
     }
     /**
      * Filter rows whose `belongsTo` relation points at `parent`. Sugar for
@@ -724,7 +766,7 @@ export class Model {
      * await Comment.whereBelongsTo(post, 'post').get()  // explicit relation name when ambiguous
      */
     static whereBelongsTo(parent, relation) {
-        return _attachWhereBelongsTo(this, Model._q(this), parent, relation);
+        return attachWhereBelongsTo(this, Model._q(this), parent, relation);
     }
     /**
      * Aggregate eager-loading — count related rows alongside the parent in a
@@ -736,7 +778,7 @@ export class Model {
      *   - `withCount('posts')` — single relation, no constraint.
      *   - `withCount(['posts', 'comments'])` — multiple, no constraints.
      *   - `withCount({ posts: q => q.where('published', true).as('publishedPosts') })`
-     *     — map form with `where`/`orWhere` constraints + optional alias override.
+     *     — map form with `where` constraints + optional alias override.
      *
      * Closes the N+1 footgun for hot list pages. For a single instance use
      * `instance.loadCount('posts')` instead.
@@ -969,7 +1011,7 @@ export class Model {
     /** @internal — pull the primary-key value from this instance, or `undefined` if unset. */
     _getKey() {
         const ctor = this.constructor;
-        const value = this[ctor.primaryKey];
+        const value = readField(this, ctor.primaryKey);
         if (value === undefined || value === null)
             return undefined;
         return value;
@@ -1004,9 +1046,34 @@ export class Model {
     _toData() {
         return this._currentAttrs();
     }
+    /**
+     * @internal — return the dirty-tracking baseline, materializing the deferred
+     * raw record from hydrate on first access. After materialization (or after
+     * an explicit `_syncOriginal()` reset), subsequent calls return the cached
+     * snapshot directly.
+     */
+    _original() {
+        if (this.#originalRaw === undefined)
+            return this.#originalSnapshot;
+        const aggregates = this[AGGREGATES_SYMBOL];
+        const out = {};
+        for (const [k, v] of Object.entries(this.#originalRaw)) {
+            if (k.startsWith('_'))
+                continue;
+            if (v === undefined)
+                continue;
+            if (aggregates && aggregates.has(k))
+                continue;
+            out[k] = v;
+        }
+        this.#originalSnapshot = out;
+        this.#originalRaw = undefined;
+        return out;
+    }
     /** @internal — capture current attrs as the new dirty-tracking baseline. */
     _syncOriginal() {
-        this.#original = this._currentAttrs();
+        this.#originalSnapshot = this._currentAttrs();
+        this.#originalRaw = undefined;
     }
     /**
      * Persist this instance. Inserts when the primary key is unset; otherwise updates.
@@ -1026,13 +1093,15 @@ export class Model {
             : await Model._doUpdate.call(ctor, id, data);
         Object.assign(this, persisted);
         const next = this._currentAttrs();
+        const prev = this._original();
         const diff = {};
-        for (const k of new Set([...Object.keys(next), ...Object.keys(this.#original)])) {
-            if (!_attrEqual(next[k], this.#original[k]))
+        for (const k of new Set([...Object.keys(next), ...Object.keys(prev)])) {
+            if (!attrEqual(next[k], prev[k]))
                 diff[k] = next[k];
         }
         this.#changes = diff;
-        this.#original = next;
+        this.#originalSnapshot = next;
+        this.#originalRaw = undefined;
         return this;
     }
     /**
@@ -1073,7 +1142,7 @@ export class Model {
             throw new ModelNotFoundError(ctor.name, id);
         for (const k of Object.keys(this)) {
             if (!k.startsWith('_'))
-                delete this[k];
+                deleteField(this, k);
         }
         Object.assign(this, fresh);
         this.#changes = {};
@@ -1096,8 +1165,7 @@ export class Model {
         }
         await ctor.delete(id);
         if (ctor.softDeletes) {
-            ;
-            this.deletedAt = new Date();
+            writeField(this, 'deletedAt', new Date());
             this._syncOriginal();
         }
     }
@@ -1258,7 +1326,7 @@ export class Model {
         for (const [k, v] of Object.entries(this)) {
             if (k.startsWith('_') || exclude.has(k) || v === undefined)
                 continue;
-            clone[k] = v;
+            writeField(clone, k, v);
         }
         return clone;
     }
@@ -1285,9 +1353,10 @@ export class Model {
             : key in this.#changes;
     }
     getOriginal(key) {
+        const snap = this._original();
         if (key === undefined)
-            return { ...this.#original };
-        return this.#original[key];
+            return { ...snap };
+        return snap[key];
     }
     /** Diff map of attributes that changed during the most recent {@link save}. */
     getChanges() {
@@ -1297,8 +1366,9 @@ export class Model {
     getDirty() {
         const out = {};
         const current = this._currentAttrs();
-        for (const k of new Set([...Object.keys(current), ...Object.keys(this.#original)])) {
-            if (!_attrEqual(current[k], this.#original[k]))
+        const prev = this._original();
+        for (const k of new Set([...Object.keys(current), ...Object.keys(prev)])) {
+            if (!attrEqual(current[k], prev[k]))
                 out[k] = current[k];
         }
         return out;
@@ -1324,7 +1394,7 @@ export class Model {
     }
     /** True when this instance has been soft-deleted (its `deletedAt` is set). */
     trashed() {
-        const v = this['deletedAt'];
+        const v = readField(this, 'deletedAt');
         return v !== null && v !== undefined;
     }
     // ── Relations ──────────────────────────────────────────
@@ -1356,8 +1426,8 @@ export class Model {
         if (def.type === 'morphTo') {
             const idCol = `${def.morphName}Id`;
             const typeCol = `${def.morphName}Type`;
-            const idVal = this[idCol];
-            const typeVal = this[typeCol];
+            const idVal = readField(this, idCol);
+            const typeVal = readField(this, typeCol);
             if (idVal === undefined || idVal === null || typeVal === undefined || typeVal === null) {
                 throw new Error(`[RudderJS ORM] Cannot resolve morphTo "${name}" on ${ctor.name} — ${idCol}/${typeCol} unset.`);
             }
@@ -1386,42 +1456,42 @@ export class Model {
         // expectation (`first()` vs `get()`). Split into two ifs so TS can narrow
         // each tag literal out of the union for the fall-through branches below.
         if (def.type === 'morphMany') {
-            return _morphParentQuery(this, ctor, def, name);
+            return morphParentQuery(this, ctor, def, name);
         }
         if (def.type === 'morphOne') {
-            return _morphParentQuery(this, ctor, def, name);
+            return morphParentQuery(this, ctor, def, name);
         }
         const Related = def.model();
         const fkCamel = (s) => s.charAt(0).toLowerCase() + s.slice(1);
         if (def.type === 'belongsToMany') {
-            const meta = _resolveBelongsToManyMeta(ctor, Related, def);
-            const parentVal = this[meta.parentKey];
+            const meta = resolveBelongsToManyMeta(ctor, Related, def);
+            const parentVal = readField(this, meta.parentKey);
             if (parentVal === undefined || parentVal === null) {
                 throw new Error(`[RudderJS ORM] Cannot resolve "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
             }
-            return _belongsToManyDeferredQb(Related, def, meta, parentVal);
+            return belongsToManyDeferredQb(Related, def, meta, parentVal);
         }
         if (def.type === 'morphToMany') {
-            const meta = _resolveMorphToManyMeta(ctor, Related, def);
-            const parentVal = this[meta.parentKey];
+            const meta = resolveMorphToManyMeta(ctor, Related, def);
+            const parentVal = readField(this, meta.parentKey);
             if (parentVal === undefined || parentVal === null) {
                 throw new Error(`[RudderJS ORM] Cannot resolve "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
             }
-            return _morphToManyDeferredQb(Related, def, meta, parentVal);
+            return morphToManyDeferredQb(Related, def, meta, parentVal);
         }
         if (def.type === 'morphedByMany') {
-            const meta = _resolveMorphedByManyMeta(ctor, Related, def);
-            const parentVal = this[meta.parentKey];
+            const meta = resolveMorphedByManyMeta(ctor, Related, def);
+            const parentVal = readField(this, meta.parentKey);
             if (parentVal === undefined || parentVal === null) {
                 throw new Error(`[RudderJS ORM] Cannot resolve "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
             }
-            return _morphedByManyDeferredQb(Related, def, meta, parentVal);
+            return morphedByManyDeferredQb(Related, def, meta, parentVal);
         }
         if (def.type === 'belongsTo') {
             // This model holds the FK; query the related model's PK.
             const fk = def.foreignKey ?? `${fkCamel(Related.name)}Id`;
             const localCol = def.localKey ?? fk;
-            const localVal = this[localCol];
+            const localVal = readField(this, localCol);
             if (localVal === undefined || localVal === null) {
                 throw new Error(`[RudderJS ORM] Cannot resolve belongsTo "${name}" — ${ctor.name}.${localCol} is unset.`);
             }
@@ -1430,7 +1500,7 @@ export class Model {
         // hasOne / hasMany — related model holds the FK pointing back to us.
         const fk = def.foreignKey ?? `${fkCamel(ctor.name)}Id`;
         const localCol = def.localKey ?? ctor.primaryKey;
-        const localVal = this[localCol];
+        const localVal = readField(this, localCol);
         if (localVal === undefined || localVal === null) {
             throw new Error(`[RudderJS ORM] Cannot resolve "${name}" on ${ctor.name} — ${localCol} is unset.`);
         }
@@ -1465,15 +1535,15 @@ export class Model {
             throw new Error(`[RudderJS ORM] Relation "${name}" on ${ctor.name} is "${def.type}", not "belongsToMany".`);
         }
         const Related = def.model();
-        const meta = _resolveBelongsToManyMeta(ctor, Related, def);
-        const parentVal = parent[meta.parentKey];
+        const meta = resolveBelongsToManyMeta(ctor, Related, def);
+        const parentVal = readField(parent, meta.parentKey);
         if (parentVal === undefined || parentVal === null) {
             throw new Error(`[RudderJS ORM] Cannot use belongsToMany "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
         }
         // Belt-and-suspenders: make sure the auto-method is installed even
         // for instances constructed before any query against this class.
-        _installBelongsToManyMethods(ctor);
-        return _makeBelongsToManyAccessor(ctor, Related, def, parentVal);
+        installBelongsToManyMethods(ctor);
+        return makeBelongsToManyAccessor(ctor, Related, def, parentVal);
     }
     /**
      * Pivot-mutation accessor for a `morphToMany` relation (the polymorphic
@@ -1499,13 +1569,13 @@ export class Model {
             throw new Error(`[RudderJS ORM] Relation "${name}" on ${ctor.name} is "${def.type}", not "morphToMany".`);
         }
         const Related = def.model();
-        const meta = _resolveMorphToManyMeta(ctor, Related, def);
-        const parentVal = parent[meta.parentKey];
+        const meta = resolveMorphToManyMeta(ctor, Related, def);
+        const parentVal = readField(parent, meta.parentKey);
         if (parentVal === undefined || parentVal === null) {
             throw new Error(`[RudderJS ORM] Cannot use morphToMany "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
         }
-        _installMorphPivotMethods(ctor);
-        return _makeMorphToManyAccessor(ctor, Related, def, parentVal);
+        installMorphPivotMethods(ctor);
+        return makeMorphToManyAccessor(ctor, Related, def, parentVal);
     }
     /**
      * Pivot-mutation accessor for a `morphedByMany` relation (the inverse
@@ -1532,13 +1602,13 @@ export class Model {
             throw new Error(`[RudderJS ORM] Relation "${name}" on ${ctor.name} is "${def.type}", not "morphedByMany".`);
         }
         const Related = def.model();
-        const meta = _resolveMorphedByManyMeta(ctor, Related, def);
-        const parentVal = parent[meta.parentKey];
+        const meta = resolveMorphedByManyMeta(ctor, Related, def);
+        const parentVal = readField(parent, meta.parentKey);
         if (parentVal === undefined || parentVal === null) {
             throw new Error(`[RudderJS ORM] Cannot use morphedByMany "${name}" on ${ctor.name} — ${meta.parentKey} is unset.`);
         }
-        _installMorphPivotMethods(ctor);
-        return _makeMorphedByManyAccessor(ctor, Related, def, parentVal);
+        installMorphPivotMethods(ctor);
+        return makeMorphedByManyAccessor(ctor, Related, def, parentVal);
     }
     /**
      * Build the `{name}Id + {name}Type` payload for a polymorphic write.
@@ -1555,7 +1625,7 @@ export class Model {
      */
     static morph(name, parent) {
         const ctor = parent.constructor;
-        const pk = parent[ctor.primaryKey];
+        const pk = readField(parent, ctor.primaryKey);
         if (pk === undefined || pk === null) {
             throw new Error(`[RudderJS ORM] Model.morph("${name}", parent): parent.${ctor.primaryKey} is unset — save the parent first.`);
         }
@@ -1679,845 +1749,6 @@ export class Model {
         return Object.fromEntries(Object.entries(result).filter(([k]) => !effectiveHidden.includes(k)));
     }
 }
-// ─── Dirty tracking equality ───────────────────────────────
-/**
- * @internal — value equality used by dirty tracking. Mirrors Eloquent's
- * `originalIsEquivalent`: strict for primitives, `getTime()` for Date,
- * structural-by-JSON for arrays / plain objects (covers `json` / `array`
- * casts), null/undefined collapsed.
- *
- * Caveat: JSON.stringify is key-order sensitive, so `{a:1,b:2}` vs
- * `{b:2,a:1}` compares unequal. Same posture Laravel takes — documented
- * in the Dirty Tracking section of the orm README.
- */
-function _attrEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null && b == null)
-        return true;
-    if (a instanceof Date && b instanceof Date)
-        return a.getTime() === b.getTime();
-    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
-        try {
-            return JSON.stringify(a) === JSON.stringify(b);
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
-}
-function _camelHead(s) {
-    return s.charAt(0).toLowerCase() + s.slice(1);
-}
-function _morphParentQuery(self, ctor, def, name) {
-    const Related = def.model();
-    const idCol = `${def.morphName}Id`;
-    const typeCol = `${def.morphName}Type`;
-    const localCol = def.localKey ?? ctor.primaryKey;
-    const localVal = self[localCol];
-    const typeVal = def.morphType ?? ctor.morphAlias ?? ctor.name;
-    if (localVal === undefined || localVal === null) {
-        throw new Error(`[RudderJS ORM] Cannot resolve "${name}" on ${ctor.name} — ${localCol} is unset.`);
-    }
-    return Related.where(idCol, localVal).where(typeCol, typeVal);
-}
-function _resolveBelongsToManyMeta(Parent, Related, def) {
-    return {
-        pivotTable: def.pivotTable,
-        foreignPivotKey: def.foreignPivotKey ?? `${_camelHead(Parent.name)}Id`,
-        relatedPivotKey: def.relatedPivotKey ?? `${_camelHead(Related.name)}Id`,
-        parentKey: def.parentKey ?? Parent.primaryKey,
-        relatedKey: def.relatedKey ?? Related.primaryKey,
-    };
-}
-function _resolveMorphToManyMeta(Parent, Related, def) {
-    return {
-        pivotTable: def.pivotTable,
-        foreignPivotKey: `${def.morphName}Id`,
-        morphTypeKey: `${def.morphName}Type`,
-        morphTypeValue: def.morphType ?? Parent.morphAlias ?? Parent.name,
-        relatedPivotKey: def.relatedPivotKey ?? `${_camelHead(Related.name)}Id`,
-        parentKey: def.parentKey ?? Parent.primaryKey,
-        relatedKey: def.relatedKey ?? Related.primaryKey,
-    };
-}
-function _resolveMorphedByManyMeta(Parent, Related, def) {
-    return {
-        pivotTable: def.pivotTable,
-        relatedPivotKey: `${def.morphName}Id`,
-        morphTypeKey: `${def.morphName}Type`,
-        morphTypeValue: def.morphType ?? Related.morphAlias ?? Related.name,
-        foreignPivotKey: def.foreignPivotKey ?? `${_camelHead(Parent.name)}Id`,
-        parentKey: def.parentKey ?? Parent.primaryKey,
-        relatedKey: def.relatedKey ?? Related.primaryKey,
-    };
-}
-// ─── whereHas internals ────────────────────────────────────
-/**
- * Run the constrain callback against a recording-only QueryBuilder that
- * captures `.where()` calls into a flat `WhereClause[]` and treats every
- * other chainable method as a no-op. Nested `whereHas` inside the callback
- * throws — recursive predicates are deferred to v2.
- */
-function _captureConstraintWheres(constrain) {
-    const wheres = [];
-    const recorder = new Proxy({}, {
-        get(_t, prop) {
-            const name = String(prop);
-            if (name === 'where') {
-                return (col, opOrVal, maybeVal) => {
-                    if (maybeVal === undefined) {
-                        wheres.push({ column: col, operator: '=', value: opOrVal });
-                    }
-                    else {
-                        wheres.push({ column: col, operator: opOrVal, value: maybeVal });
-                    }
-                    return recorder;
-                };
-            }
-            if (name === 'whereHas' || name === 'whereDoesntHave' || name === 'withWhereHas') {
-                return () => {
-                    throw new Error(`[RudderJS ORM] Nested ${name} inside a whereHas constrain callback is deferred to v2. ` +
-                        `Filter on flat columns inside the callback for now.`);
-                };
-            }
-            if (name === 'orWhere') {
-                return () => {
-                    throw new Error(`[RudderJS ORM] orWhere inside a whereHas constrain callback is not supported in v1 — ` +
-                        `the WhereClause contract has no boolean flag, so the OR semantic can't round-trip to the adapter. ` +
-                        `Compose the predicate with where() (AND), or run two queries and merge in app code.`);
-                };
-            }
-            // All other chainable methods record nothing and return the recorder so
-            // `q.orderBy('x').limit(1)` chains through silently. Terminal methods
-            // (find/get/etc.) don't make sense in a constrain callback — they'd
-            // execute mid-build — but we don't intercept them here; they'd just
-            // return the recorder which then fails downstream. Keep the contract
-            // simple.
-            return () => recorder;
-        },
-    });
-    constrain(recorder);
-    return wheres;
-}
-/**
- * Resolve the `belongsTo` relation declaration on `Self` that points at
- * `ParentCtor`. When `relation` is given, looks it up directly. Otherwise
- * scans `Self.relations` for a single `belongsTo` whose `model()` resolves
- * to `ParentCtor` — throws on zero or multiple candidates.
- */
-function _resolveBelongsToFor(Self, ParentCtor, relation) {
-    if (relation !== undefined) {
-        const def = Self.relations[relation];
-        if (!def)
-            throw new Error(`[RudderJS ORM] Relation "${relation}" is not defined on ${Self.name}.`);
-        if (def.type !== 'belongsTo') {
-            throw new Error(`[RudderJS ORM] Relation "${relation}" on ${Self.name} is "${def.type}", not "belongsTo".`);
-        }
-        return def;
-    }
-    const candidates = [];
-    for (const [name, def] of Object.entries(Self.relations)) {
-        if (def.type !== 'belongsTo')
-            continue;
-        const btDef = def;
-        if (btDef.model() === ParentCtor)
-            candidates.push([name, btDef]);
-    }
-    if (candidates.length === 0) {
-        throw new Error(`[RudderJS ORM] whereBelongsTo: ${Self.name} has no belongsTo relation pointing at ${ParentCtor.name}. ` +
-            `Pass a relation name explicitly.`);
-    }
-    if (candidates.length > 1) {
-        const names = candidates.map(([n]) => n).join(', ');
-        throw new Error(`[RudderJS ORM] whereBelongsTo: ${Self.name} has multiple belongsTo relations pointing at ${ParentCtor.name} (${names}). ` +
-            `Pass the relation name explicitly.`);
-    }
-    return candidates[0][1];
-}
-/**
- * Build the {@link RelationExistencePredicate} for a relation declared on
- * `Parent` by `relation` and dispatch it to the adapter via
- * `q.whereRelationExists(predicate)`. Returns the same QueryBuilder for
- * chaining (the adapter mutates in place).
- *
- * `morphTo` throws — the related table isn't statically known so a single
- * EXISTS subquery can't represent it. Filter on the discriminator + id
- * columns directly when you need that semantic.
- */
-function _attachWhereHas(Parent, q, relation, exists, constrain) {
-    const def = Parent.relations[relation];
-    if (!def) {
-        throw new Error(`[RudderJS ORM] Relation "${relation}" is not defined on ${Parent.name}.`);
-    }
-    if (def.type === 'morphTo') {
-        throw new Error(`[RudderJS ORM] morphTo "${relation}" cannot be used with whereHas — the related table is dynamic. ` +
-            `Filter on ${def.morphName}Id / ${def.morphName}Type directly instead.`);
-    }
-    const constraintWheres = constrain ? _captureConstraintWheres(constrain) : [];
-    const predicate = _buildRelationPredicate(Parent, relation, def, exists, constraintWheres);
-    return q.whereRelationExists(predicate);
-}
-function _buildRelationPredicate(Parent, relation, def, exists, constraintWheres) {
-    const Related = def.model();
-    if (def.type === 'belongsToMany') {
-        const meta = _resolveBelongsToManyMeta(Parent, Related, def);
-        return {
-            relation,
-            exists,
-            relatedTable: Related.getTable(),
-            parentColumn: meta.parentKey,
-            relatedColumn: meta.relatedKey,
-            constraintWheres,
-            through: {
-                pivotTable: meta.pivotTable,
-                foreignPivotKey: meta.foreignPivotKey,
-                relatedPivotKey: meta.relatedPivotKey,
-            },
-        };
-    }
-    if (def.type === 'morphToMany') {
-        const meta = _resolveMorphToManyMeta(Parent, Related, def);
-        return {
-            relation,
-            exists,
-            relatedTable: Related.getTable(),
-            parentColumn: meta.parentKey,
-            relatedColumn: meta.relatedKey,
-            constraintWheres,
-            extraEquals: { [meta.morphTypeKey]: meta.morphTypeValue },
-            through: {
-                pivotTable: meta.pivotTable,
-                foreignPivotKey: meta.foreignPivotKey,
-                relatedPivotKey: meta.relatedPivotKey,
-            },
-        };
-    }
-    if (def.type === 'morphedByMany') {
-        const meta = _resolveMorphedByManyMeta(Parent, Related, def);
-        return {
-            relation,
-            exists,
-            relatedTable: Related.getTable(),
-            parentColumn: meta.parentKey,
-            relatedColumn: meta.relatedKey,
-            constraintWheres,
-            extraEquals: { [meta.morphTypeKey]: meta.morphTypeValue },
-            through: {
-                pivotTable: meta.pivotTable,
-                foreignPivotKey: meta.foreignPivotKey,
-                relatedPivotKey: meta.relatedPivotKey,
-            },
-        };
-    }
-    if (def.type === 'morphMany' || def.type === 'morphOne') {
-        const idCol = `${def.morphName}Id`;
-        const typeCol = `${def.morphName}Type`;
-        const localCol = def.localKey ?? Parent.primaryKey;
-        const typeVal = def.morphType ?? Parent.morphAlias ?? Parent.name;
-        return {
-            relation,
-            exists,
-            relatedTable: Related.getTable(),
-            parentColumn: localCol,
-            relatedColumn: idCol,
-            constraintWheres,
-            extraEquals: { [typeCol]: typeVal },
-        };
-    }
-    if (def.type === 'belongsTo') {
-        const fk = def.foreignKey ?? `${_camelHead(Related.name)}Id`;
-        const localCol = def.localKey ?? fk;
-        return {
-            relation,
-            exists,
-            relatedTable: Related.getTable(),
-            parentColumn: localCol,
-            relatedColumn: Related.primaryKey,
-            constraintWheres,
-        };
-    }
-    // hasOne / hasMany — related table holds the FK pointing back to Parent.
-    const fk = def.foreignKey ?? `${_camelHead(Parent.name)}Id`;
-    const localCol = def.localKey ?? Parent.primaryKey;
-    return {
-        relation,
-        exists,
-        relatedTable: Related.getTable(),
-        parentColumn: localCol,
-        relatedColumn: fk,
-        constraintWheres,
-    };
-}
-/**
- * `withWhereHas` — run `whereHas` AND eager-load the relation under the
- * same constraint when the adapter implements `withConstrained`. Adapters
- * without it fall back to plain `with(relation)` (constraint applies only
- * to the parent filter, not the eagerly loaded children).
- */
-function _attachWithWhereHas(Parent, q, relation, constrain) {
-    const constraintWheres = constrain ? _captureConstraintWheres(constrain) : [];
-    // Reuse _attachWhereHas for the parent-side filter — it re-runs the
-    // constrain callback against a fresh recorder, so the WhereClause[] we
-    // capture above and the one captured inside _attachWhereHas come from
-    // distinct recorder instances. That's intentional: each captures the
-    // same constraint independently and neither is mutated by the adapter.
-    _attachWhereHas(Parent, q, relation, true, constrain);
-    const withConstrained = q.withConstrained;
-    if (constraintWheres.length > 0 && typeof withConstrained === 'function') {
-        return withConstrained.call(q, relation, constraintWheres);
-    }
-    return q.with(relation);
-}
-function _attachWhereBelongsTo(Self, q, parent, relation) {
-    const ParentCtor = parent.constructor;
-    const def = _resolveBelongsToFor(Self, ParentCtor, relation);
-    const Related = def.model();
-    const fk = def.foreignKey ?? `${_camelHead(Related.name)}Id`;
-    const localCol = def.localKey ?? fk;
-    const parentVal = parent[ParentCtor.primaryKey];
-    if (parentVal === undefined || parentVal === null) {
-        throw new Error(`[RudderJS ORM] whereBelongsTo: parent.${ParentCtor.primaryKey} is unset on ${ParentCtor.name}.`);
-    }
-    return q.where(localCol, parentVal);
-}
-const _CHAIN_METHODS = new Set([
-    'where', 'orWhere', 'orderBy', 'limit', 'offset', 'with', 'withTrashed', 'onlyTrashed',
-]);
-const _TERMINAL_METHODS = new Set([
-    'first', 'find', 'get', 'all', 'count', 'paginate',
-]);
-const _UNSUPPORTED_TERMINALS = new Set([
-    'create', 'update', 'delete', 'restore', 'forceDelete', 'increment', 'decrement', 'insertMany', 'deleteAll', 'updateAll',
-]);
-function _replayChain(q, recorded) {
-    let cur = q;
-    for (const [m, args] of recorded) {
-        const fn = cur[m];
-        if (fn)
-            cur = fn.apply(cur, args);
-    }
-    return cur;
-}
-function _makeDeferredProxy(buildResolved, recorded, relationKind, hooks = {}) {
-    const proxy = new Proxy({}, {
-        get(_t, prop) {
-            const name = String(prop);
-            if (name === 'withPivot') {
-                return (...cols) => {
-                    if (cols.length === 0) {
-                        throw new Error('[RudderJS ORM] withPivot() requires at least one column name.');
-                    }
-                    hooks.onWithPivot?.(cols);
-                    return proxy;
-                };
-            }
-            if (_CHAIN_METHODS.has(name)) {
-                return (...args) => {
-                    recorded.push([name, args]);
-                    return proxy;
-                };
-            }
-            if (_TERMINAL_METHODS.has(name)) {
-                return async (...args) => {
-                    const q = await buildResolved();
-                    const fn = q[name];
-                    const raw = fn ? await fn.apply(q, args) : undefined;
-                    return hooks.postProcess ? hooks.postProcess(raw, name) : raw;
-                };
-            }
-            if (_UNSUPPORTED_TERMINALS.has(name)) {
-                return () => {
-                    throw new Error(`[RudderJS ORM] "${name}" is not supported on a ${relationKind} lazy-fetch query. ` +
-                        `Use Model.${relationKind}(parent, name) for pivot mutations or call methods on the related Model directly.`);
-                };
-            }
-            return undefined;
-        },
-    });
-    return proxy;
-}
-/**
- * Stamp `row.pivot = { col: value, ... }` for every row in `rows` whose
- * `relatedKey` matches a pivot row. Used by the three deferred QBs after the
- * second-step `Related` query resolves. Mutates rows in place; rows whose
- * pivot row is absent are left untouched (`pivot` stays undefined).
- */
-function _stampPivotOnRows(rows, relatedKey, pivotRows, relatedPivotKey, pivotColumns) {
-    if (pivotColumns.length === 0)
-        return;
-    const byId = new Map();
-    for (const p of pivotRows)
-        byId.set(p[relatedPivotKey], p);
-    for (const row of rows) {
-        if (row === null || row === undefined)
-            continue;
-        const pivot = byId.get(row[relatedKey]);
-        if (!pivot)
-            continue;
-        const projected = {};
-        for (const col of pivotColumns)
-            projected[col] = pivot[col];
-        row['pivot'] = projected;
-    }
-}
-/**
- * Stamp `pivot` onto a single result (object or array). Used by the deferred
- * proxy's `postProcess` hook — the terminal name (`first` / `find` / `get` /
- * `all` / `paginate`) determines whether to walk the result.
- */
-function _stampPivotOnResult(result, terminal, relatedKey, pivotRows, relatedPivotKey, pivotColumns) {
-    if (pivotColumns.length === 0)
-        return result;
-    if (result === null || result === undefined)
-        return result;
-    if (terminal === 'first' || terminal === 'find') {
-        _stampPivotOnRows([result], relatedKey, pivotRows, relatedPivotKey, pivotColumns);
-        return result;
-    }
-    if (terminal === 'get' || terminal === 'all') {
-        _stampPivotOnRows(result, relatedKey, pivotRows, relatedPivotKey, pivotColumns);
-        return result;
-    }
-    if (terminal === 'paginate') {
-        const page = result;
-        _stampPivotOnRows(page.data, relatedKey, pivotRows, relatedPivotKey, pivotColumns);
-        return result;
-    }
-    return result;
-}
-function _belongsToManyDeferredQb(Related, _def, meta, parentVal) {
-    const recorded = [];
-    const pivotColumns = [];
-    let lastPivotRows = [];
-    const buildResolved = async () => {
-        const adapter = ModelRegistry.getAdapter();
-        const pivotRows = await adapter
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .get();
-        lastPivotRows = pivotRows;
-        const ids = pivotRows.map(r => r[meta.relatedPivotKey]);
-        // Empty IN list — short-circuit with a guaranteed-empty query so
-        // adapters don't have to handle the edge case.
-        const q = Related.query()
-            .where(meta.relatedKey, 'IN', ids.length === 0 ? [] : ids);
-        return _replayChain(q, recorded);
-    };
-    return _makeDeferredProxy(buildResolved, recorded, 'belongsToMany', {
-        onWithPivot(cols) { pivotColumns.push(...cols); },
-        postProcess(result, terminal) {
-            return _stampPivotOnResult(result, terminal, meta.relatedKey, lastPivotRows, meta.relatedPivotKey, pivotColumns);
-        },
-    });
-}
-function _morphToManyDeferredQb(Related, _def, meta, parentVal) {
-    const recorded = [];
-    const pivotColumns = [];
-    let lastPivotRows = [];
-    const buildResolved = async () => {
-        const adapter = ModelRegistry.getAdapter();
-        const pivotRows = await adapter
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .where(meta.morphTypeKey, meta.morphTypeValue)
-            .get();
-        lastPivotRows = pivotRows;
-        const ids = pivotRows.map(r => r[meta.relatedPivotKey]);
-        const q = Related.query()
-            .where(meta.relatedKey, 'IN', ids.length === 0 ? [] : ids);
-        return _replayChain(q, recorded);
-    };
-    return _makeDeferredProxy(buildResolved, recorded, 'morphToMany', {
-        onWithPivot(cols) { pivotColumns.push(...cols); },
-        postProcess(result, terminal) {
-            return _stampPivotOnResult(result, terminal, meta.relatedKey, lastPivotRows, meta.relatedPivotKey, pivotColumns);
-        },
-    });
-}
-function _morphedByManyDeferredQb(Related, _def, meta, parentVal) {
-    const recorded = [];
-    const pivotColumns = [];
-    let lastPivotRows = [];
-    const buildResolved = async () => {
-        const adapter = ModelRegistry.getAdapter();
-        const pivotRows = await adapter
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .where(meta.morphTypeKey, meta.morphTypeValue)
-            .get();
-        lastPivotRows = pivotRows;
-        const ids = pivotRows.map(r => r[meta.relatedPivotKey]);
-        const q = Related.query()
-            .where(meta.relatedKey, 'IN', ids.length === 0 ? [] : ids);
-        return _replayChain(q, recorded);
-    };
-    return _makeDeferredProxy(buildResolved, recorded, 'morphedByMany', {
-        onWithPivot(cols) { pivotColumns.push(...cols); },
-        postProcess(result, terminal) {
-            return _stampPivotOnResult(result, terminal, meta.relatedKey, lastPivotRows, meta.relatedPivotKey, pivotColumns);
-        },
-    });
-}
-function _normalizeAttachInput(input, foreignPivotKey, parentVal, relatedPivotKey, flatPivot) {
-    const rows = [];
-    if (Array.isArray(input)) {
-        for (const id of input) {
-            rows.push({
-                ...(flatPivot ?? {}),
-                [foreignPivotKey]: parentVal,
-                [relatedPivotKey]: id,
-            });
-        }
-    }
-    else {
-        for (const [id, perIdPivot] of Object.entries(input)) {
-            // Normalize numeric-string keys back to numbers when possible — JS
-            // object keys are always strings; the pivot column may be int.
-            const idVal = /^\d+$/.test(id) ? Number(id) : id;
-            rows.push({
-                ...perIdPivot,
-                [foreignPivotKey]: parentVal,
-                [relatedPivotKey]: idVal,
-            });
-        }
-    }
-    return rows;
-}
-function _idsFromAttachInput(input) {
-    if (Array.isArray(input))
-        return [...input];
-    return Object.keys(input).map(k => /^\d+$/.test(k) ? Number(k) : k);
-}
-function _makeBelongsToManyAccessor(Parent, Related, def, parentVal) {
-    const meta = _resolveBelongsToManyMeta(Parent, Related, def);
-    const updatePivot = async (relatedId, data) => {
-        return ModelRegistry.getAdapter()
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .where(meta.relatedPivotKey, relatedId)
-            .updateAll(data);
-    };
-    return {
-        async attach(input, flatPivot) {
-            const ids = _idsFromAttachInput(input);
-            if (ids.length === 0)
-                return;
-            const rows = _normalizeAttachInput(input, meta.foreignPivotKey, parentVal, meta.relatedPivotKey, flatPivot);
-            await ModelRegistry.getAdapter()
-                .query(meta.pivotTable)
-                .insertMany(rows);
-        },
-        async detach(ids) {
-            const adapter = ModelRegistry.getAdapter();
-            let q = adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal);
-            if (ids !== undefined) {
-                if (ids.length === 0)
-                    return 0;
-                q = q.where(meta.relatedPivotKey, 'IN', [...ids]);
-            }
-            return q.deleteAll();
-        },
-        updatePivot,
-        async sync(arg1, flatPivot) {
-            const adapter = ModelRegistry.getAdapter();
-            const isMap = !Array.isArray(arg1);
-            const perIdMap = isMap ? arg1 : null;
-            const desiredIds = isMap
-                ? Object.keys(perIdMap).map(k => /^\d+$/.test(k) ? Number(k) : k)
-                : [...arg1];
-            const currentRows = await adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal)
-                .get();
-            const current = new Set(currentRows.map(r => r[meta.relatedPivotKey]));
-            const desired = new Set(desiredIds);
-            const attached = [];
-            const detached = [];
-            const updated = [];
-            for (const id of desired)
-                if (!current.has(id))
-                    attached.push(id);
-            for (const id of current)
-                if (!desired.has(id))
-                    detached.push(id);
-            if (attached.length > 0) {
-                const rows = attached.map(id => {
-                    const perIdPivot = perIdMap ? perIdMap[id] : undefined;
-                    return {
-                        ...(flatPivot ?? {}),
-                        ...(perIdPivot ?? {}),
-                        [meta.foreignPivotKey]: parentVal,
-                        [meta.relatedPivotKey]: id,
-                    };
-                });
-                await adapter.query(meta.pivotTable).insertMany(rows);
-            }
-            if (detached.length > 0) {
-                await adapter
-                    .query(meta.pivotTable)
-                    .where(meta.foreignPivotKey, parentVal)
-                    .where(meta.relatedPivotKey, 'IN', detached)
-                    .deleteAll();
-            }
-            if (perIdMap) {
-                // Reconcile extras on still-present ids by overwriting with the
-                // requested pivot data — matches Filament's posture (the form
-                // value wins). Skip when the supplied pivot is empty.
-                for (const id of desired) {
-                    if (!current.has(id))
-                        continue;
-                    const perIdPivot = perIdMap[id];
-                    if (!perIdPivot || Object.keys(perIdPivot).length === 0)
-                        continue;
-                    await updatePivot(id, perIdPivot);
-                    updated.push(id);
-                }
-            }
-            return { attached, detached, updated };
-        },
-    };
-}
-/**
- * Install per-relation prototype methods for every `belongsToMany` entry
- * declared on `static relations`. Idempotent — won't overwrite a method
- * the author already defined (typing escape hatch).
- *
- * Called on first query (via `ModelRegistry.register`) and once more
- * defensively from `Model.belongsToMany` so apps that construct instances
- * without ever querying still get the auto-method.
- */
-function _installBelongsToManyMethods(ModelClass) {
-    for (const [name, def] of Object.entries(ModelClass.relations)) {
-        if (def.type !== 'belongsToMany')
-            continue;
-        if (Object.prototype.hasOwnProperty.call(ModelClass.prototype, name))
-            continue;
-        Object.defineProperty(ModelClass.prototype, name, {
-            configurable: true,
-            writable: true,
-            value() {
-                return Model.belongsToMany(this, name);
-            },
-        });
-    }
-}
-function _makeMorphToManyAccessor(Parent, Related, def, parentVal) {
-    const meta = _resolveMorphToManyMeta(Parent, Related, def);
-    const updatePivot = async (relatedId, data) => {
-        return ModelRegistry.getAdapter()
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .where(meta.morphTypeKey, meta.morphTypeValue)
-            .where(meta.relatedPivotKey, relatedId)
-            .updateAll(data);
-    };
-    return {
-        async attach(input, flatPivot) {
-            const ids = _idsFromAttachInput(input);
-            if (ids.length === 0)
-                return;
-            const rows = _normalizeAttachInput(input, meta.foreignPivotKey, parentVal, meta.relatedPivotKey, flatPivot)
-                .map(r => ({ ...r, [meta.morphTypeKey]: meta.morphTypeValue }));
-            await ModelRegistry.getAdapter()
-                .query(meta.pivotTable)
-                .insertMany(rows);
-        },
-        async detach(ids) {
-            const adapter = ModelRegistry.getAdapter();
-            let q = adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal)
-                .where(meta.morphTypeKey, meta.morphTypeValue);
-            if (ids !== undefined) {
-                if (ids.length === 0)
-                    return 0;
-                q = q.where(meta.relatedPivotKey, 'IN', [...ids]);
-            }
-            return q.deleteAll();
-        },
-        updatePivot,
-        async sync(arg1, flatPivot) {
-            const adapter = ModelRegistry.getAdapter();
-            const isMap = !Array.isArray(arg1);
-            const perIdMap = isMap ? arg1 : null;
-            const desiredIds = isMap
-                ? Object.keys(perIdMap).map(k => /^\d+$/.test(k) ? Number(k) : k)
-                : [...arg1];
-            const currentRows = await adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal)
-                .where(meta.morphTypeKey, meta.morphTypeValue)
-                .get();
-            const current = new Set(currentRows.map(r => r[meta.relatedPivotKey]));
-            const desired = new Set(desiredIds);
-            const attached = [];
-            const detached = [];
-            const updated = [];
-            for (const id of desired)
-                if (!current.has(id))
-                    attached.push(id);
-            for (const id of current)
-                if (!desired.has(id))
-                    detached.push(id);
-            if (attached.length > 0) {
-                const rows = attached.map(id => {
-                    const perIdPivot = perIdMap ? perIdMap[id] : undefined;
-                    return {
-                        ...(flatPivot ?? {}),
-                        ...(perIdPivot ?? {}),
-                        [meta.foreignPivotKey]: parentVal,
-                        [meta.relatedPivotKey]: id,
-                        [meta.morphTypeKey]: meta.morphTypeValue,
-                    };
-                });
-                await adapter.query(meta.pivotTable).insertMany(rows);
-            }
-            if (detached.length > 0) {
-                await adapter
-                    .query(meta.pivotTable)
-                    .where(meta.foreignPivotKey, parentVal)
-                    .where(meta.morphTypeKey, meta.morphTypeValue)
-                    .where(meta.relatedPivotKey, 'IN', detached)
-                    .deleteAll();
-            }
-            if (perIdMap) {
-                for (const id of desired) {
-                    if (!current.has(id))
-                        continue;
-                    const perIdPivot = perIdMap[id];
-                    if (!perIdPivot || Object.keys(perIdPivot).length === 0)
-                        continue;
-                    await updatePivot(id, perIdPivot);
-                    updated.push(id);
-                }
-            }
-            return { attached, detached, updated };
-        },
-    };
-}
-function _makeMorphedByManyAccessor(Parent, Related, def, parentVal) {
-    const meta = _resolveMorphedByManyMeta(Parent, Related, def);
-    const updatePivot = async (relatedId, data) => {
-        return ModelRegistry.getAdapter()
-            .query(meta.pivotTable)
-            .where(meta.foreignPivotKey, parentVal)
-            .where(meta.morphTypeKey, meta.morphTypeValue)
-            .where(meta.relatedPivotKey, relatedId)
-            .updateAll(data);
-    };
-    return {
-        async attach(input, flatPivot) {
-            const ids = _idsFromAttachInput(input);
-            if (ids.length === 0)
-                return;
-            // Parent is the strong side, related is the polymorphic side. Each row
-            // carries: parent FK, related FK, related-class discriminator.
-            const rows = _normalizeAttachInput(input, meta.foreignPivotKey, parentVal, meta.relatedPivotKey, flatPivot)
-                .map(r => ({ ...r, [meta.morphTypeKey]: meta.morphTypeValue }));
-            await ModelRegistry.getAdapter()
-                .query(meta.pivotTable)
-                .insertMany(rows);
-        },
-        async detach(ids) {
-            const adapter = ModelRegistry.getAdapter();
-            let q = adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal)
-                .where(meta.morphTypeKey, meta.morphTypeValue);
-            if (ids !== undefined) {
-                if (ids.length === 0)
-                    return 0;
-                q = q.where(meta.relatedPivotKey, 'IN', [...ids]);
-            }
-            return q.deleteAll();
-        },
-        updatePivot,
-        async sync(arg1, flatPivot) {
-            const adapter = ModelRegistry.getAdapter();
-            const isMap = !Array.isArray(arg1);
-            const perIdMap = isMap ? arg1 : null;
-            const desiredIds = isMap
-                ? Object.keys(perIdMap).map(k => /^\d+$/.test(k) ? Number(k) : k)
-                : [...arg1];
-            const currentRows = await adapter
-                .query(meta.pivotTable)
-                .where(meta.foreignPivotKey, parentVal)
-                .where(meta.morphTypeKey, meta.morphTypeValue)
-                .get();
-            const current = new Set(currentRows.map(r => r[meta.relatedPivotKey]));
-            const desired = new Set(desiredIds);
-            const attached = [];
-            const detached = [];
-            const updated = [];
-            for (const id of desired)
-                if (!current.has(id))
-                    attached.push(id);
-            for (const id of current)
-                if (!desired.has(id))
-                    detached.push(id);
-            if (attached.length > 0) {
-                const rows = attached.map(id => {
-                    const perIdPivot = perIdMap ? perIdMap[id] : undefined;
-                    return {
-                        ...(flatPivot ?? {}),
-                        ...(perIdPivot ?? {}),
-                        [meta.foreignPivotKey]: parentVal,
-                        [meta.relatedPivotKey]: id,
-                        [meta.morphTypeKey]: meta.morphTypeValue,
-                    };
-                });
-                await adapter.query(meta.pivotTable).insertMany(rows);
-            }
-            if (detached.length > 0) {
-                await adapter
-                    .query(meta.pivotTable)
-                    .where(meta.foreignPivotKey, parentVal)
-                    .where(meta.morphTypeKey, meta.morphTypeValue)
-                    .where(meta.relatedPivotKey, 'IN', detached)
-                    .deleteAll();
-            }
-            if (perIdMap) {
-                for (const id of desired) {
-                    if (!current.has(id))
-                        continue;
-                    const perIdPivot = perIdMap[id];
-                    if (!perIdPivot || Object.keys(perIdPivot).length === 0)
-                        continue;
-                    await updatePivot(id, perIdPivot);
-                    updated.push(id);
-                }
-            }
-            return { attached, detached, updated };
-        },
-    };
-}
-/**
- * Install per-relation prototype methods for every `morphToMany` /
- * `morphedByMany` entry. Same idempotent shape as
- * {@link _installBelongsToManyMethods}.
- */
-function _installMorphPivotMethods(ModelClass) {
-    for (const [name, def] of Object.entries(ModelClass.relations)) {
-        if (def.type !== 'morphToMany' && def.type !== 'morphedByMany')
-            continue;
-        if (Object.prototype.hasOwnProperty.call(ModelClass.prototype, name))
-            continue;
-        const isOwning = def.type === 'morphToMany';
-        Object.defineProperty(ModelClass.prototype, name, {
-            configurable: true,
-            writable: true,
-            value() {
-                return isOwning
-                    ? Model.morphToMany(this, name)
-                    : Model.morphedByMany(this, name);
-            },
-        });
-    }
-}
 // ─── Compile-time contract check ───────────────────────────
 // Asserts that `Model`'s static surface conforms to the `ModelLike`
 // contract from `@rudderjs/contracts`. Downstream tools (admin panels
@@ -2525,7 +1756,6 @@ function _installMorphPivotMethods(ModelClass) {
 // `ModelLike` so they don't need to depend on `@rudderjs/orm` directly.
 // This line will fail to compile if a future change to Model breaks
 // that contract.
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const _modelSatisfiesContract = Model;
 void _modelSatisfiesContract;
 //# sourceMappingURL=index.js.map