vsrepo 1.2.6 → 1.2.7

package/dist/internal/resolvers/base-methods.resolve.js

@@ -0,0 +1,535 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBaseMethods = resolveBaseMethods;
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+const logger_util_1 = require("../utils/logger.util");
+const is_object_validate_1 = require("../validation/is-object.validate");
+const method_options_validate_1 = require("../validation/method-options.validate");
+const obj_with_relations_validate_1 = require("../validation/obj-with-relations.validate");
+const create_update_payloads_with_relations_resolve_1 = require("./create-update-payloads-with-relations.resolve");
+const data_payload_with_relations_resolve_1 = require("./data-payload-with-relations.resolve");
+const dbAndPrismaArgs_resolve_1 = require("./dbAndPrismaArgs.resolve");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+function resolveBaseMethods(instance, config) {
+    const { baseMethods, showWorking } = config;
+    const { tableName, pkName, relations, softRemovekName } = instance;
+    const relationsKeys = relations ? Object.keys(relations) : [];
+    // * GET
+    if (baseMethods.get.active) {
+        instance.get = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.get,
+                options,
+                wherePkValue: pk,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "get", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findUnique(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "get", start);
+            return result;
+        };
+    }
+    // * GET OR THROW
+    if (baseMethods.getOrThrow.active) {
+        instance.getOrThrow = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.getOrThrow,
+                options,
+                wherePkValue: pk,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "getOrThrow", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findUnique(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "getOrThrow", start);
+            if (!result) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) No record was found for the provided primary key.`, "20727");
+            }
+            return result;
+        };
+    }
+    // * GET LIST
+    if (baseMethods.getList.active) {
+        instance.getList = async (pks, options) => {
+            if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.getList,
+                options,
+                wherePkValue: { in: pks },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "getList", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findMany(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "getList", start);
+            return result;
+        };
+    }
+    // * GET ALL
+    if (baseMethods.getAll.active) {
+        instance.getAll = async (options) => {
+            if (options !== undefined && !(0, is_object_validate_1.isObject)(options))
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'options' must be a valid object.`);
+            const { pagination, order, ...restOptions } = options ?? {};
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.getAll,
+                options: restOptions,
+                pagination,
+                ordenation: order,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "getAll", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findMany(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "getAll", start);
+            return result;
+        };
+    }
+    // * REMOVE
+    if (baseMethods.remove.active) {
+        instance.remove = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.remove,
+                options,
+                wherePkValue: pk,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "remove", prismaArgs)
+                : undefined;
+            const result = await db[tableName].delete(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "remove", start);
+            return result;
+        };
+    }
+    // * REMOVE LIST
+    if (baseMethods.removeList.active) {
+        instance.removeList = async (pks, options) => {
+            if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.removeList,
+                options,
+                wherePkValue: { in: pks },
+                withoutSelect: true,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "removeList", prismaArgs)
+                : undefined;
+            const result = await db[tableName].deleteMany(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "removeList", start);
+            return result;
+        };
+    }
+    // * TOTAL
+    if (baseMethods.total.active) {
+        instance.total = async (options) => {
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.total,
+                options,
+                withoutSelect: true,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "total", prismaArgs)
+                : undefined;
+            const result = await db[tableName].count(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "total", start);
+            return result;
+        };
+    }
+    // * HAS
+    if (baseMethods.has.active) {
+        instance.has = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.has,
+                options,
+                wherePkValue: pk,
+                specificSelect: { [pkName]: true },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "has", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findUnique(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "has", start);
+            return !!result;
+        };
+    }
+    // * MERGE
+    if (baseMethods.merge.active) {
+        instance.merge = async (pk, obj, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            if (!(0, is_object_validate_1.isObject)(obj)) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+            }
+            (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.merge,
+                options,
+                wherePkValue: pk,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "merge", prismaArgs)
+                : undefined;
+            const result = await db[tableName].findUnique(prismaArgs);
+            if (!result) {
+                if (showWorking)
+                    (0, logger_util_1.performanceLoggerEnd)(tableName, "merge", start);
+                return null;
+            }
+            if (!relations) {
+                if (showWorking)
+                    (0, logger_util_1.performanceLoggerEnd)(tableName, "merge", start);
+                return (0, deepmerge_1.default)(result, obj, {
+                    arrayMerge: (target, source) => target.concat(source),
+                });
+            }
+            const objKeys = Object.keys(obj);
+            const objAny = obj;
+            for (let i = 0; i < objKeys.length; i++) {
+                const key = objKeys[i];
+                if (!relationsKeys.includes(key)) {
+                    result[key] = objAny[key];
+                    continue;
+                }
+                const relation = relations[key];
+                if ((relation.mode === "oto" || relation.mode === "mto") && (0, is_object_validate_1.isObject)(result[key])) {
+                    result[key] = objAny[key] === null ? null : (0, deepmerge_1.default)(result[key], objAny[key]);
+                    continue;
+                }
+                else if ((relation.mode === "mtm" || relation.mode === "otm") &&
+                    Array.isArray(result[key])) {
+                    const targetArray = result[key];
+                    const sourceArray = objAny[key];
+                    const relationPk = relation.pk;
+                    const targetMap = new Map();
+                    const targetWithoutPk = [];
+                    const sourceWithoutPk = [];
+                    for (let i = 0; i < targetArray.length; i++) {
+                        const item = targetArray[i];
+                        if (item[relationPk] !== undefined) {
+                            targetMap.set(item[relationPk], item);
+                        }
+                        else {
+                            targetWithoutPk.push(item);
+                        }
+                    }
+                    for (let i = 0; i < sourceArray.length; i++) {
+                        const sourceItem = sourceArray[i];
+                        if (sourceItem[relationPk] !== undefined) {
+                            const targetItem = targetMap.get(sourceItem[relationPk]);
+                            if (targetItem) {
+                                targetMap.set(sourceItem[relationPk], (0, deepmerge_1.default)(targetItem, sourceItem));
+                            }
+                            else {
+                                targetMap.set(sourceItem[relationPk], sourceItem);
+                            }
+                        }
+                        else {
+                            sourceWithoutPk.push(sourceItem);
+                        }
+                    }
+                    result[key] = [...targetMap.values(), ...targetWithoutPk, ...sourceWithoutPk];
+                    continue;
+                }
+                result[key] = objAny[key];
+            }
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "merge", start);
+            return result;
+        };
+    }
+    // * SOFT REMOVE
+    if (baseMethods.softRemove.active && softRemovekName) {
+        instance.softRemove = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.softRemove,
+                options,
+                wherePkValue: pk,
+                forceSeeMode: "all",
+                dataPayload: { [softRemovekName]: new Date() },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "softRemove", prismaArgs)
+                : undefined;
+            const result = await db[tableName].update(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "softRemove", start);
+            return result;
+        };
+    }
+    // * SOFT REMOVE LIST
+    if (baseMethods.softRemoveList.active && softRemovekName) {
+        instance.softRemoveList = async (pks, options) => {
+            if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.softRemoveList,
+                options,
+                wherePkValue: { in: pks },
+                withoutSelect: true,
+                forceSeeMode: "all",
+                dataPayload: { [softRemovekName]: new Date() },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "softRemoveList", prismaArgs)
+                : undefined;
+            const result = await db[tableName].updateMany(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "softRemoveList", start);
+            return result;
+        };
+    }
+    // * RESTORE
+    if (baseMethods.restore.active && softRemovekName) {
+        instance.restore = async (pk, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.restore,
+                options,
+                wherePkValue: pk,
+                forceSeeMode: "all",
+                dataPayload: { [softRemovekName]: null },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "restore", prismaArgs)
+                : undefined;
+            const result = await db[tableName].update(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "restore", start);
+            return result;
+        };
+    }
+    // * RESTORE LIST
+    if (baseMethods.restoreList.active && softRemovekName) {
+        instance.restoreList = async (pks, options) => {
+            if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.restoreList,
+                options,
+                withoutSelect: true,
+                wherePkValue: { in: pks },
+                forceSeeMode: "all",
+                dataPayload: { [softRemovekName]: null },
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "restoreList", prismaArgs)
+                : undefined;
+            const result = await db[tableName].updateMany(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "restoreList", start);
+            return result;
+        };
+    }
+    // * SAVE
+    if (baseMethods.save.active) {
+        instance.save = async (obj, options) => {
+            if (!(0, is_object_validate_1.isObject)(obj)) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+            }
+            (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
+            const objAny = obj;
+            if (objAny[pkName] === undefined) {
+                const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                    instance,
+                    baseConfig: baseMethods.save,
+                    options,
+                    withoutWhere: true,
+                    dataPayload: (0, data_payload_with_relations_resolve_1.resolveDataPayloadWithRelations)(instance, objAny, relationsKeys),
+                });
+                const start = showWorking
+                    ? (0, logger_util_1.performanceLoggerStart)(tableName, "save", prismaArgs)
+                    : undefined;
+                const result = await db[tableName].create(prismaArgs);
+                if (showWorking)
+                    (0, logger_util_1.performanceLoggerEnd)(tableName, "save", start);
+                return result;
+            }
+            else {
+                const { createPayload, updatePayload } = (0, create_update_payloads_with_relations_resolve_1.resolveCreateUpdatePayloadsWithRelations)(instance, obj, relationsKeys);
+                const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                    instance,
+                    baseConfig: baseMethods.save,
+                    options,
+                    wherePkValue: objAny[pkName],
+                    createPayload,
+                    updatePayload,
+                });
+                const start = showWorking
+                    ? (0, logger_util_1.performanceLoggerStart)(tableName, "save", prismaArgs)
+                    : undefined;
+                const result = await db[tableName].upsert(prismaArgs);
+                if (showWorking)
+                    (0, logger_util_1.performanceLoggerEnd)(tableName, "save", start);
+                return result;
+            }
+        };
+    }
+    // * SAVE LIST
+    if (baseMethods.saveList.active) {
+        instance.saveList = async (objs, options) => {
+            if (!Array.isArray(objs) || objs.some(ob => !(0, is_object_validate_1.isObject)(ob))) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'objs' must be an array of valid objects.`);
+            }
+            const validatedOptions = (0, method_options_validate_1.validateMethodOptions)(options, instance);
+            const argsList = [];
+            const queries = objs.map(obj => {
+                (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
+                const objAny = obj;
+                if (objAny[pkName] === undefined) {
+                    const { prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                        instance,
+                        baseConfig: baseMethods.saveList,
+                        options: validatedOptions,
+                        alreadyValidatedOptions: true,
+                        withoutWhere: true,
+                        dataPayload: (0, data_payload_with_relations_resolve_1.resolveDataPayloadWithRelations)(instance, objAny, relationsKeys),
+                    });
+                    argsList.push(prismaArgs);
+                    return (db) => db[tableName].create(prismaArgs);
+                }
+                else {
+                    const { createPayload, updatePayload } = (0, create_update_payloads_with_relations_resolve_1.resolveCreateUpdatePayloadsWithRelations)(instance, obj, relationsKeys);
+                    const { prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                        instance,
+                        baseConfig: baseMethods.saveList,
+                        options: validatedOptions,
+                        alreadyValidatedOptions: true,
+                        wherePkValue: objAny[pkName],
+                        createPayload,
+                        updatePayload,
+                    });
+                    argsList.push(prismaArgs);
+                    return (db) => db[tableName].upsert(prismaArgs);
+                }
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "saveList", argsList)
+                : undefined;
+            const results = [];
+            if (validatedOptions.db) {
+                for (let i = 0; i < queries.length; i++) {
+                    results.push(await queries[i](validatedOptions.db));
+                }
+            }
+            else {
+                await instance.prisma.$transaction(async (tx) => {
+                    for (let i = 0; i < queries.length; i++) {
+                        results.push(await queries[i](tx));
+                    }
+                });
+            }
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "saveList", start);
+            return results;
+        };
+    }
+    // * PATCH
+    if (baseMethods.patch.active) {
+        instance.patch = async (pk, obj, options) => {
+            if (pk == undefined)
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+            if (!(0, is_object_validate_1.isObject)(obj)) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+            }
+            (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
+            const { updatePayload } = (0, create_update_payloads_with_relations_resolve_1.resolveCreateUpdatePayloadsWithRelations)(instance, obj, relationsKeys);
+            const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                instance,
+                baseConfig: baseMethods.patch,
+                options,
+                wherePkValue: pk,
+                dataPayload: updatePayload,
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "patch", prismaArgs)
+                : undefined;
+            const result = await db[tableName].update(prismaArgs);
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "patch", start);
+            return result;
+        };
+    }
+    // * PATCH LIST
+    if (baseMethods.patchList.active) {
+        instance.patchList = async (tuples, options) => {
+            if (!Array.isArray(tuples) ||
+                tuples.some(tuple => tuple[0] == undefined || !(0, is_object_validate_1.isObject)(tuple[1]))) {
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'tuples' must be a valid array of tuples [pk, obj].`);
+            }
+            const validatedOptions = (0, method_options_validate_1.validateMethodOptions)(options, instance);
+            const argsList = [];
+            const queries = tuples.map(tuple => {
+                (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, tuple[1], relationsKeys);
+                const objAny = tuple[1];
+                const { updatePayload } = (0, create_update_payloads_with_relations_resolve_1.resolveCreateUpdatePayloadsWithRelations)(instance, objAny, relationsKeys);
+                const { prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
+                    instance,
+                    baseConfig: baseMethods.patchList,
+                    options: validatedOptions,
+                    alreadyValidatedOptions: true,
+                    wherePkValue: tuple[0],
+                    dataPayload: updatePayload,
+                });
+                argsList.push(prismaArgs);
+                return (db) => db[tableName].update(prismaArgs);
+            });
+            const start = showWorking
+                ? (0, logger_util_1.performanceLoggerStart)(tableName, "patchList", argsList)
+                : undefined;
+            const results = [];
+            if (validatedOptions.db) {
+                for (let i = 0; i < queries.length; i++) {
+                    results.push(await queries[i](validatedOptions.db));
+                }
+            }
+            else {
+                await instance.prisma.$transaction(async (tx) => {
+                    for (let i = 0; i < queries.length; i++) {
+                        results.push(await queries[i](tx));
+                    }
+                });
+            }
+            if (showWorking)
+                (0, logger_util_1.performanceLoggerEnd)(tableName, "patchList", start);
+            return results;
+        };
+    }
+}

