vsrepo 1.2.6 → 1.2.7

package/dist/internal/resolvers/data-payload-with-relations.resolve.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDataPayloadWithRelations = resolveDataPayloadWithRelations;
+function resolveDataPayloadWithRelations(instance, obj, relationsKeys) {
+    const relations = instance.relations;
+    if (!relations)
+        return obj;
+    const dataPayload = {};
+    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)) {
+            if (field === null)
+                continue;
+            const relation = relations[key];
+            if (relation.mode === "otm" || relation.mode === "mtm") {
+                const dataWithPk = [];
+                const dataWithoutPk = [];
+                field.forEach((data) => {
+                    if (data[relation.pk] !== undefined) {
+                        dataWithPk.push(data);
+                    }
+                    else {
+                        dataWithoutPk.push(data);
+                    }
+                });
+                dataPayload[key] = {
+                    create: dataWithoutPk,
+                    connectOrCreate: dataWithPk.map(data => ({
+                        where: { [relation.pk]: data[relation.pk] },
+                        create: data,
+                    })),
+                };
+            }
+            else {
+                const relationFieldPk = field[relation.pk];
+                if (relationFieldPk != null) {
+                    dataPayload[key] = {
+                        connectOrCreate: {
+                            where: { [relation.pk]: relationFieldPk },
+                            create: field,
+                        },
+                    };
+                }
+                else {
+                    dataPayload[key] = {
+                        create: field,
+                    };
+                }
+            }
+        }
+        else {
+            dataPayload[key] = field;
+        }
+    }
+    return dataPayload;
+}

package/dist/internal/resolvers/dbAndPrismaArgs.resolve.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDbAndPrismaArgs = resolveDbAndPrismaArgs;
+const method_options_validate_1 = require("../validation/method-options.validate");
+const merge_wheres_resolve_1 = require("./merge-wheres.resolve");
+const select_resolve_1 = require("./select.resolve");
+function resolveDbAndPrismaArgs(data) {
+    const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordenation, pagination, skipDuplicates, forceSeeMode, } = data;
+    const validatedOptions = (alreadyValidatedOptions && options)
+        ? options
+        : (0, method_options_validate_1.validateMethodOptions)(options, instance);
+    const db = validatedOptions.db ?? instance.prisma;
+    const prismaArgs = {};
+    if (!withoutWhere) {
+        prismaArgs.where = (0, merge_wheres_resolve_1.resolveMergeWheres)({
+            respectRequired: !baseConfig.ignoreRequiredWhere,
+            see: forceSeeMode ?? validatedOptions.see,
+        }, wherePkValue != undefined ? { [instance.pkName]: wherePkValue } : specificWhere, pushWhere, instance.requiredWhere, instance.softRemovekName);
+    }
+    if (!withoutSelect) {
+        prismaArgs.select =
+            specificSelect ??
+                (0, select_resolve_1.resolveSelect)(instance, validatedOptions.selectModel, baseConfig.defaultSelect);
+    }
+    if (dataPayload) {
+        prismaArgs.data = dataPayload;
+    }
+    if (createPayload) {
+        prismaArgs.create = createPayload;
+    }
+    if (updatePayload) {
+        prismaArgs.update = updatePayload;
+    }
+    if (ordenation) {
+        prismaArgs.orderBy = ordenation;
+    }
+    if (pagination) {
+        prismaArgs.skip = pagination.skip;
+        prismaArgs.take = pagination.take;
+        prismaArgs.cursor = pagination.cursor;
+    }
+    if (skipDuplicates !== undefined) {
+        prismaArgs.skipDuplicates = skipDuplicates;
+    }
+    return { db, prismaArgs };
+}

