vsrepo 2.5.0 → 2.6.0

package/dist/internal/resolvers/dynamic-methods.resolver.js

@@ -26,6 +26,55 @@ class DynamicMethodsResolver {
         this.validator = validator;
         this.defaultOrdering = defaultOrdering;
     }
+    keywordTemplate = (keyword, allowAtTheEnd = false) => new RegExp(`${keyword}(?=[\\p{Lu}]|[^\\p{ASCII}]${allowAtTheEnd ? "|$" : ""})`, "u");
+    fieldModifiers = {
+        IsNull: this.keywordTemplate("IsNull", true),
+        IsNotNull: this.keywordTemplate("IsNotNull", true),
+        IsTrue: this.keywordTemplate("IsTrue", true),
+        IsFalse: this.keywordTemplate("IsFalse", true),
+        IgnoreCase: this.keywordTemplate("IgnoreCase", true),
+        Optional: this.keywordTemplate("Optional", true),
+        NotBetween: this.keywordTemplate("NotBetween", true),
+        Between: this.keywordTemplate("Between", true),
+        NotStartsWith: this.keywordTemplate("NotStartsWith", true),
+        StartsWith: this.keywordTemplate("StartsWith", true),
+        NotEndsWith: this.keywordTemplate("NotEndsWith", true),
+        EndsWith: this.keywordTemplate("EndsWith", true),
+        NotContains: this.keywordTemplate("NotContains", true),
+        Contains: this.keywordTemplate("Contains", true),
+        LessThanEqual: this.keywordTemplate("LessThanEqual", true),
+        LessThan: this.keywordTemplate("LessThan", true),
+        GreaterThanEqual: this.keywordTemplate("GreaterThanEqual", true),
+        GreaterThan: this.keywordTemplate("GreaterThan", true),
+        NotIn: this.keywordTemplate("NotIn", true),
+        In: this.keywordTemplate("In", true),
+        Not: this.keywordTemplate("Not", true),
+        Equals: this.keywordTemplate("Equals", true),
+        NotEquals: this.keywordTemplate("NotEquals", true),
+        Without: this.keywordTemplate("Without", true),
+        With: this.keywordTemplate("With", true),
+        Some: this.keywordTemplate("Some", true),
+        Every: this.keywordTemplate("Every", true),
+        None: this.keywordTemplate("None", true),
+    };
+    operators = {
+        And: this.keywordTemplate("And"),
+        Or: this.keywordTemplate("Or"),
+        AND: this.keywordTemplate("AND"),
+    };
+    customizationModifiers = {
+        Distinct: this.keywordTemplate("Distinct"),
+        OrderBy: this.keywordTemplate("OrderBy"),
+        PaginatedAndOrdered: /PaginatedAndOrdered$/,
+        OrderedAndPaginated: /OrderedAndPaginated$/,
+        Paginated: /Paginated$/,
+        Ordered: /Ordered$/,
+        IgnoreConflicts: /IgnoreConflicts$/,
+    };
+    logAndThrowError(errorMessage) {
+        this.logger.logError(errorMessage);
+        throw new VSRepoError_1.VSRepoError(errorMessage, vsrepo_error_type_enum_1.VSRepoErrorType.RESOLVER);
+    }
     validateIndexedArg(args, positionIndex, validate, parseDebugToString = true) {
         const value = args.at(positionIndex);
         if (value === debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL) {
@@ -49,6 +98,7 @@ class DynamicMethodsResolver {
             ignoreDistinct: true,
             whereParams: [],
             otherParams: [],
+            originalDynamicMethodName: dynamicMethod,
         };
         if (dynamicMethod.startsWith("findOneBy")) {
             dynamicMethodInfo.keyToMapReplaced = dynamicMethod.replace("findOneBy", "");
@@ -61,14 +111,6 @@ class DynamicMethodsResolver {
             dynamicMethodInfo.ignoreDistinct = false;
             dynamicMethodInfo.method = "findMany";
         }
-        // else if (dynamicMethod === "groupBy") {
-        //     dynamicMethodInfo.keyToMapReplaced = dynamicMethod.replace("groupBy", "");
-        //     dynamicMethodInfo.ignoreSelect = true;
-        //     dynamicMethodInfo.ignoreWhere = true;
-        //     dynamicMethodInfo.method = "groupBy";
-        //     dynamicMethodInfo.otherParams.push("prismaArgs"); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        //     dynamicMethodInfo.argsCount++;
-        // }
         else if (dynamicMethod.startsWith("findOneOrThrowBy")) {
             dynamicMethodInfo.keyToMapReplaced = dynamicMethod.replace("findOneOrThrowBy", "");
             dynamicMethodInfo.ignoreOrderByAndPagination = false;
@@ -302,59 +344,63 @@ class DynamicMethodsResolver {
             dynamicMethodInfo.method = "findOne";
         }
         else {
-            const errorMessage = `Unknown dynamic method: ${dynamicMethod}.`;
-            this.logger.logError(errorMessage);
-            throw new VSRepoError_1.VSRepoError(errorMessage, vsrepo_error_type_enum_1.VSRepoErrorType.RESOLVER);
+            this.logAndThrowError(`Unknown dynamic method: ${dynamicMethod}.`);
         }
         return dynamicMethodInfo;
     }
     resolveDynamicMethodCustomization(dynamicMethodInfo, methodData) {
         const dynamicMethodCustomization = {};
         if (!dynamicMethodInfo.ignoreIgnoreConflicts) {
-            if (dynamicMethodInfo.keyToMapReplaced.endsWith("IgnoreConflicts")) {
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("IgnoreConflicts", "");
+            if (this.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.IgnoreConflicts, "");
                 dynamicMethodCustomization.ignoreConflicts = true;
             }
         }
+        else if (this.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
+            this.logAndThrowError(`This dynamic method prefix doesn't support the "IgnoreConflicts" modifier: ${dynamicMethodInfo.originalDynamicMethodName}.`);
+        }
         if (!dynamicMethodInfo.ignoreOrderByAndPagination) {
-            if (dynamicMethodInfo.keyToMapReplaced.endsWith("PaginatedAndOrdered")) {
+            if (this.customizationModifiers.PaginatedAndOrdered.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.orderPosition = -2;
                 dynamicMethodCustomization.paginationPosition = -3;
                 dynamicMethodInfo.otherParams.push("pagination");
                 dynamicMethodInfo.otherParams.push("order");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("PaginatedAndOrdered", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.PaginatedAndOrdered, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("OrderedAndPaginated")) {
+            else if (this.customizationModifiers.OrderedAndPaginated.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.orderPosition = -3;
                 dynamicMethodCustomization.paginationPosition = -2;
                 dynamicMethodInfo.otherParams.push("order");
                 dynamicMethodInfo.otherParams.push("pagination");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("OrderedAndPaginated", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.OrderedAndPaginated, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Paginated")) {
+            else if (this.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.paginationPosition = -2;
                 dynamicMethodInfo.otherParams.push("pagination");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Paginated", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.Paginated, "");
                 dynamicMethodInfo.argsCount++;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Ordered")) {
+            else if (this.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.orderPosition = -2;
                 dynamicMethodInfo.otherParams.push("order");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Ordered", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.Ordered, "");
                 dynamicMethodInfo.argsCount++;
             }
-            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split("OrderBy");
+            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split(this.customizationModifiers.OrderBy);
             if (keySplitedOrderBy[1]) {
-                const orderByFields = keySplitedOrderBy[1].split("And").map(uncapitalize_util_1.uncapitalize);
+                if (this.customizationModifiers.Distinct.test(keySplitedOrderBy[1])) {
+                    this.logAndThrowError(`The "Distinct" modifier cannot appear after the "OrderBy" modifier: ${dynamicMethodInfo.originalDynamicMethodName}.`);
+                }
+                const orderByFields = keySplitedOrderBy[1].split(this.operators.And).map(uncapitalize_util_1.uncapitalize);
                 dynamicMethodCustomization.injectOrdering = orderByFields.map(field => {
                     if (field.endsWith("Asc")) {
-                        field = field.replace("Asc", "");
+                        field = field.replace(/Asc$/, "");
                         return { [field]: "ASC" };
                     }
                     else if (field.endsWith("Desc")) {
-                        field = field.replace("Desc", "");
+                        field = field.replace(/Desc$/, "");
                         return { [field]: "DESC" };
                     }
                     return { [field]: "ASC" };
@@ -363,119 +409,135 @@ class DynamicMethodsResolver {
             dynamicMethodInfo.keyToMapReplaced = keySplitedOrderBy[0];
             dynamicMethodCustomization.injectOrdering ??= methodData.injectOrdering;
         }
+        else if (this.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced) ||
+            this.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced) ||
+            this.customizationModifiers.OrderBy.test(dynamicMethodInfo.keyToMapReplaced)) {
+            this.logAndThrowError(`This dynamic method prefix doesn't support the ordering or pagination modifiers: ${dynamicMethodInfo.originalDynamicMethodName}.`);
+        }
         if (!dynamicMethodInfo.ignoreDistinct) {
-            const keySplitedDistinct = dynamicMethodInfo.keyToMapReplaced.split("Distinct");
+            const keySplitedDistinct = dynamicMethodInfo.keyToMapReplaced.split(this.customizationModifiers.Distinct);
             if (keySplitedDistinct[1]) {
                 dynamicMethodCustomization.distinctKeys = keySplitedDistinct[1]
-                    .split("And")
+                    .split(this.operators.And)
                     .map(uncapitalize_util_1.uncapitalize);
             }
             dynamicMethodInfo.keyToMapReplaced = keySplitedDistinct[0];
         }
+        else if (this.customizationModifiers.Distinct.test(dynamicMethodInfo.keyToMapReplaced)) {
+            this.logAndThrowError(`This dynamic method prefix doesn't support the "Distinct" modifier: ${dynamicMethodInfo.originalDynamicMethodName}.`);
+        }
         return dynamicMethodCustomization;
     }
     resolveUglyWhere(keySplitedAnd) {
         const uglyWhere = { name: "", pushProperty: "$$$" };
         let nullMode = undefined;
-        if (keySplitedAnd.includes("IsNull")) {
+        if (this.fieldModifiers.IsNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = null;
             nullMode = "is";
-            keySplitedAnd = keySplitedAnd.replace("IsNull", "");
+            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsNull, "");
         }
-        else if (keySplitedAnd.includes("IsNotNull")) {
+        else if (this.fieldModifiers.IsNotNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "not";
             uglyWhere.autoInjectVal = null;
             nullMode = "not";
-            keySplitedAnd = keySplitedAnd.replace("IsNotNull", "");
+            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsNotNull, "");
         }
-        else if (keySplitedAnd.includes("IsTrue")) {
+        else if (this.fieldModifiers.IsTrue.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = true;
-            keySplitedAnd = keySplitedAnd.replace("IsTrue", "");
+            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsTrue, "");
         }
-        else if (keySplitedAnd.includes("IsFalse")) {
+        else if (this.fieldModifiers.IsFalse.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = false;
-            keySplitedAnd = keySplitedAnd.replace("IsFalse", "");
+            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsFalse, "");
         }
         else {
-            if (keySplitedAnd.includes("IgnoreCase")) {
+            if (this.fieldModifiers.IgnoreCase.test(keySplitedAnd)) {
                 uglyWhere.properties = {};
                 uglyWhere.properties.ignoreCase = true;
-                keySplitedAnd = keySplitedAnd.replace("IgnoreCase", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IgnoreCase, "");
             }
-            if (keySplitedAnd.includes("Optional")) {
-                keySplitedAnd = keySplitedAnd.replace("Optional", "");
+            if (this.fieldModifiers.Optional.test(keySplitedAnd)) {
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Optional, "");
             }
-            if (keySplitedAnd.includes("NotBetween")) {
+            if (this.fieldModifiers.NotBetween.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace("NotBetween", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotBetween, "");
             }
-            else if (keySplitedAnd.includes("Between")) {
+            else if (this.fieldModifiers.Between.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "$$$";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace("Between", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Between, "");
             }
-            else if (keySplitedAnd.includes("NotStartsWith")) {
+            else if (this.fieldModifiers.NotStartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.startsWith";
-                keySplitedAnd = keySplitedAnd.replace("NotStartsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotStartsWith, "");
             }
-            else if (keySplitedAnd.includes("StartsWith")) {
+            else if (this.fieldModifiers.StartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "startsWith";
-                keySplitedAnd = keySplitedAnd.replace("StartsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.StartsWith, "");
             }
-            else if (keySplitedAnd.includes("NotEndsWith")) {
+            else if (this.fieldModifiers.NotEndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.endsWith";
-                keySplitedAnd = keySplitedAnd.replace("NotEndsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotEndsWith, "");
             }
-            else if (keySplitedAnd.includes("EndsWith")) {
+            else if (this.fieldModifiers.EndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "endsWith";
-                keySplitedAnd = keySplitedAnd.replace("EndsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.EndsWith, "");
             }
-            else if (keySplitedAnd.includes("NotContains")) {
+            else if (this.fieldModifiers.NotContains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.contains";
-                keySplitedAnd = keySplitedAnd.replace("NotContains", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotContains, "");
             }
-            else if (keySplitedAnd.includes("Contains")) {
+            else if (this.fieldModifiers.Contains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "contains";
-                keySplitedAnd = keySplitedAnd.replace("Contains", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Contains, "");
+            }
+            else if (this.fieldModifiers.NotEquals.test(keySplitedAnd)) {
+                uglyWhere.pushProperty = "not";
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotEquals, "");
             }
-            else if (keySplitedAnd.includes("LessThanEqual")) {
+            else if (this.fieldModifiers.Equals.test(keySplitedAnd)) {
+                uglyWhere.pushProperty = "$$$";
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Equals, "");
+            }
+            else if (this.fieldModifiers.LessThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lte";
-                keySplitedAnd = keySplitedAnd.replace("LessThanEqual", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.LessThanEqual, "");
             }
-            else if (keySplitedAnd.includes("LessThan")) {
+            else if (this.fieldModifiers.LessThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lt";
-                keySplitedAnd = keySplitedAnd.replace("LessThan", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.LessThan, "");
             }
-            else if (keySplitedAnd.includes("GreaterThanEqual")) {
+            else if (this.fieldModifiers.GreaterThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gte";
-                keySplitedAnd = keySplitedAnd.replace("GreaterThanEqual", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.GreaterThanEqual, "");
             }
-            else if (keySplitedAnd.includes("GreaterThan")) {
+            else if (this.fieldModifiers.GreaterThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gt";
-                keySplitedAnd = keySplitedAnd.replace("GreaterThan", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.GreaterThan, "");
             }
-            else if (keySplitedAnd.includes("NotIn")) {
+            else if (this.fieldModifiers.NotIn.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "notIn";
-                keySplitedAnd = keySplitedAnd.replace("NotIn", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotIn, "");
             }
-            else if (keySplitedAnd.includes("In")) {
+            else if (this.fieldModifiers.In.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "in";
-                keySplitedAnd = keySplitedAnd.replace("In", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.In, "");
             }
-            else if (keySplitedAnd.includes("Not")) {
+            else if (this.fieldModifiers.Not.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
-                keySplitedAnd = keySplitedAnd.replace("Not", "");
+                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Not, "");
             }
             else {
                 uglyWhere.pushProperty = "$$$";
             }
         }
-        if (keySplitedAnd.includes("Without")) {
-            const keySplitedConector = keySplitedAnd.split("Without");
+        if (this.fieldModifiers.Without.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Without);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -487,12 +549,12 @@ class DynamicMethodsResolver {
                 }
             }
             else {
-                uglyWhere.pushProperty = `_without.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+                uglyWhere.pushProperty = `_without.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? (uglyWhere.properties ? ".equals" : "") : `.${uglyWhere.pushProperty}`}`;
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (keySplitedAnd.includes("With")) {
-            const keySplitedConector = keySplitedAnd.split("With");
+        else if (this.fieldModifiers.With.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.With);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -504,43 +566,43 @@ class DynamicMethodsResolver {
                 }
             }
             else {
-                uglyWhere.pushProperty = `_with.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+                uglyWhere.pushProperty = `_with.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? (uglyWhere.properties ? ".equals" : "") : `.${uglyWhere.pushProperty}`}`;
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (keySplitedAnd.includes("Some")) {
-            const keySplitedConector = keySplitedAnd.split("Some");
+        else if (this.fieldModifiers.Some.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Some);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_some";
                 uglyWhere.autoInjectVal = {};
             }
             else {
-                uglyWhere.pushProperty = `_some.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+                uglyWhere.pushProperty = `_some.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? (uglyWhere.properties ? ".equals" : "") : `.${uglyWhere.pushProperty}`}`;
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (keySplitedAnd.includes("Every")) {
-            const keySplitedConector = keySplitedAnd.split("Every");
+        else if (this.fieldModifiers.Every.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Every);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_every";
                 uglyWhere.autoInjectVal = {};
             }
             else {
-                uglyWhere.pushProperty = `_every.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+                uglyWhere.pushProperty = `_every.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? (uglyWhere.properties ? ".equals" : "") : `.${uglyWhere.pushProperty}`}`;
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (keySplitedAnd.includes("None")) {
-            const keySplitedConector = keySplitedAnd.split("None");
+        else if (this.fieldModifiers.None.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.None);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_none";
                 uglyWhere.autoInjectVal = {};
             }
             else {
-                uglyWhere.pushProperty = `_none.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? "" : `.${uglyWhere.pushProperty}`}`;
+                uglyWhere.pushProperty = `_none.${(0, uncapitalize_util_1.uncapitalize)(specificField)}${uglyWhere.pushProperty === "$$$" ? (uglyWhere.properties ? ".equals" : "") : `.${uglyWhere.pushProperty}`}`;
             }
             keySplitedAnd = keySplitedConector[0];
         }
@@ -554,20 +616,29 @@ class DynamicMethodsResolver {
             prettyWheres: [],
         };
         let ANDMode = false;
-        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split("AND");
+        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split(this.operators.AND);
         if (keysSplitedAND.length > 1) {
             ANDMode = true;
         }
         keysSplitedAND.forEach((keySplitedAND, idx) => {
             let orMode = false;
-            let keysSplitedOr = idx === 0 ? keySplitedAND.split("Or") : [keySplitedAND];
+            let keysSplitedOr;
+            if (idx === 0) {
+                keysSplitedOr = keySplitedAND.split(this.operators.Or);
+            }
+            else {
+                if (this.operators.Or.test(keySplitedAND)) {
+                    this.logAndThrowError(`The logical operator "Or" cannot appear after an "AND" (all caps): ${dynamicMethodInfo.originalDynamicMethodName}.`);
+                }
+                keysSplitedOr = [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");
+                const keysSplitedAnd = keysSplitedOr[i].split(this.operators.And);
                 for (const keySplitedAnd of keysSplitedAnd) {
                     if (keySplitedAnd === "")
                         continue;
@@ -718,9 +789,7 @@ class DynamicMethodsResolver {
                         adjust++;
                         continue;
                     }
-                    const arg = args[j - adjust] === debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL
-                        ? `<args>[${j - adjust}]`
-                        : args[j - adjust];
+                    const arg = args[j - adjust] === debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL ? `<args>[${j - adjust}]` : args[j - adjust];
                     // ? Avaliar necessidade dessa validação; era usada por compatibilidade direta com o prisma
                     if (currentWhereRslvd.betweenMode && arg !== undefined) {
                         current[context[i]] = { between: arg };
@@ -782,7 +851,7 @@ class DynamicMethodsResolver {
             if (!dynamicMethodInfo.ignoreWhere) {
                 dynamicMethodWhereOps = this.resolvePrettyWheres(dynamicMethodInfo);
             }
-            instance.$vsrepocache.set(originalKey, (args, methodOptions) => {
+            instance._vsrepocache.set(originalKey, (args, methodOptions) => {
                 const vsrepoResolveArgsData = {
                     instance,
                     options: methodOptions ?? {},
@@ -796,9 +865,7 @@ class DynamicMethodsResolver {
                     pagination: dynamicMethodCustomization.paginationPosition !== undefined
                         ? this.validateIndexedArg(args, dynamicMethodCustomization.paginationPosition, value => this.validator.validatePagination(value))
                         : undefined,
-                    dataPayload: dynamicMethodInfo.dataIndex !== undefined
-                        ? args.at(dynamicMethodInfo.dataIndex)
-                        : undefined,
+                    dataPayload: dynamicMethodInfo.dataIndex !== undefined ? args.at(dynamicMethodInfo.dataIndex) : undefined,
                     createPayload: dynamicMethodInfo.createIndex !== undefined
                         ? args.at(dynamicMethodInfo.createIndex)
                         : undefined,
@@ -825,7 +892,7 @@ class DynamicMethodsResolver {
                 for (let i = 0; i <= dynamicMethodInfo.argsCount; i++) {
                     argsSimulation.push(debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL);
                 }
-                const vsrepoArgs = instance.$vsrepocache.get(originalKey)(argsSimulation);
+                const vsrepoArgs = instance._vsrepocache.get(originalKey)(argsSimulation);
                 const { db: _, ...options } = vsrepoArgs.options ?? {};
                 this.logger.logDebug(`Args preview for ${originalKey}:`, {
                     ...vsrepoArgs,
@@ -833,7 +900,6 @@ class DynamicMethodsResolver {
                 });
             }
             instance[originalKey] = async (...args) => {
-                let db = this.adapter.getDbClient();
                 let methodOptions;
                 if (args.length < dynamicMethodInfo.argsCount) {
                     const missingParams = dynamicMethodInfo.whereParams
@@ -846,12 +912,11 @@ class DynamicMethodsResolver {
                 else if (args.length > dynamicMethodInfo.argsCount) {
                     const optionsArg = args[args.length - 1];
                     methodOptions = this.validator.validateMethodOptions(optionsArg);
-                    db = methodOptions.db ?? db;
                 }
                 else {
                     args.push("1");
                 }
-                const vsrepoArgs = instance.$vsrepocache.get(originalKey)(args, methodOptions);
+                const vsrepoArgs = instance._vsrepocache.get(originalKey)(args, methodOptions);
                 const start = this.logger.startPerformLog(`run ${String(originalKey)} (-> ${dynamicMethodInfo.method})`);
                 try {
                     // * Todos os métodos do adapter seguem essa precedencia de parametros