package/dist/internal/resolvers/create-update-payloads-with-relations.resolve.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCreateUpdatePayloadsWithRelations = resolveCreateUpdatePayloadsWithRelations;
+function resolveCreateUpdatePayloadsWithRelations(instance, obj, relationsKeys) {
+    const relations = instance.relations;
+    if (!relations) {
+        const objUpdate = { ...obj };
+        delete objUpdate[instance.pkName];
+        return {
+            createPayload: obj,
+            updatePayload: objUpdate,
+        };
+    }
+    const createPayload = {};
+    const updatePayload = {};
+    const objKeys = Object.keys(obj);
+    for (let i = 0; i < objKeys.length; i++) {
+        const key = objKeys[i];
+        const field = obj[key];
+        if (field === undefined)
+            continue;
+        if (relationsKeys.includes(key)) {
+            const relation = relations[key];
+            if (relation.mode === "oto" || relation.mode === "mto") {
+                if (field === null) {
+                    if (relation.mode === "oto" && relation.restriction === "set") {
+                        updatePayload[key] = { delete: true };
+                    }
+                    else if (relation.mode === "mto" && (relation.nullAble || relation.nullable)) {
+                        updatePayload[key] = { disconnect: true };
+                    }
+                }
+                else if (field !== undefined) {
+                    const relationFieldPk = field[relation.pk];
+                    if (relationFieldPk != null) {
+                        const connectOrCreate = {
+                            where: { [relation.pk]: relationFieldPk },
+                            create: field,
+                        };
+                        createPayload[key] = { connectOrCreate };
+                        if (relation.restriction === "add") {
+                            updatePayload[key] = { connectOrCreate };
+                        }
+                        else {
+                            const update = { ...field };
+                            delete update[relation.pk];
+                            updatePayload[key] = {
+                                upsert: {
+                                    where: { [relation.pk]: relationFieldPk },
+                                    create: field,
+                                    update: update,
+                                },
+                            };
+                        }
+                    }
+                    else {
+                        createPayload[key] = { create: field };
+                        updatePayload[key] =
+                            relation.restriction === "add"
+                                ? { create: field }
+                                : { upsert: { create: field, update: field } };
+                    }
+                }
+            }
+            else {
+                const fieldAnyArray = field;
+                const dataWithPk = [];
+                const dataWithoutPk = [];
+                fieldAnyArray.forEach((data) => {
+                    if (data[relation.pk] !== undefined) {
+                        dataWithPk.push(data);
+                    }
+                    else {
+                        dataWithoutPk.push(data);
+                    }
+                });
+                const connectOrCreate = dataWithPk.map(data => ({
+                    where: { [relation.pk]: data[relation.pk] },
+                    create: data,
+                }));
+                createPayload[key] = {
+                    create: dataWithoutPk,
+                    connectOrCreate,
+                };
+                if (relation.restriction === "add") {
+                    if (relation.mode === "mtm") {
+                        updatePayload[key] = {
+                            create: dataWithoutPk,
+                            connectOrCreate,
+                        };
+                    }
+                    else {
+                        updatePayload[key] = {
+                            create: dataWithoutPk,
+                            upsert: dataWithPk.map(data => {
+                                const update = { ...data };
+                                delete update[relation.pk];
+                                return {
+                                    where: { [relation.pk]: data[relation.pk] },
+                                    create: data,
+                                    update,
+                                };
+                            }),
+                        };
+                    }
+                }
+                else {
+                    if (relation.mode === "mtm") {
+                        updatePayload[key] = {
+                            set: [],
+                            create: dataWithoutPk,
+                            connectOrCreate,
+                        };
+                    }
+                    else {
+                        updatePayload[key] = {
+                            deleteMany: {
+                                [relation.pk]: { notIn: dataWithPk.map(data => data[relation.pk]) },
+                            },
+                            create: dataWithoutPk,
+                            upsert: dataWithPk.map(data => {
+                                const update = { ...data };
+                                delete update[relation.pk];
+                                return {
+                                    where: { [relation.pk]: data[relation.pk] },
+                                    create: data,
+                                    update,
+                                };
+                            }),
+                        };
+                    }
+                }
+            }
+        }
+        else {
+            createPayload[key] = field;
+            if (key !== instance.pkName) {
+                updatePayload[key] = field;
+            }
+        }
+    }
+    return { createPayload, updatePayload };
+}