package/dist/internal/resolvers/dinamic-method-customization.resolve.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDinamicMethodCustomization = resolveDinamicMethodCustomization;
+function resolveDinamicMethodCustomization(instance, dinamicMethodInfo, originalKey) {
+    const dinamicMethodCustomization = {};
+    if (!dinamicMethodInfo.ignoreSkipDuplicates) {
+        if (dinamicMethodInfo.keyToMapReplaced.endsWith("SkipDuplicates")) {
+            dinamicMethodInfo.keyToMapReplaced = dinamicMethodInfo.keyToMapReplaced.replace("SkipDuplicates", "");
+            dinamicMethodCustomization.skipDuplicates = true;
+        }
+    }
+    if (!dinamicMethodInfo.ignoreOrderByAndPagination) {
+        dinamicMethodCustomization.injectOrdenation = instance.methods?.[originalKey]?.injectOrdenation;
+        dinamicMethodCustomization.injectPagination = instance.methods?.[originalKey]?.injectPagination;
+        if (dinamicMethodInfo.keyToMapReplaced.endsWith("PaginatedAndOrdered")) {
+            dinamicMethodCustomization.orderPosition = -2;
+            dinamicMethodCustomization.paginationPosition = -3;
+            dinamicMethodInfo.otherParams.push("pagination");
+            dinamicMethodInfo.otherParams.push("order");
+            dinamicMethodInfo.keyToMapReplaced = dinamicMethodInfo.keyToMapReplaced.replace("PaginatedAndOrdered", "");
+            dinamicMethodInfo.argsCount += 2;
+        }
+        else if (dinamicMethodInfo.keyToMapReplaced.endsWith("OrderedAndPaginated")) {
+            dinamicMethodCustomization.orderPosition = -3;
+            dinamicMethodCustomization.paginationPosition = -2;
+            dinamicMethodInfo.otherParams.push("order");
+            dinamicMethodInfo.otherParams.push("pagination");
+            dinamicMethodInfo.keyToMapReplaced = dinamicMethodInfo.keyToMapReplaced.replace("OrderedAndPaginated", "");
+            dinamicMethodInfo.argsCount += 2;
+        }
+        else if (dinamicMethodInfo.keyToMapReplaced.endsWith("Paginated")) {
+            dinamicMethodCustomization.paginationPosition = -2;
+            dinamicMethodInfo.otherParams.push("pagination");
+            dinamicMethodInfo.keyToMapReplaced = dinamicMethodInfo.keyToMapReplaced.replace("Paginated", "");
+            dinamicMethodInfo.argsCount++;
+        }
+        else if (dinamicMethodInfo.keyToMapReplaced.endsWith("Ordered")) {
+            dinamicMethodCustomization.orderPosition = -2;
+            dinamicMethodInfo.otherParams.push("order");
+            dinamicMethodInfo.keyToMapReplaced = dinamicMethodInfo.keyToMapReplaced.replace("Ordered", "");
+            dinamicMethodInfo.argsCount++;
+        }
+    }
+    return dinamicMethodCustomization;
+}

