@webda/models 0.0.0-stage → 4.0.0-beta.4

package/lib/relations.js

@@ -0,0 +1,938 @@
+var _a, _b, _c, _d;
+import { isStorable, PrimaryKeyEquals, WEBDA_PRIMARY_KEY } from "./storable.js";
+import { useRepository } from "./repositories/hooks.js";
+import * as WebdaQL from "@webda/ql";
+/** Symbol key holding the parent Storable of a relation. */
+//export const RelationParent = Symbol("RelationParent");
+/** Symbol key holding the primary key value of a relation target. */
+export const RelationKey = Symbol("RelationKey");
+/** Symbol key holding the repository used to resolve a relation. */
+export const RelationRepository = Symbol("RelationRepository");
+/** Symbol key identifying the role of a relation (Link, Related, Links, CustomLinks). */
+export const RelationRole = Symbol("RelationRole");
+/** Symbol key holding custom data on a ModelRefCustom. */
+export const RelationData = Symbol("RelationData");
+/** Symbol key holding the model. */
+export const RelationModel = Symbol("RelationModel");
+/** Symbol key holding the type of custom attributes on a ModelLinksArray. */
+export const RelationAttributes = Symbol("RelationAttributes");
+/**
+ * Assign non symbol properties from source to target
+ * @param target - the destination object
+ * @param source - the source object
+ */
+export function assignNonSymbols(target, source) {
+    Object.keys(source).forEach(key => {
+        target[key] = source[key];
+    });
+}
+/**
+ * A reference to a model
+ */
+export class ModelRef {
+    /**
+     * Create a new model reference
+     * @param key - Primary key of the referenced model
+     * @param repository - Repository to resolve the reference against
+     * @param parent - Parent storable that owns this reference
+     */
+    constructor(key, repository, parent) {
+        // this[RelationParent] = parent;
+        this[RelationKey] = key;
+        this[RelationRepository] = repository;
+    }
+    /**
+     * Get the repository and ensure it's initialized
+     * @returns the repository instance
+     */
+    getRepository() {
+        if (!this[RelationRepository]) {
+            throw new Error("Relation repository is not initialized");
+        }
+        return this[RelationRepository];
+    }
+    /**
+     * Get the primary key and ensure it's initialized
+     * @returns the primary key value
+     */
+    getKey() {
+        return this.getPrimaryKey();
+    }
+    /**
+     * Get the model
+     * @returns the primary key value
+     */
+    getPrimaryKey() {
+        if (!this[RelationKey]) {
+            throw new Error("Relation key is not initialized");
+        }
+        return this[RelationKey];
+    }
+    /**
+     * Serialize the reference to its primary key value
+     * @returns the primary key value
+     */
+    toJSON() {
+        return this.getKey();
+    }
+    /**
+     * Set the attribute of the model
+     * @param attribute - the attribute path to set
+     * @param value - the new attribute value
+     * @returns a promise resolving when complete
+     */
+    setAttribute(attribute, value) {
+        return this.getRepository().setAttribute(this.getKey(), attribute, value);
+    }
+    /**
+     * Patch the model
+     * @param data - the partial data to patch
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    patch(data, conditionField, condition) {
+        return this.getRepository().patch(this.getKey(), data, conditionField, condition);
+    }
+    /**
+     * Fully replace the model data (except primary key fields)
+     * @param data - Complete model data excluding primary key
+     * @param conditionField - Optional field for optimistic locking
+     * @param condition - Expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    update(data, conditionField, condition) {
+        return this.getRepository().update({ ...data, ...this.getKey() }, conditionField, condition);
+    }
+    /**
+     * Get the model referenced by the key
+     * @returns the resolved model instance
+     */
+    get() {
+        return this.getRepository().get(this.getKey());
+    }
+    /**
+     * Delete the model
+     *
+     * If a condition is specified, it will be used to check if the model can be deleted
+     *
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    delete(conditionField, condition) {
+        return this.getRepository().delete(this.getKey(), conditionField, condition);
+    }
+    /**
+     * Check if the model exists in the repository
+     * @returns true if the model exists
+     */
+    exists() {
+        return this.getRepository().exists(this.getKey());
+    }
+    /**
+     * Increment the attributes of the model
+     * @param info The attributes to increment
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    incrementAttributes(info, conditionField, condition) {
+        return this.getRepository().incrementAttributes(this.getKey(), info, conditionField, condition);
+    }
+    /**
+     * Add an item to a collection
+     * @param collection - the collection field name
+     * @param item - the item to add or update
+     * @param index - optional position to insert at
+     * @param itemWriteConditionField - optional field for item write condition
+     * @param itemWriteCondition - expected value for the item write condition
+     * @returns a promise resolving when complete
+     */
+    upsertItemToCollection(collection, item, index, itemWriteConditionField, itemWriteCondition) {
+        return this.getRepository().upsertItemToCollection(this.getKey(), collection, item, index, itemWriteConditionField, itemWriteCondition);
+    }
+    /**
+     * Remove an item from a collection
+     * @param collection - the collection field name
+     * @param index - the position to remove from
+     * @param itemWriteConditionField - optional field for item write condition
+     * @param itemWriteCondition - expected value for the item write condition
+     * @returns a promise resolving when complete
+     */
+    deleteItemFromCollection(collection, index, itemWriteConditionField, itemWriteCondition) {
+        return this.getRepository().deleteItemFromCollection(this.getKey(), collection, index, itemWriteConditionField, itemWriteCondition);
+    }
+    /**
+     * Remove an attribute from the model
+     * @param attribute - the attribute to remove
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    removeAttribute(attribute, conditionField, condition) {
+        return this.getRepository().removeAttribute(this.getKey(), attribute, conditionField, condition);
+    }
+    /**
+     * Increment only one attribute of the model
+     * @param property - the numeric property to increment
+     * @param value - the increment amount
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    incrementAttribute(property, value, conditionField, condition) {
+        return this.incrementAttributes([{ property: property, value: value }], conditionField, condition);
+    }
+}
+/**
+ * Model reference with create and upsert methods
+ */
+export class ModelRefWithCreate extends ModelRef {
+    /**
+     * Upsert a model reference
+     * @param data - the model data excluding primary key
+     * @returns the upserted model instance
+     */
+    upsert(data) {
+        return this.getRepository().upsert({
+            ...data,
+            ...this.getRepository().getPrimaryKey(this.getKey(), true)
+        });
+    }
+    /**
+     * Create a model reference
+     *
+     * It will fail if the model already exists
+     * @param data - the model data excluding primary key
+     * @returns the created model instance
+     */
+    create(data) {
+        return this.getRepository().create({
+            ...data,
+            ...this.getRepository().getPrimaryKey(this.getKey(), true)
+        });
+    }
+}
+/**
+ * Define a 1:n relation on the current model to another model
+ *
+ * T is the model to link to
+ * _K is the attribute in T to query
+ *
+ * _K is not used but is required to complete the graph
+ * _K define the attribute to use to load the related objects
+ *
+ * In SQL if current model is TableA and T is TableB, _K is the foreign key in TableB
+ *
+ * TODO Deduce attribute from the ModelParent on the other side when "" is used
+ */
+export class ModelRelated {
+    /** Create a new ModelRelated
+     * @param targetClass - the target model class
+     * @param object - the source object owning the relation
+     * @param attribute - the attribute name linking the relation
+     */
+    constructor(targetClass, object, attribute = "") {
+        this.object = object;
+        this.attribute = attribute;
+        this.repoSource = useRepository(targetClass);
+    }
+    /**
+     * Build a WebdaQL query string that filters related objects by this model's primary key.
+     * @param query - optional additional query filter
+     * @returns the constructed query string
+     */
+    getQuery(query = "") {
+        // escape() makes keys containing quotes or backslashes round-trip through the parser
+        return WebdaQL.PrependCondition(query, WebdaQL.escape([`${this.attribute} = `, ""], [String(this.object.getPrimaryKey())]));
+    }
+    /**
+     * Query the related objects
+     * @param query - optional additional query filter, optionally with `?` or `:name` placeholders
+     * @param params - values for the placeholders: an array for `?`, an object for `:name`
+     * @returns the query results with optional continuation token
+     */
+    async query(query = "", params) {
+        // Bind before merging the relation condition, which parses the query
+        const q = this.getQuery(params === undefined ? query : WebdaQL.bind(query, params));
+        return this.repoSource.query(q);
+    }
+    /**
+     * Iterate through linked objects
+     * @param query - the query filter, optionally with `?` or `:name` placeholders
+     * @param params - values for the placeholders: an array for `?`, an object for `:name`
+     * @returns an async iterable of linked objects
+     */
+    iterate(query, params) {
+        const q = this.getQuery(params === undefined ? query : WebdaQL.bind(query, params));
+        return this.repoSource.iterate(q);
+    }
+    /**
+     * It is a helper and should not be serialized
+     */
+    toJSON() {
+        return;
+    }
+}
+/**
+ * Define a link to n:1 or 1:1 relation on the current model to another model
+ *
+ * T is the model to link to
+ *
+ * This is expected to be the symetric of ModelRelated or ModelLink in a 1:1 relation
+ *
+ * ```
+ * class Album extends Model {
+ *  artist: ModelLink<Artist>;
+ * }
+ * ```
+ */
+export class ModelLink {
+    static { _a = RelationRole; }
+    /** Create a new ModelLink
+     * @param model - the model class to link to
+     */
+    constructor(
+    /**
+     * The repository of the object to link
+     */
+    model) {
+        this[_a] = "Link";
+        this[RelationModel] = model;
+    }
+    /**
+     * Resolve the link and fetch the target model from the repository
+     * @returns the linked model instance
+     */
+    async get() {
+        if (!this[RelationKey]) {
+            throw new Error("Relation key is not initialized");
+        }
+        return (await useRepository(this[RelationModel]).get(this[RelationKey]));
+    }
+    /**
+     * Update the link to point to a different target
+     * @param id - New target: a primary key, model instance, or string UID
+     * @returns this link instance
+     * @WebdaAutoSetter
+     */
+    set(id) {
+        this[RelationKey] = isStorable(id)
+            ? id.getPrimaryKey()
+            : typeof id === "string"
+                ? useRepository(this[RelationModel]).parseUID(id)
+                : id;
+        return this;
+    }
+    /**
+     * Return the string representation of the linked key
+     * @returns the string representation
+     */
+    toString() {
+        if (!this[RelationKey]) {
+            throw new Error("Relation key is not initialized");
+        }
+        return this[RelationKey].toString();
+    }
+    /**
+     * Serialize the link to its primary key value
+     * @returns the primary key value
+     */
+    toJSON() {
+        if (!this[RelationKey]) {
+            throw new Error("Relation key is not initialized");
+        }
+        return this[RelationKey];
+    }
+    /**
+     * Get the primary key of the linked model
+     * @returns the primary key value
+     */
+    getPrimaryKey() {
+        if (!this[RelationKey]) {
+            throw new Error("Relation key is not initialized");
+        }
+        return this[RelationKey];
+    }
+}
+/**
+ * Link to a collection of objects
+ *
+ * Uses composition instead of extending Array for better maintainability,
+ * performance, and type safety.
+ *
+ * This allows to do a n:m or 1:n relation between two models
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects
+ */
+export class ModelLinksSimpleArray {
+    /** Create a new ModelLinksSimpleArray
+     * @param model - the model class for linked items
+     * @param content - initial array of primary keys
+     * @param parentObject - optional parent object owning this relation
+     */
+    constructor(model, content = [], parentObject) {
+        this[_b] = "Links";
+        // COMPOSITION: Internal array instead of extending Array
+        this.items = [];
+        this[RelationRepository] = useRepository(model);
+        // Initialize internal array
+        this.items = content.map(c => this.getModelRef(c));
+        // Return a Proxy to support indexed access like an array
+        return new Proxy(this, {
+            get(target, prop) {
+                // Handle numeric indices
+                if (typeof prop === "string" && /^\d+$/.test(prop)) {
+                    return target.items[parseInt(prop, 10)];
+                }
+                // Handle all other properties normally
+                return target[prop];
+            },
+            set(target, prop, value) {
+                // Handle numeric indices
+                if (typeof prop === "string" && /^\d+$/.test(prop)) {
+                    target.items[parseInt(prop, 10)] = value;
+                    return true;
+                }
+                // Handle all other properties normally
+                target[prop] = value;
+                return true;
+            }
+        });
+    }
+    /**
+     * Add items to the end of the collection
+     * @param items - items to add
+     * @returns the new collection length
+     */
+    push(...items) {
+        const result = this.items.push(...items.map(i => this.getModelRef(i)));
+        this.setDirty();
+        return result;
+    }
+    /**
+     * Add items to the beginning of the collection
+     * @param items - items to prepend
+     * @returns the new collection length
+     */
+    unshift(...items) {
+        const result = this.items.unshift(...items.map(i => this.getModelRef(i)));
+        this.setDirty();
+        return result;
+    }
+    /**
+     * Remove and return the last item
+     * @returns the removed item, or undefined
+     */
+    pop() {
+        const result = this.items.pop();
+        if (result !== undefined) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Remove and return the first item
+     * @returns the removed item, or undefined
+     */
+    shift() {
+        const result = this.items.shift();
+        if (result !== undefined) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Remove/add items at specified index
+     * @param start - the start index
+     * @param deleteCount - number of items to remove
+     * @param rest - items to insert
+     * @returns the removed items
+     */
+    splice(start, deleteCount, ...rest) {
+        const result = this.items.splice(start, deleteCount, ...rest.map(i => this.getModelRef(i)));
+        if (result.length > 0 || rest.length > 0) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Add a model to the collection
+     * @param model - the model to add
+     * @deprecated use push instead
+     */
+    add(model) {
+        this.push(model);
+    }
+    /**
+     * Set the collection to a new set of items
+     * @param items - the new items to set
+     * @WebdaAutoSetter
+     */
+    set(items) {
+        this.items = items?.map(i => this.getModelRef(i)) || [];
+        this.setDirty();
+    }
+    /**
+     * Remove item by reference or primary key
+     * @param model - the item to remove
+     * @returns true if the item was found and removed
+     */
+    remove(model) {
+        const uuid = this.getModelRef(model).getPrimaryKey().toString();
+        const index = this.items.findIndex(m => m.getPrimaryKey().toString() === uuid);
+        if (index >= 0) {
+            this.items.splice(index, 1);
+            this.setDirty();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get the number of items
+     * @returns the item count
+     */
+    get length() {
+        return this.items.length;
+    }
+    /**
+     * Get item at index
+     * @param index - the array index
+     * @returns the item, or undefined
+     */
+    at(index) {
+        return this.items[index];
+    }
+    /**
+     * Find item by predicate
+     * @param predicate - the search predicate
+     * @returns the found item, or undefined
+     */
+    find(predicate) {
+        return this.items.find(predicate);
+    }
+    /**
+     * Find index by predicate
+     * @param predicate - the search predicate
+     * @returns the index, or -1
+     */
+    findIndex(predicate) {
+        return this.items.findIndex(predicate);
+    }
+    /**
+     * Map over items (does NOT mutate)
+     * @param callback - the mapping function
+     * @returns the mapped array
+     */
+    map(callback) {
+        return this.items.map(callback);
+    }
+    /**
+     * Filter items (does NOT mutate)
+     * @param predicate - the filter predicate
+     * @returns the filtered items
+     */
+    filter(predicate) {
+        return this.items.filter(predicate);
+    }
+    /**
+     * Execute callback for each item
+     * @param callback - the function to execute for each item
+     */
+    forEach(callback) {
+        this.items.forEach(callback);
+    }
+    /**
+     * Check if any item matches predicate
+     * @param predicate - the test predicate
+     * @returns true if any item matches
+     */
+    some(predicate) {
+        return this.items.some(predicate);
+    }
+    /**
+     * Check if all items match predicate
+     * @param predicate - the test predicate
+     * @returns true if all items match
+     */
+    every(predicate) {
+        return this.items.every(predicate);
+    }
+    /**
+     * Convert to JSON
+     * @returns array of primary key values
+     */
+    toJSON() {
+        return this.items.map(m => m.getPrimaryKey());
+    }
+    /**
+     * Make the collection iterable (for...of loops)
+     * @returns an iterator over the items
+     */
+    [(_b = RelationRole, Symbol.iterator)]() {
+        return this.items[Symbol.iterator]();
+    }
+    /**
+     * Convert any accepted input (string, key, ref, or model) into a ModelRef
+     * @param model - the input to convert
+     * @returns the model reference
+     */
+    getModelRef(model) {
+        let modelRef;
+        if (typeof model === "string") {
+            modelRef = new ModelRef(this[RelationRepository].parseUID(model), this[RelationRepository]);
+        }
+        else if (model instanceof ModelRef) {
+            modelRef = model;
+        }
+        else if (isStorable(model)) {
+            modelRef = new ModelRef(model.getPrimaryKey(), this[RelationRepository]);
+        }
+        else {
+            modelRef = new ModelRef(model, this[RelationRepository]);
+        }
+        return modelRef;
+    }
+    /**
+     * Mark the parent model's property for this collection as dirty
+     */
+    setDirty() {
+        // no-op: dirty tracking is handled by the deep proxy in track()
+    }
+}
+/**
+ * ModelRef with custom properties
+ *
+ * This is used to define a link to a collection of objects with additional data
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects and additional properties defined as K
+ *
+ * Sample usage:
+ * ```typescript
+ * class MyModel extends AbstractCoreModel {
+ *   _links: ModelLinksArray<OtherModel, { custom: string }>;
+ * }
+ * ```
+ */
+class ModelRefCustom extends ModelRef {
+    /** Create a new ModelRefCustom
+     * @param key - the primary key of the referenced object
+     * @param repo - the repository managing the referenced model
+     * @param data - custom data associated with this reference
+     * @param parent - optional parent storable
+     */
+    constructor(key, repo, data, parent) {
+        super(key, repo, parent);
+        this[RelationData] = data;
+        assignNonSymbols(this, data);
+        // We might want to explore moving data in sub-classes
+    }
+    /**
+     * Override toJSON to include custom properties along with primary key
+     * @returns the relation data
+     */
+    toJSON() {
+        // Return the relation data which should already include the primary key
+        // along with any additional custom properties
+        return this[RelationData];
+    }
+}
+/**
+ * Link to a collection of objects including some additional data
+ *
+ * Uses composition instead of extending Array for better maintainability,
+ * performance, and type safety. Provides array-like interface through
+ * explicit methods and iterators.
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects and additional properties defined as K
+ *
+ * Sample usage:
+ * ```typescript
+ * class MyModel extends AbstractCoreModel {
+ *   _links: ModelLinksArray<OtherModel, { custom: string }>;
+ * }
+ * ```
+ */
+export class ModelLinksArray {
+    /** Create a new ModelLinksCustomArray
+     * @param repo - the repository for the linked model
+     * @param content - initial array of primary keys with custom data
+     */
+    constructor(repo, content = []
+    //parentObject?: T
+    ) {
+        this.repo = repo;
+        this[_c] = "CustomLinks";
+        // COMPOSITION: Internal array instead of extending Array
+        this.items = [];
+        //this[RelationParent] = parentObject!;
+        // Initialize internal array
+        this.items = content.map(c => new ModelRefCustom(repo.getPrimaryKey(c), repo, c));
+        // Return a Proxy to support indexed access like an array
+        return new Proxy(this, {
+            get(target, prop) {
+                // Handle numeric indices
+                if (typeof prop === "string" && /^\d+$/.test(prop)) {
+                    return target.items[parseInt(prop, 10)];
+                }
+                // Handle all other properties normally
+                return target[prop];
+            },
+            set(target, prop, value) {
+                // Handle numeric indices
+                if (typeof prop === "string" && /^\d+$/.test(prop)) {
+                    target.items[parseInt(prop, 10)] = value;
+                    return true;
+                }
+                // Handle all other properties normally
+                target[prop] = value;
+                return true;
+            }
+        });
+    }
+    /**
+     * Add a model to the collection
+     * @param model - the model to add
+     * @deprecated use push instead
+     */
+    add(model) {
+        this.push(new ModelRefCustom(this.repo.getPrimaryKey(model), this.repo, model));
+    }
+    /**
+     * Add items to the end of the collection
+     * @param items - items to add
+     * @returns the new collection length
+     */
+    push(...items) {
+        const result = this.items.push(...items.map(i => this.getModelRef(i)));
+        this.setDirty();
+        return result;
+    }
+    /**
+     * Remove and return the last item
+     * @returns the removed item, or undefined
+     */
+    pop() {
+        const result = this.items.pop();
+        if (result !== undefined) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Remove and return the first item
+     * @returns the removed item, or undefined
+     */
+    shift() {
+        const result = this.items.shift();
+        if (result !== undefined) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Add items to the beginning of the collection
+     * @param items - items to prepend
+     * @returns the new collection length
+     */
+    unshift(...items) {
+        const result = this.items.unshift(...items.map(i => this.getModelRef(i)));
+        this.setDirty();
+        return result;
+    }
+    /**
+     * Remove/add items at specified index
+     * @param start - the start index
+     * @param deleteCount - number of items to remove
+     * @param rest - items to insert
+     * @returns the removed items
+     */
+    splice(start, deleteCount, ...rest) {
+        const result = this.items.splice(start, deleteCount, ...rest.map(i => this.getModelRef(i)));
+        if (result.length > 0 || rest.length > 0) {
+            this.setDirty();
+        }
+        return result;
+    }
+    /**
+     * Remove item by reference or primary key
+     * @param model - the item to remove
+     * @returns true if found and removed
+     */
+    remove(model) {
+        const uuid = typeof model["getPrimaryKey"] === "function" ? model["getPrimaryKey"]() : model;
+        const index = this.items.findIndex(m => PrimaryKeyEquals(m.getPrimaryKey(), uuid));
+        if (index >= 0) {
+            this.items.splice(index, 1);
+            this.setDirty();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get the number of items
+     * @returns the item count
+     */
+    get length() {
+        return this.items.length;
+    }
+    /**
+     * Get item at index
+     * @param index - the array index
+     * @returns the item, or undefined
+     */
+    at(index) {
+        return this.items[index];
+    }
+    /**
+     * Find item by predicate
+     * @param predicate - the search predicate
+     * @returns the found item, or undefined
+     */
+    find(predicate) {
+        return this.items.find(predicate);
+    }
+    /**
+     * Find index by predicate
+     * @param predicate - the search predicate
+     * @returns the index, or -1
+     */
+    findIndex(predicate) {
+        return this.items.findIndex(predicate);
+    }
+    /**
+     * Check if item exists in collection
+     * @param search - the item to look for
+     * @param fromIndex - optional start index
+     * @returns true if found
+     */
+    includes(search, fromIndex) {
+        return this.items.includes(search, fromIndex);
+    }
+    /**
+     * Map over items (does NOT mutate)
+     * @param callback - the mapping function
+     * @returns the mapped array
+     */
+    map(callback) {
+        return this.items.map(callback);
+    }
+    /**
+     * Filter items (does NOT mutate)
+     * @param predicate - the filter predicate
+     * @returns the filtered items
+     */
+    filter(predicate) {
+        return this.items.filter(predicate);
+    }
+    /**
+     * Execute callback for each item
+     * @param callback - the function to execute for each item
+     */
+    forEach(callback) {
+        this.items.forEach(callback);
+    }
+    /**
+     * Check if any item matches predicate
+     * @param predicate - the test predicate
+     * @returns true if any item matches
+     */
+    some(predicate) {
+        return this.items.some(predicate);
+    }
+    /**
+     * Check if all items match predicate
+     * @param predicate - the test predicate
+     * @returns true if all items match
+     */
+    every(predicate) {
+        return this.items.every(predicate);
+    }
+    /**
+     * Convert to JSON
+     * @returns array of serialized items
+     */
+    toJSON() {
+        return this.items;
+    }
+    /**
+     * Make the collection iterable (for...of loops)
+     * @returns an iterator over the items
+     */
+    [(_c = RelationRole, Symbol.iterator)]() {
+        return this.items[Symbol.iterator]();
+    }
+    /**
+     * Convert input into a ModelRefCustom, preserving custom properties
+     * @param model - the input to convert
+     * @returns the model reference with custom properties
+     */
+    getModelRef(model) {
+        return ((model instanceof ModelRefCustom
+            ? model
+            : new ModelRefCustom(this.repo.getPrimaryKey(model), this.repo, model)));
+    }
+    /**
+     * Mark the parent model's property for this collection as dirty
+     */
+    setDirty() {
+        // no-op: dirty tracking is handled by the deep proxy in track()
+    }
+}
+/**
+ * Define a ModelRef with custom properties for map
+ * Exclude the PrimaryKey from the JSON
+ *
+ * @deprecated
+ */
+export class ModelRefCustomMap extends ModelRefCustom {
+    /**
+     * Serialize the relation data as a plain object (excluding the primary key).
+     * @returns the relation data
+     */
+    toJSON() {
+        return this[RelationData] || {};
+    }
+}
+/**
+ * Define a junction link between two models in a n:m relation
+ *
+ * This is used to define the junction model in a n:m relation with additional data
+ * It does not require to have a symetric relation on the other side
+ */
+export class JunctionLink {
+    constructor() {
+        this[_d] = ["linkA", "linkB"];
+    }
+    static { _d = WEBDA_PRIMARY_KEY; }
+    /**
+     * Return the composite primary key (linkA + linkB)
+     * @returns the composite primary key object
+     */
+    getPrimaryKey() {
+        return { linkA: this.linkA.getPrimaryKey(), linkB: this.linkB.getPrimaryKey() };
+    }
+    /** @override */
+    load(params) {
+        return this;
+    }
+    /**
+     * Return a string UID combining both link keys
+     * @returns the combined UID string
+     */
+    getUUID() {
+        return `${this.linkA.getPrimaryKey()}_${this.linkB.getPrimaryKey()}`;
+    }
+    /**
+     * Return the proxied version of this model (identity for JunctionLink)
+     * @returns this instance
+     */
+    toProxy() {
+        return this;
+    }
+}
+//# sourceMappingURL=relations.js.map