@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/FabricConstruction.js

@@ -0,0 +1,433 @@
+import { cacheModelForPopulate, Cascade, createOrUpdate, getPopulateKey, Repository, repositoryFromTypeMetadata, } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { findPrimaryKey, InternalError, } from "@decaf-ts/db-decorators";
+/**
+ * @description Handles one-to-one relationship creation
+ * @summary Processes a one-to-one relationship when creating a model, either by referencing an existing model or creating a new one
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param {string} key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnCreate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnCreate
+ *   participant repositoryFromTypeMetadata
+ *   participant Model
+ *   participant Repository
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnCreate: this, context, data, key, model
+ *   oneToOneOnCreate->>oneToOneOnCreate: check if propertyValue exists
+ *
+ *   alt propertyValue is not an object
+ *     oneToOneOnCreate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToOneOnCreate: innerRepo
+ *     oneToOneOnCreate->>innerRepo: read(propertyValue)
+ *     innerRepo-->>oneToOneOnCreate: read
+ *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, propertyValue, read
+ *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = propertyValue
+ *   else propertyValue is an object
+ *     oneToOneOnCreate->>Model: get(data.class)
+ *     Model-->>oneToOneOnCreate: constructor
+ *     oneToOneOnCreate->>Repository: forModel(constructor)
+ *     Repository-->>oneToOneOnCreate: repo
+ *     oneToOneOnCreate->>repo: create(propertyValue)
+ *     repo-->>oneToOneOnCreate: created
+ *     oneToOneOnCreate->>findPrimaryKey: created
+ *     findPrimaryKey-->>oneToOneOnCreate: pk
+ *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, created[pk], created
+ *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = created[pk]
+ *   end
+ *
+ *   oneToOneOnCreate-->>Caller: void
+ */
+export async function oneToOneOnCreate(context, data, key, model) {
+    const propertyValue = model[key];
+    if (!propertyValue)
+        return;
+    if (typeof propertyValue !== "object") {
+        const innerRepo = repositoryFromTypeMetadata(model, key, this.adapter.alias);
+        const read = await innerRepo.read(propertyValue, context);
+        await cacheModelForPopulate(context, model, key, propertyValue, read);
+        model[key] = propertyValue;
+        return;
+    }
+    data.class =
+        typeof data.class === "string" ? data.class : data.class().name;
+    const constructor = Model.get(data.class);
+    if (!constructor)
+        throw new InternalError(`Could not find model ${data.class}`);
+    const repo = Repository.forModel(constructor, this.adapter.alias);
+    const created = await repo.create(propertyValue, context);
+    const pk = findPrimaryKey(created).id;
+    await cacheModelForPopulate(context, model, key, created[pk], created);
+    model[key] = created[pk];
+}
+/**
+ * @description Handles one-to-one relationship updates
+ * @summary Processes a one-to-one relationship when updating a model, either by referencing an existing model or updating the related model
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnUpdate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnUpdate
+ *   participant repositoryFromTypeMetadata
+ *   participant createOrUpdate
+ *   participant findPrimaryKey
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnUpdate: this, context, data, key, model
+ *   oneToOneOnUpdate->>oneToOneOnUpdate: check if propertyValue exists
+ *   oneToOneOnUpdate->>oneToOneOnUpdate: check if cascade.update is CASCADE
+ *
+ *   alt propertyValue is not an object
+ *     oneToOneOnUpdate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToOneOnUpdate: innerRepo
+ *     oneToOneOnUpdate->>innerRepo: read(propertyValue)
+ *     innerRepo-->>oneToOneOnUpdate: read
+ *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, propertyValue, read
+ *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = propertyValue
+ *   else propertyValue is an object
+ *     oneToOneOnUpdate->>createOrUpdate: model[key], context
+ *     createOrUpdate-->>oneToOneOnUpdate: updated
+ *     oneToOneOnUpdate->>findPrimaryKey: updated
+ *     findPrimaryKey-->>oneToOneOnUpdate: pk
+ *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, updated[pk], updated
+ *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = updated[pk]
+ *   end
+ *
+ *   oneToOneOnUpdate-->>Caller: void
+ */
+export async function oneToOneOnUpdate(context, data, key, model) {
+    const propertyValue = model[key];
+    if (!propertyValue)
+        return;
+    if (data.cascade.update !== Cascade.CASCADE)
+        return;
+    if (typeof propertyValue !== "object") {
+        const innerRepo = repositoryFromTypeMetadata(model, key, this.adapter.alias);
+        const read = await innerRepo.read(propertyValue, context);
+        await cacheModelForPopulate(context, model, key, propertyValue, read);
+        model[key] = propertyValue;
+        return;
+    }
+    const updated = await createOrUpdate(model[key], context, this.adapter.alias);
+    const pk = findPrimaryKey(updated).id;
+    await cacheModelForPopulate(context, model, key, updated[pk], updated);
+    model[key] = updated[pk];
+}
+/**
+ * @description Handles one-to-one relationship deletion
+ * @summary Processes a one-to-one relationship when deleting a model, deleting the related model if cascade is enabled
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnDelete
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnDelete
+ *   participant repositoryFromTypeMetadata
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnDelete: this, context, data, key, model
+ *   oneToOneOnDelete->>oneToOneOnDelete: check if propertyValue exists
+ *   oneToOneOnDelete->>oneToOneOnDelete: check if cascade.update is CASCADE
+ *
+ *   oneToOneOnDelete->>repositoryFromTypeMetadata: model, key
+ *   repositoryFromTypeMetadata-->>oneToOneOnDelete: innerRepo
+ *
+ *   alt propertyValue is not a Model instance
+ *     oneToOneOnDelete->>innerRepo: delete(model[key], context)
+ *     innerRepo-->>oneToOneOnDelete: deleted
+ *   else propertyValue is a Model instance
+ *     oneToOneOnDelete->>innerRepo: delete(model[key][innerRepo.pk], context)
+ *     innerRepo-->>oneToOneOnDelete: deleted
+ *   end
+ *
+ *   oneToOneOnDelete->>cacheModelForPopulate: context, model, key, deleted[innerRepo.pk], deleted
+ *   oneToOneOnDelete-->>Caller: void
+ */
+export async function oneToOneOnDelete(context, data, key, model) {
+    const propertyValue = model[key];
+    if (!propertyValue)
+        return;
+    if (data.cascade.update !== Cascade.CASCADE)
+        return;
+    const innerRepo = repositoryFromTypeMetadata(model, key, this.adapter.alias);
+    let deleted;
+    if (!(propertyValue instanceof Model))
+        deleted = await innerRepo.delete(model[key], context);
+    else
+        deleted = await innerRepo.delete(model[key][innerRepo.pk], context);
+    await cacheModelForPopulate(context, model, key, deleted[innerRepo.pk], deleted);
+}
+/**
+ * @description Handles one-to-many relationship creation
+ * @summary Processes a one-to-many relationship when creating a model, either by referencing existing models or creating new ones
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToManyOnCreate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToManyOnCreate
+ *   participant repositoryFromTypeMetadata
+ *   participant createOrUpdate
+ *   participant findPrimaryKey
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToManyOnCreate: this, context, data, key, model
+ *   oneToManyOnCreate->>oneToManyOnCreate: check if propertyValues exists and has length
+ *   oneToManyOnCreate->>oneToManyOnCreate: check if all elements have same type
+ *   oneToManyOnCreate->>oneToManyOnCreate: create uniqueValues set
+ *
+ *   alt arrayType is not "object"
+ *     oneToManyOnCreate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToManyOnCreate: repo
+ *     loop for each id in uniqueValues
+ *       oneToManyOnCreate->>repo: read(id)
+ *       repo-->>oneToManyOnCreate: read
+ *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, id, read
+ *     end
+ *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...uniqueValues]
+ *   else arrayType is "object"
+ *     oneToManyOnCreate->>findPrimaryKey: propertyValues[0]
+ *     findPrimaryKey-->>oneToManyOnCreate: pkName
+ *     oneToManyOnCreate->>oneToManyOnCreate: create result set
+ *     loop for each m in propertyValues
+ *       oneToManyOnCreate->>createOrUpdate: m, context
+ *       createOrUpdate-->>oneToManyOnCreate: record
+ *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, record[pkName], record
+ *       oneToManyOnCreate->>oneToManyOnCreate: add record[pkName] to result
+ *     end
+ *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...result]
+ *   end
+ *
+ *   oneToManyOnCreate-->>Caller: void
+ */
+export async function oneToManyOnCreate(context, data, key, model) {
+    const propertyValues = model[key];
+    if (!propertyValues || !propertyValues.length)
+        return;
+    const arrayType = typeof propertyValues[0];
+    if (!propertyValues.every((item) => typeof item === arrayType))
+        throw new InternalError(`Invalid operation. All elements of property ${key} must match the same type.`);
+    const uniqueValues = new Set([...propertyValues]);
+    if (arrayType !== "object") {
+        const repo = repositoryFromTypeMetadata(model, key, this.adapter.alias);
+        for (const id of uniqueValues) {
+            const read = await repo.read(id, context);
+            await cacheModelForPopulate(context, model, key, id, read);
+        }
+        model[key] = [...uniqueValues];
+        return;
+    }
+    const pkName = findPrimaryKey(propertyValues[0]).id;
+    const result = new Set();
+    for (const m of propertyValues) {
+        const record = await createOrUpdate(m, context, this.adapter.alias);
+        await cacheModelForPopulate(context, model, key, record[pkName], record);
+        result.add(record[pkName]);
+    }
+    model[key] = [...result];
+}
+/**
+ * @description Handles one-to-many relationship deletion
+ * @summary Processes a one-to-many relationship when deleting a model, deleting all related models if cascade delete is enabled
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToManyOnDelete
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToManyOnDelete
+ *   participant Repository
+ *   participant repositoryFromTypeMetadata
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToManyOnDelete: this, context, data, key, model
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if cascade.delete is CASCADE
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if values exists and has length
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if all elements have same type
+ *
+ *   alt isInstantiated (arrayType is "object")
+ *     oneToManyOnDelete->>Repository: forModel(values[0])
+ *     Repository-->>oneToManyOnDelete: repo
+ *   else not instantiated
+ *     oneToManyOnDelete->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToManyOnDelete: repo
+ *   end
+ *
+ *   oneToManyOnDelete->>oneToManyOnDelete: create uniqueValues set
+ *
+ *   loop for each id in uniqueValues
+ *     oneToManyOnDelete->>repo: delete(id, context)
+ *     repo-->>oneToManyOnDelete: deleted
+ *     oneToManyOnDelete->>cacheModelForPopulate: context, model, key, id, deleted
+ *   end
+ *
+ *   oneToManyOnDelete->>oneToManyOnDelete: set model[key] = [...uniqueValues]
+ *   oneToManyOnDelete-->>Caller: void
+ */
+export async function oneToManyOnDelete(context, data, key, model) {
+    if (data.cascade.delete !== Cascade.CASCADE)
+        return;
+    const values = model[key];
+    if (!values || !values.length)
+        return;
+    const arrayType = typeof values[0];
+    const areAllSameType = values.every((item) => typeof item === arrayType);
+    if (!areAllSameType)
+        throw new InternalError(`Invalid operation. All elements of property ${key} must match the same type.`);
+    const isInstantiated = arrayType === "object";
+    const repo = isInstantiated
+        ? Repository.forModel(values[0], this.adapter.alias)
+        : repositoryFromTypeMetadata(model, key, this.adapter.alias);
+    const uniqueValues = new Set([
+        ...(isInstantiated
+            ? values.map((v) => v[repo.pk])
+            : values),
+    ]);
+    for (const id of uniqueValues.values()) {
+        const deleted = await repo.delete(id, context);
+        await cacheModelForPopulate(context, model, key, id, deleted);
+    }
+    model[key] = [...uniqueValues];
+}
+/**
+ * @description Populates a model's relationship
+ * @summary Retrieves and attaches related models to a model's relationship property
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function populate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant populate
+ *   participant fetchPopulateValues
+ *   participant getPopulateKey
+ *   participant Context
+ *   participant repositoryFromTypeMetadata
+ *
+ *   Caller->>populate: this, context, data, key, model
+ *   populate->>populate: check if data.populate is true
+ *   populate->>populate: get nested value and check if it exists
+ *
+ *   populate->>fetchPopulateValues: context, model, key, isArr ? nested : [nested]
+ *
+ *   fetchPopulateValues->>fetchPopulateValues: initialize variables
+ *
+ *   loop for each proKeyValue in propKeyValues
+ *     fetchPopulateValues->>getPopulateKey: model.constructor.name, propName, proKeyValue
+ *     getPopulateKey-->>fetchPopulateValues: cacheKey
+ *
+ *     alt try to get from cache
+ *       fetchPopulateValues->>Context: get(cacheKey)
+ *       Context-->>fetchPopulateValues: val
+ *     else catch error
+ *       fetchPopulateValues->>repositoryFromTypeMetadata: model, propName
+ *       repositoryFromTypeMetadata-->>fetchPopulateValues: repo
+ *       fetchPopulateValues->>repo: read(proKeyValue)
+ *       repo-->>fetchPopulateValues: val
+ *     end
+ *
+ *     fetchPopulateValues->>fetchPopulateValues: add val to results
+ *   end
+ *
+ *   fetchPopulateValues-->>populate: results
+ *   populate->>populate: set model[key] = isArr ? res : res[0]
+ *   populate-->>Caller: void
+ */
+export async function populate(context, data, key, model) {
+    if (!data.populate)
+        return;
+    const nested = model[key];
+    const isArr = Array.isArray(nested);
+    if (typeof nested === "undefined" || (isArr && nested.length === 0))
+        return;
+    async function fetchPopulateValues(c, model, propName, propKeyValues, alias) {
+        let cacheKey;
+        let val;
+        const results = [];
+        for (const proKeyValue of propKeyValues) {
+            cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);
+            try {
+                val = await c.get(cacheKey);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                const repo = repositoryFromTypeMetadata(model, propName, alias);
+                if (!repo)
+                    throw new InternalError("Could not find repo");
+                val = await repo.read(proKeyValue, context);
+            }
+            results.push(val);
+        }
+        return results;
+    }
+    const res = await fetchPopulateValues(context, model, key, isArr ? nested : [nested], this.adapter.alias);
+    model[key] = isArr ? res : res[0];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricConstruction.js","sourceRoot":"","sources":["../../../src/contracts/FabricConstruction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,OAAO,EACP,cAAc,EACd,cAAc,EAGd,UAAU,EACV,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AAEvD,OAAO,EAEL,cAAc,EACd,aAAa,GACd,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAQpC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,MAAM,aAAa,GAAQ,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,CAAC,aAAa;QAAE,OAAO;IAE3B,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;QACtC,MAAM,SAAS,GAAG,0BAA0B,CAC1C,KAAK,EACL,GAAG,EACH,IAAI,CAAC,OAAO,CAAC,KAAK,CACnB,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QAC1D,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QACrE,KAAa,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC;QACpC,OAAO;IACT,CAAC;IAED,IAAI,CAAC,KAAK;QACR,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE,IAAI,CAAC,KAAa,EAAE,CAAC,IAAI,CAAC;IAE3E,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAe,CAAC,CAAC;IACpD,IAAI,CAAC,WAAW;QACd,MAAM,IAAI,aAAa,CAAC,wBAAwB,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAChE,MAAM,IAAI,GAAc,UAAU,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7E,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC1D,MAAM,EAAE,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACtC,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;IACtE,KAAa,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAQpC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,MAAM,aAAa,GAAQ,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,CAAC,aAAa;QAAE,OAAO;IAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,OAAO;QAAE,OAAO;IAEpD,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;QACtC,MAAM,SAAS,GAAG,0BAA0B,CAC1C,KAAK,EACL,GAAG,EACH,IAAI,CAAC,OAAO,CAAC,KAAK,CACnB,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QAC1D,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QACrE,KAAa,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC;QACpC,OAAO;IACT,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,cAAc,CAClC,KAAK,CAAC,GAAG,CAAM,EACf,OAAO,EACP,IAAI,CAAC,OAAO,CAAC,KAAK,CACnB,CAAC;IACF,MAAM,EAAE,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACtC,MAAM,qBAAqB,CACzB,OAAO,EACP,KAAK,EACL,GAAG,EACH,OAAO,CAAC,EAAE,CAAW,EACrB,OAAO,CACR,CAAC;IACF,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAQpC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,MAAM,aAAa,GAAQ,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,CAAC,aAAa;QAAE,OAAO;IAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,OAAO;QAAE,OAAO;IACpD,MAAM,SAAS,GAAY,0BAA0B,CACnD,KAAK,EACL,GAAG,EACH,IAAI,CAAC,OAAO,CAAC,KAAK,CACnB,CAAC;IACF,IAAI,OAAU,CAAC;IACf,IAAI,CAAC,CAAC,aAAa,YAAY,KAAK,CAAC;QACnC,OAAO,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAW,EAAE,OAAO,CAAC,CAAC;;QAEhE,OAAO,GAAG,MAAM,SAAS,CAAC,MAAM,CAC7B,KAAK,CAAC,GAAG,CAAO,CAAC,SAAS,CAAC,EAAa,CAAW,EACpD,OAAO,CACR,CAAC;IACJ,MAAM,qBAAqB,CACzB,OAAO,EACP,KAAK,EACL,GAAG,EACH,OAAO,CAAC,SAAS,CAAC,EAAE,CAAW,EAC/B,OAAO,CACR,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAQrC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,MAAM,cAAc,GAAQ,KAAK,CAAC,GAAG,CAAC,CAAC;IACvC,IAAI,CAAC,cAAc,IAAI,CAAC,cAAc,CAAC,MAAM;QAAE,OAAO;IACtD,MAAM,SAAS,GAAG,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,SAAS,CAAC;QACjE,MAAM,IAAI,aAAa,CACrB,+CAA+C,GAAa,4BAA4B,CACzF,CAAC;IACJ,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAClD,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,0BAA0B,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACxE,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;YAC1C,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;QAC7D,CAAC;QACA,KAAa,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;QACxC,OAAO;IACT,CAAC;IAED,MAAM,MAAM,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEpD,MAAM,MAAM,GAAgB,IAAI,GAAG,EAAE,CAAC;IAEtC,KAAK,MAAM,CAAC,IAAI,cAAc,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpE,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;QACzE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7B,CAAC;IAEA,KAAa,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAQrC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,OAAO;QAAE,OAAO;IACpD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAQ,CAAC;IACjC,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO;IACtC,MAAM,SAAS,GAAG,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC;IAC9E,IAAI,CAAC,cAAc;QACjB,MAAM,IAAI,aAAa,CACrB,+CAA+C,GAAa,4BAA4B,CACzF,CAAC;IACJ,MAAM,cAAc,GAAG,SAAS,KAAK,QAAQ,CAAC;IAC9C,MAAM,IAAI,GAAG,cAAc;QACzB,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACpD,CAAC,CAAC,0BAA0B,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAE/D,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC;QAC3B,GAAG,CAAC,cAAc;YAChB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAsB,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAY,CAAC,CAAC;YAC9D,CAAC,CAAC,MAAM,CAAC;KACZ,CAAC,CAAC;IAEH,KAAK,MAAM,EAAE,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC/C,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IACA,KAAa,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAQ5B,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,QAAQ;QAAE,OAAO;IAC3B,MAAM,MAAM,GAAQ,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;QAAE,OAAO;IAE5E,KAAK,UAAU,mBAAmB,CAChC,CAAa,EACb,KAAQ,EACR,QAAgB,EAChB,aAAoB,EACpB,KAAc;QAEd,IAAI,QAAgB,CAAC;QACrB,IAAI,GAAQ,CAAC;QACb,MAAM,OAAO,GAAQ,EAAE,CAAC;QACxB,KAAK,MAAM,WAAW,IAAI,aAAa,EAAE,CAAC;YACxC,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;YACzE,IAAI,CAAC;gBACH,GAAG,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,QAAe,CAAC,CAAC;gBACnC,6DAA6D;YAC/D,CAAC;YAAC,OAAO,CAAM,EAAE,CAAC;gBAChB,MAAM,IAAI,GAAG,0BAA0B,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;gBAChE,IAAI,CAAC,IAAI;oBAAE,MAAM,IAAI,aAAa,CAAC,qBAAqB,CAAC,CAAC;gBAC1D,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAC9C,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,mBAAmB,CACnC,OAAO,EACP,KAAK,EACL,GAAa,EACb,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EACzB,IAAI,CAAC,OAAO,CAAC,KAAK,CACnB,CAAC;IACD,KAAa,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import {\n  cacheModelForPopulate,\n  Cascade,\n  createOrUpdate,\n  getPopulateKey,\n  RelationsMetadata,\n  Repo,\n  Repository,\n  repositoryFromTypeMetadata,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { FabricContractFlags } from \"./types\";\nimport {\n  Context,\n  findPrimaryKey,\n  InternalError,\n} from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Handles one-to-one relationship creation\n * @summary Processes a one-to-one relationship when creating a model, either by referencing an existing model or creating a new one\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param {string} key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnCreate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnCreate\n *   participant repositoryFromTypeMetadata\n *   participant Model\n *   participant Repository\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnCreate: this, context, data, key, model\n *   oneToOneOnCreate->>oneToOneOnCreate: check if propertyValue exists\n *\n *   alt propertyValue is not an object\n *     oneToOneOnCreate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToOneOnCreate: innerRepo\n *     oneToOneOnCreate->>innerRepo: read(propertyValue)\n *     innerRepo-->>oneToOneOnCreate: read\n *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, propertyValue, read\n *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = propertyValue\n *   else propertyValue is an object\n *     oneToOneOnCreate->>Model: get(data.class)\n *     Model-->>oneToOneOnCreate: constructor\n *     oneToOneOnCreate->>Repository: forModel(constructor)\n *     Repository-->>oneToOneOnCreate: repo\n *     oneToOneOnCreate->>repo: create(propertyValue)\n *     repo-->>oneToOneOnCreate: created\n *     oneToOneOnCreate->>findPrimaryKey: created\n *     findPrimaryKey-->>oneToOneOnCreate: pk\n *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, created[pk], created\n *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = created[pk]\n *   end\n *\n *   oneToOneOnCreate-->>Caller: void\n */\nexport async function oneToOneOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(\n      model,\n      key,\n      this.adapter.alias\n    );\n    const read = await innerRepo.read(propertyValue, context);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  data.class =\n    typeof data.class === \"string\" ? data.class : (data.class as any)().name;\n\n  const constructor = Model.get(data.class as string);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor, this.adapter.alias);\n  const created = await repo.create(propertyValue, context);\n  const pk = findPrimaryKey(created).id;\n  await cacheModelForPopulate(context, model, key, created[pk], created);\n  (model as any)[key] = created[pk];\n}\n\n/**\n * @description Handles one-to-one relationship updates\n * @summary Processes a one-to-one relationship when updating a model, either by referencing an existing model or updating the related model\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnUpdate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnUpdate\n *   participant repositoryFromTypeMetadata\n *   participant createOrUpdate\n *   participant findPrimaryKey\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnUpdate: this, context, data, key, model\n *   oneToOneOnUpdate->>oneToOneOnUpdate: check if propertyValue exists\n *   oneToOneOnUpdate->>oneToOneOnUpdate: check if cascade.update is CASCADE\n *\n *   alt propertyValue is not an object\n *     oneToOneOnUpdate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToOneOnUpdate: innerRepo\n *     oneToOneOnUpdate->>innerRepo: read(propertyValue)\n *     innerRepo-->>oneToOneOnUpdate: read\n *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, propertyValue, read\n *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = propertyValue\n *   else propertyValue is an object\n *     oneToOneOnUpdate->>createOrUpdate: model[key], context\n *     createOrUpdate-->>oneToOneOnUpdate: updated\n *     oneToOneOnUpdate->>findPrimaryKey: updated\n *     findPrimaryKey-->>oneToOneOnUpdate: pk\n *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, updated[pk], updated\n *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = updated[pk]\n *   end\n *\n *   oneToOneOnUpdate-->>Caller: void\n */\nexport async function oneToOneOnUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(\n      model,\n      key,\n      this.adapter.alias\n    );\n    const read = await innerRepo.read(propertyValue, context);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  const updated = await createOrUpdate(\n    model[key] as M,\n    context,\n    this.adapter.alias\n  );\n  const pk = findPrimaryKey(updated).id;\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    updated[pk] as string,\n    updated\n  );\n  model[key] = updated[pk];\n}\n\n/**\n * @description Handles one-to-one relationship deletion\n * @summary Processes a one-to-one relationship when deleting a model, deleting the related model if cascade is enabled\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnDelete\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnDelete\n *   participant repositoryFromTypeMetadata\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnDelete: this, context, data, key, model\n *   oneToOneOnDelete->>oneToOneOnDelete: check if propertyValue exists\n *   oneToOneOnDelete->>oneToOneOnDelete: check if cascade.update is CASCADE\n *\n *   oneToOneOnDelete->>repositoryFromTypeMetadata: model, key\n *   repositoryFromTypeMetadata-->>oneToOneOnDelete: innerRepo\n *\n *   alt propertyValue is not a Model instance\n *     oneToOneOnDelete->>innerRepo: delete(model[key], context)\n *     innerRepo-->>oneToOneOnDelete: deleted\n *   else propertyValue is a Model instance\n *     oneToOneOnDelete->>innerRepo: delete(model[key][innerRepo.pk], context)\n *     innerRepo-->>oneToOneOnDelete: deleted\n *   end\n *\n *   oneToOneOnDelete->>cacheModelForPopulate: context, model, key, deleted[innerRepo.pk], deleted\n *   oneToOneOnDelete-->>Caller: void\n */\nexport async function oneToOneOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n  const innerRepo: Repo<M> = repositoryFromTypeMetadata(\n    model,\n    key,\n    this.adapter.alias\n  );\n  let deleted: M;\n  if (!(propertyValue instanceof Model))\n    deleted = await innerRepo.delete(model[key] as string, context);\n  else\n    deleted = await innerRepo.delete(\n      (model[key] as M)[innerRepo.pk as keyof M] as string,\n      context\n    );\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    deleted[innerRepo.pk] as string,\n    deleted\n  );\n}\n\n/**\n * @description Handles one-to-many relationship creation\n * @summary Processes a one-to-many relationship when creating a model, either by referencing existing models or creating new ones\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToManyOnCreate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToManyOnCreate\n *   participant repositoryFromTypeMetadata\n *   participant createOrUpdate\n *   participant findPrimaryKey\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToManyOnCreate: this, context, data, key, model\n *   oneToManyOnCreate->>oneToManyOnCreate: check if propertyValues exists and has length\n *   oneToManyOnCreate->>oneToManyOnCreate: check if all elements have same type\n *   oneToManyOnCreate->>oneToManyOnCreate: create uniqueValues set\n *\n *   alt arrayType is not \"object\"\n *     oneToManyOnCreate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToManyOnCreate: repo\n *     loop for each id in uniqueValues\n *       oneToManyOnCreate->>repo: read(id)\n *       repo-->>oneToManyOnCreate: read\n *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, id, read\n *     end\n *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...uniqueValues]\n *   else arrayType is \"object\"\n *     oneToManyOnCreate->>findPrimaryKey: propertyValues[0]\n *     findPrimaryKey-->>oneToManyOnCreate: pkName\n *     oneToManyOnCreate->>oneToManyOnCreate: create result set\n *     loop for each m in propertyValues\n *       oneToManyOnCreate->>createOrUpdate: m, context\n *       createOrUpdate-->>oneToManyOnCreate: record\n *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, record[pkName], record\n *       oneToManyOnCreate->>oneToManyOnCreate: add record[pkName] to result\n *     end\n *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...result]\n *   end\n *\n *   oneToManyOnCreate-->>Caller: void\n */\nexport async function oneToManyOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValues: any = model[key];\n  if (!propertyValues || !propertyValues.length) return;\n  const arrayType = typeof propertyValues[0];\n  if (!propertyValues.every((item: any) => typeof item === arrayType))\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const uniqueValues = new Set([...propertyValues]);\n  if (arrayType !== \"object\") {\n    const repo = repositoryFromTypeMetadata(model, key, this.adapter.alias);\n    for (const id of uniqueValues) {\n      const read = await repo.read(id, context);\n      await cacheModelForPopulate(context, model, key, id, read);\n    }\n    (model as any)[key] = [...uniqueValues];\n    return;\n  }\n\n  const pkName = findPrimaryKey(propertyValues[0]).id;\n\n  const result: Set<string> = new Set();\n\n  for (const m of propertyValues) {\n    const record = await createOrUpdate(m, context, this.adapter.alias);\n    await cacheModelForPopulate(context, model, key, record[pkName], record);\n    result.add(record[pkName]);\n  }\n\n  (model as any)[key] = [...result];\n}\n\n/**\n * @description Handles one-to-many relationship deletion\n * @summary Processes a one-to-many relationship when deleting a model, deleting all related models if cascade delete is enabled\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToManyOnDelete\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToManyOnDelete\n *   participant Repository\n *   participant repositoryFromTypeMetadata\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToManyOnDelete: this, context, data, key, model\n *   oneToManyOnDelete->>oneToManyOnDelete: check if cascade.delete is CASCADE\n *   oneToManyOnDelete->>oneToManyOnDelete: check if values exists and has length\n *   oneToManyOnDelete->>oneToManyOnDelete: check if all elements have same type\n *\n *   alt isInstantiated (arrayType is \"object\")\n *     oneToManyOnDelete->>Repository: forModel(values[0])\n *     Repository-->>oneToManyOnDelete: repo\n *   else not instantiated\n *     oneToManyOnDelete->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToManyOnDelete: repo\n *   end\n *\n *   oneToManyOnDelete->>oneToManyOnDelete: create uniqueValues set\n *\n *   loop for each id in uniqueValues\n *     oneToManyOnDelete->>repo: delete(id, context)\n *     repo-->>oneToManyOnDelete: deleted\n *     oneToManyOnDelete->>cacheModelForPopulate: context, model, key, id, deleted\n *   end\n *\n *   oneToManyOnDelete->>oneToManyOnDelete: set model[key] = [...uniqueValues]\n *   oneToManyOnDelete-->>Caller: void\n */\nexport async function oneToManyOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (data.cascade.delete !== Cascade.CASCADE) return;\n  const values = model[key] as any;\n  if (!values || !values.length) return;\n  const arrayType = typeof values[0];\n  const areAllSameType = values.every((item: any) => typeof item === arrayType);\n  if (!areAllSameType)\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const isInstantiated = arrayType === \"object\";\n  const repo = isInstantiated\n    ? Repository.forModel(values[0], this.adapter.alias)\n    : repositoryFromTypeMetadata(model, key, this.adapter.alias);\n\n  const uniqueValues = new Set([\n    ...(isInstantiated\n      ? values.map((v: Record<string, any>) => v[repo.pk as string])\n      : values),\n  ]);\n\n  for (const id of uniqueValues.values()) {\n    const deleted = await repo.delete(id, context);\n    await cacheModelForPopulate(context, model, key, id, deleted);\n  }\n  (model as any)[key] = [...uniqueValues];\n}\n\n/**\n * @description Populates a model's relationship\n * @summary Retrieves and attaches related models to a model's relationship property\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function populate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant populate\n *   participant fetchPopulateValues\n *   participant getPopulateKey\n *   participant Context\n *   participant repositoryFromTypeMetadata\n *\n *   Caller->>populate: this, context, data, key, model\n *   populate->>populate: check if data.populate is true\n *   populate->>populate: get nested value and check if it exists\n *\n *   populate->>fetchPopulateValues: context, model, key, isArr ? nested : [nested]\n *\n *   fetchPopulateValues->>fetchPopulateValues: initialize variables\n *\n *   loop for each proKeyValue in propKeyValues\n *     fetchPopulateValues->>getPopulateKey: model.constructor.name, propName, proKeyValue\n *     getPopulateKey-->>fetchPopulateValues: cacheKey\n *\n *     alt try to get from cache\n *       fetchPopulateValues->>Context: get(cacheKey)\n *       Context-->>fetchPopulateValues: val\n *     else catch error\n *       fetchPopulateValues->>repositoryFromTypeMetadata: model, propName\n *       repositoryFromTypeMetadata-->>fetchPopulateValues: repo\n *       fetchPopulateValues->>repo: read(proKeyValue)\n *       repo-->>fetchPopulateValues: val\n *     end\n *\n *     fetchPopulateValues->>fetchPopulateValues: add val to results\n *   end\n *\n *   fetchPopulateValues-->>populate: results\n *   populate->>populate: set model[key] = isArr ? res : res[0]\n *   populate-->>Caller: void\n */\nexport async function populate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends FabricContractFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.populate) return;\n  const nested: any = model[key];\n  const isArr = Array.isArray(nested);\n  if (typeof nested === \"undefined\" || (isArr && nested.length === 0)) return;\n\n  async function fetchPopulateValues(\n    c: Context<F>,\n    model: M,\n    propName: string,\n    propKeyValues: any[],\n    alias?: string\n  ) {\n    let cacheKey: string;\n    let val: any;\n    const results: M[] = [];\n    for (const proKeyValue of propKeyValues) {\n      cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);\n      try {\n        val = await c.get(cacheKey as any);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        const repo = repositoryFromTypeMetadata(model, propName, alias);\n        if (!repo) throw new InternalError(\"Could not find repo\");\n        val = await repo.read(proKeyValue, context);\n      }\n      results.push(val);\n    }\n    return results;\n  }\n  const res = await fetchPopulateValues(\n    context,\n    model,\n    key as string,\n    isArr ? nested : [nested],\n    this.adapter.alias\n  );\n  (model as any)[key] = isArr ? res : res[0];\n}\n"]}