package/dist/internal/resolvers/dinamic-method-info.resolve.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDinamicMethodInfo = resolveDinamicMethodInfo;
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+function resolveDinamicMethodInfo(instance, dinamicMethod, originalKey) {
+    const dinamicMethodInfo = {
+        onlyBaseWheres: false,
+        ignoreWhere: false,
+        ignoreOrderByAndPagination: true,
+        ignoreSelect: false,
+        keyToMapReplaced: "",
+        argsCount: 0,
+        method: "unknown",
+        existsMode: false,
+        ignoreSkipDuplicates: true,
+        whereParams: [],
+        otherParams: [],
+    };
+    if (dinamicMethod === "aggregate") {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("aggregate", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.method = "aggregate";
+        dinamicMethodInfo.prismaArgsIndex = 0;
+        dinamicMethodInfo.otherParams.push("prismaArgs");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod === "groupBy") {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("groupBy", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.method = "groupBy";
+        dinamicMethodInfo.prismaArgsIndex = 0;
+        dinamicMethodInfo.otherParams.push("prismaArgs");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("findUniqueOrThrowBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findUniqueOrThrowBy", "");
+        dinamicMethodInfo.method = "findUniqueOrThrow";
+    }
+    else if (dinamicMethod.startsWith("findUniqueBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findUniqueBy", "");
+        dinamicMethodInfo.method = "findUnique";
+    }
+    else if (dinamicMethod.startsWith("findFirstOrThrowBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findFirstOrThrowBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.method = "findFirstOrThrow";
+    }
+    else if (dinamicMethod.startsWith("findFirstOrThrow")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findFirstOrThrow", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findFirstOrThrow";
+    }
+    else if (dinamicMethod.startsWith("findFirstBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findFirstBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.method = "findFirst";
+    }
+    else if (dinamicMethod.startsWith("findFirst")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findFirst", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findFirst";
+    }
+    else if (dinamicMethod.startsWith("countBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("countBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.method = "count";
+    }
+    else if (dinamicMethod.startsWith("countWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("countWhere", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.method = "count";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("count")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("count", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "count";
+    }
+    else if (dinamicMethod.startsWith("existsBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("existsBy", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.existsMode = true;
+        dinamicMethodInfo.method = "findFirst";
+    }
+    else if (dinamicMethod.startsWith("existsWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("existsWhere", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.existsMode = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findFirst";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("findManyBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findManyBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.method = "findMany";
+    }
+    else if (dinamicMethod.startsWith("findMany")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findMany", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findMany";
+    }
+    else if (dinamicMethod.startsWith("createManyAndReturn")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("createManyAndReturn", "");
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.ignoreSkipDuplicates = false;
+        dinamicMethodInfo.method = "createManyAndReturn";
+        dinamicMethodInfo.dataIndex = 0;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("createMany")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("createMany", "");
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreSkipDuplicates = false;
+        dinamicMethodInfo.method = "createMany";
+        dinamicMethodInfo.dataIndex = 0;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("create")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("create", "");
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.method = "create";
+        dinamicMethodInfo.dataIndex = 0;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("updateManyAndReturnBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("updateManyAndReturnBy", "");
+        dinamicMethodInfo.method = "updateManyAndReturn";
+        dinamicMethodInfo.dataIndex = -2;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("updateManyAndReturnWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("updateManyAndReturnWhere", "");
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "updateManyAndReturn";
+        dinamicMethodInfo.dataIndex = -2;
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where", "data");
+        dinamicMethodInfo.argsCount += 2;
+    }
+    else if (dinamicMethod.startsWith("updateManyBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("updateManyBy", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.method = "updateMany";
+        dinamicMethodInfo.dataIndex = -2;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("updateManyWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("updateManyWhere", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "updateMany";
+        dinamicMethodInfo.dataIndex = -2;
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where", "data");
+        dinamicMethodInfo.argsCount += 2;
+    }
+    else if (dinamicMethod.startsWith("updateBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("updateBy", "");
+        dinamicMethodInfo.method = "update";
+        dinamicMethodInfo.dataIndex = -2;
+        dinamicMethodInfo.otherParams.push("data");
+        dinamicMethodInfo.argsCount++;
+    }
+    else if (dinamicMethod.startsWith("upsertBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("upsertBy", "");
+        dinamicMethodInfo.method = "upsert";
+        dinamicMethodInfo.createIndex = -2;
+        dinamicMethodInfo.updateIndex = -3;
+        dinamicMethodInfo.otherParams.push("update");
+        dinamicMethodInfo.otherParams.push("create");
+        dinamicMethodInfo.argsCount += 2;
+    }
+    else if (dinamicMethod.startsWith("deleteManyBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("deleteManyBy", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.method = "deleteMany";
+    }
+    else if (dinamicMethod.startsWith("deleteManyWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("deleteManyWhere", "");
+        dinamicMethodInfo.ignoreSelect = true;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "deleteMany";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("deleteBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("deleteBy", "");
+        dinamicMethodInfo.method = "delete";
+    }
+    else if (dinamicMethod.startsWith("findWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findWhere", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findFirst";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("findOneWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findOneWhere", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findFirst";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("findListWhere")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findListWhere", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.ignoreWhere = true;
+        dinamicMethodInfo.onlyBaseWheres = true;
+        dinamicMethodInfo.method = "findMany";
+        dinamicMethodInfo.whereIndex = 0;
+        dinamicMethodInfo.otherParams.push("where");
+        dinamicMethodInfo.argsCount += 1;
+    }
+    else if (dinamicMethod.startsWith("findOneBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findOneBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.method = "findFirst";
+    }
+    else if (dinamicMethod.startsWith("findBy")) {
+        dinamicMethodInfo.keyToMapReplaced = dinamicMethod.replace("findBy", "");
+        dinamicMethodInfo.ignoreOrderByAndPagination = false;
+        dinamicMethodInfo.method = instance.methods?.[originalKey]?.fbMode === "one" ? "findFirst" : "findMany";
+    }
+    else {
+        throw new vs_repo_error_1.VSRepoBuildError(`[VSRepository] (${instance.tableName}: build) Unknown method: ${dinamicMethod}.`);
+    }
+    return dinamicMethodInfo;
+}

package/dist/internal/resolvers/merge-wheres.resolve.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMergeWheres = resolveMergeWheres;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+function resolveMergeWheres(config, provided, pushed, required, softRemovekName) {
+    const objectsToMerge = [];
+    if (provided)
+        objectsToMerge.push(provided);
+    if (pushed)
+        objectsToMerge.push(pushed);
+    if (required && config.respectRequired)
+        objectsToMerge.push(required);
+    if (softRemovekName && config.see !== "all")
+        objectsToMerge.push({ [softRemovekName]: config.see === "active" ? null : { not: null } });
+    const whereResolved = deepmerge_1.default.all(objectsToMerge, {
+        arrayMerge: (target, source) => source.concat(target),
+    });
+    return whereResolved;
+}

package/dist/internal/resolvers/pretty-wheres.resolve.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePrettyWheres = resolvePrettyWheres;
+const ugly_where_resolve_1 = require("./ugly-where.resolve");
+function resolvePrettyWheres(dinamicMethodInfo, dinamicMethodWhereOps) {
+    let ANDMode = false;
+    let keysSplitedAND = dinamicMethodInfo.keyToMapReplaced.split("AND");
+    if (keysSplitedAND.length > 1) {
+        ANDMode = true;
+    }
+    keysSplitedAND.forEach((keySplitedAND, idx) => {
+        let orMode = false;
+        let keysSplitedOr = idx === 0 ? keySplitedAND.split("Or") : [keySplitedAND];
+        if (keysSplitedOr.length > 1) {
+            orMode = true;
+        }
+        for (let i = 0; i < keysSplitedOr.length; i++) {
+            if (keysSplitedOr[i] === "")
+                continue;
+            const keysSplitedAnd = keysSplitedOr[i].split("And");
+            for (const keySplitedAnd of keysSplitedAnd) {
+                if (keySplitedAnd === "")
+                    continue;
+                const uglyWhere = (0, ugly_where_resolve_1.resolveUglyWhere)(keySplitedAnd);
+                if (!orMode) {
+                    if (idx === 1 && ANDMode) {
+                        uglyWhere.name = `AND.${i}idx.${uglyWhere.name}`;
+                    }
+                    dinamicMethodWhereOps.uglyWheres.push(uglyWhere);
+                }
+                else {
+                    uglyWhere.name = `OR.${i}idx.${uglyWhere.name}`;
+                    dinamicMethodWhereOps.uglyWheres.push(uglyWhere);
+                }
+                if (uglyWhere.autoInjectVal === undefined)
+                    dinamicMethodInfo.argsCount++;
+            }
+        }
+    });
+    const prettyWheres = dinamicMethodWhereOps.uglyWheres.map(arg => {
+        let context = [];
+        let otherProps = undefined;
+        let argName = arg.name;
+        const agrNameSplitedOr = argName.split("OR.");
+        if (agrNameSplitedOr.length > 1) {
+            const agrNameSplitedOrIdx = agrNameSplitedOr[1].split("idx.");
+            context.push("OR");
+            context.push(Number(agrNameSplitedOrIdx[0]));
+            argName = agrNameSplitedOrIdx[1];
+        }
+        else {
+            const agrNameSplitedAND = argName.split("AND.");
+            if (agrNameSplitedAND.length > 1) {
+                const agrNameSplitedANDIdx = agrNameSplitedAND[1].split("idx.");
+                context.push("AND");
+                context.push(Number(agrNameSplitedANDIdx[0]));
+                argName = agrNameSplitedANDIdx[1];
+            }
+        }
+        context.push(argName);
+        if (arg.pushProperty !== "$$$") {
+            const pushProperty = arg.pushProperty;
+            const pushPropertySplitedDot = pushProperty.split(".");
+            pushPropertySplitedDot.forEach(prop => context.push(prop));
+        }
+        if (arg.properties !== undefined) {
+            const propertiesKeys = Object.keys(arg.properties);
+            otherProps = {};
+            for (let i = 0; i < propertiesKeys.length; i++) {
+                const key = propertiesKeys[i];
+                otherProps[key] = arg.properties[key];
+            }
+            if (arg.pushProperty === "$$$") {
+                context.push("equals");
+            }
+        }
+        dinamicMethodInfo.whereParams.push(argName);
+        return {
+            context,
+            otherProps,
+            argName,
+            autoVal: arg.autoInjectVal,
+            betweenMode: arg.betweenMode,
+        };
+    });
+    dinamicMethodWhereOps.prettyWheres = prettyWheres;
+}

package/dist/internal/resolvers/select.resolve.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSelect = resolveSelect;
+function resolveSelect(instance, provided, pushed) {
+    const selectModelKey = provided ?? pushed ?? instance.defaultSelectModel;
+    return selectModelKey ? instance.selectModels?.[selectModelKey] : undefined;
+}

package/dist/internal/resolvers/specific-where.resolve.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSpecificWhere = resolveSpecificWhere;
+function resolveSpecificWhere(args, prettyWheres) {
+    const specificWhere = {};
+    let OR;
+    let AND;
+    let adjust = 0;
+    for (let j = 0; j < prettyWheres.length; j++) {
+        let path = {};
+        let current = path;
+        let ormode = false;
+        let andmode = false;
+        let modeIdx;
+        const currentWhereRslvd = prettyWheres[j];
+        const context = currentWhereRslvd.context;
+        const contextLength = context.length;
+        const contextLengthM1 = contextLength - 1;
+        for (let i = 0; i < contextLength; i++) {
+            if (i < contextLengthM1) {
+                if (context[i] === "OR") {
+                    ormode = true;
+                }
+                else if (context[i] === "AND") {
+                    andmode = true;
+                }
+                else if (typeof context[i] === "number") {
+                    modeIdx = context[i];
+                }
+                else {
+                    if (!current[context[i]])
+                        current[context[i]] = {};
+                    current = current[context[i]];
+                }
+            }
+            else {
+                if (currentWhereRslvd.autoVal !== undefined) {
+                    current[context[i]] = currentWhereRslvd.autoVal;
+                    adjust++;
+                }
+                else if (currentWhereRslvd.betweenMode && args[j - adjust] !== undefined) {
+                    current[context[i]] = {};
+                    current[context[i]]["gte"] = args[j - adjust][0];
+                    current[context[i]]["lte"] = args[j - adjust][1];
+                }
+                else {
+                    current[context[i]] = args[j - adjust];
+                }
+            }
+        }
+        if (currentWhereRslvd.otherProps !== undefined) {
+            Object.assign(path[currentWhereRslvd.argName], currentWhereRslvd.otherProps);
+        }
+        if (ormode) {
+            if (!OR)
+                OR = [];
+            if (!OR[modeIdx])
+                OR[modeIdx] = {};
+            Object.assign(OR[modeIdx], path);
+        }
+        else if (andmode) {
+            if (!AND)
+                AND = [];
+            if (!AND[modeIdx])
+                AND[modeIdx] = {};
+            Object.assign(AND[modeIdx], path);
+        }
+        else {
+            Object.assign(specificWhere, path);
+        }
+    }
+    if (OR)
+        specificWhere.OR = OR.filter(x => x !== undefined);
+    if (AND)
+        specificWhere.AND = AND.filter(x => x !== undefined);
+    return specificWhere;
+}

package/dist/internal/resolvers/types/base-method-function.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/dinamic-method-customization.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/dinamic-method-info.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/dinamic-method-where-ops.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/pretty-where.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/prisma-args.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/repository-build-instance.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/resolve-db-and-prisma-args-data.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/resolvers/types/ugly-where.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });