vsrepo 2.5.0 → 2.7.0

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

@@ -13,25 +13,75 @@ const deepmerge_1 = __importDefault(require("deepmerge"));
 const vsrepo_error_type_enum_1 = require("../enums/vsrepo-error-type.enum");
 const debug_arg_symbol_constant_1 = require("../constants/debug-arg-symbol.constant");
 const db_arg_util_1 = require("../utils/db-arg.util");
+const vs_placeholder_parser_util_1 = require("../utils/vs-placeholder-parser.util");
 class DynamicMethodsResolver {
     logger;
     adapter;
     mergeWheresResolver;
     validator;
     defaultOrdering;
-    constructor(logger, adapter, mergeWheresResolver, validator, defaultOrdering) {
+    vsPlaceholders;
+    constructor(logger, adapter, mergeWheresResolver, validator, defaultOrdering, vsPlaceholders = false) {
         this.logger = logger;
         this.adapter = adapter;
         this.mergeWheresResolver = mergeWheresResolver;
         this.validator = validator;
         this.defaultOrdering = defaultOrdering;
+        this.vsPlaceholders = vsPlaceholders;
     }
-    validateIndexedArg(args, positionIndex, validate, parseDebugToString = true) {
+    static keywordTemplate = (keyword, allowAtTheEnd = false) => new RegExp(`${keyword}(?=[\\p{Lu}]|[^\\p{ASCII}]${allowAtTheEnd ? "|$" : ""})`, "u");
+    static 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),
+    };
+    static operators = {
+        And: this.keywordTemplate("And"),
+        Or: this.keywordTemplate("Or"),
+        AND: this.keywordTemplate("AND"),
+    };
+    static 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) {
         const value = args.at(positionIndex);
         if (value === debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL) {
-            return (parseDebugToString
-                ? `<args>[${positionIndex < 0 ? args.length + positionIndex : positionIndex}]`
-                : value);
+            return `<args>[${positionIndex < 0 ? args.length + positionIndex : positionIndex}]`;
         }
         return validate(value);
     }
@@ -49,6 +99,7 @@ class DynamicMethodsResolver {
             ignoreDistinct: true,
             whereParams: [],
             otherParams: [],
+            originalDynamicMethodName: dynamicMethod,
         };
         if (dynamicMethod.startsWith("findOneBy")) {
             dynamicMethodInfo.keyToMapReplaced = dynamicMethod.replace("findOneBy", "");
@@ -61,14 +112,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 +345,65 @@ 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 (DynamicMethodsResolver.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.IgnoreConflicts, "");
                 dynamicMethodCustomization.ignoreConflicts = true;
             }
         }
+        else if (DynamicMethodsResolver.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 (DynamicMethodsResolver.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(DynamicMethodsResolver.customizationModifiers.PaginatedAndOrdered, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("OrderedAndPaginated")) {
+            else if (DynamicMethodsResolver.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(DynamicMethodsResolver.customizationModifiers.OrderedAndPaginated, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Paginated")) {
+            else if (DynamicMethodsResolver.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.paginationPosition = -2;
                 dynamicMethodInfo.otherParams.push("pagination");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Paginated", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.Paginated, "");
                 dynamicMethodInfo.argsCount++;
             }
-            else if (dynamicMethodInfo.keyToMapReplaced.endsWith("Ordered")) {
+            else if (DynamicMethodsResolver.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.orderPosition = -2;
                 dynamicMethodInfo.otherParams.push("order");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace("Ordered", "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.Ordered, "");
                 dynamicMethodInfo.argsCount++;
             }
-            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split("OrderBy");
+            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split(DynamicMethodsResolver.customizationModifiers.OrderBy);
             if (keySplitedOrderBy[1]) {
-                const orderByFields = keySplitedOrderBy[1].split("And").map(uncapitalize_util_1.uncapitalize);
+                if (DynamicMethodsResolver.customizationModifiers.Distinct.test(keySplitedOrderBy[1])) {
+                    this.logAndThrowError(`The "Distinct" modifier cannot appear after the "OrderBy" modifier: ${dynamicMethodInfo.originalDynamicMethodName}.`);
+                }
+                const orderByFields = keySplitedOrderBy[1]
+                    .split(DynamicMethodsResolver.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 +412,135 @@ class DynamicMethodsResolver {
             dynamicMethodInfo.keyToMapReplaced = keySplitedOrderBy[0];
             dynamicMethodCustomization.injectOrdering ??= methodData.injectOrdering;
         }
+        else if (DynamicMethodsResolver.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced) ||
+            DynamicMethodsResolver.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced) ||
+            DynamicMethodsResolver.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(DynamicMethodsResolver.customizationModifiers.Distinct);
             if (keySplitedDistinct[1]) {
                 dynamicMethodCustomization.distinctKeys = keySplitedDistinct[1]
-                    .split("And")
+                    .split(DynamicMethodsResolver.operators.And)
                     .map(uncapitalize_util_1.uncapitalize);
             }
             dynamicMethodInfo.keyToMapReplaced = keySplitedDistinct[0];
         }
+        else if (DynamicMethodsResolver.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 (DynamicMethodsResolver.fieldModifiers.IsNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = null;
             nullMode = "is";
-            keySplitedAnd = keySplitedAnd.replace("IsNull", "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsNull, "");
         }
-        else if (keySplitedAnd.includes("IsNotNull")) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsNotNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "not";
             uglyWhere.autoInjectVal = null;
             nullMode = "not";
-            keySplitedAnd = keySplitedAnd.replace("IsNotNull", "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsNotNull, "");
         }
-        else if (keySplitedAnd.includes("IsTrue")) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsTrue.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = true;
-            keySplitedAnd = keySplitedAnd.replace("IsTrue", "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsTrue, "");
         }
-        else if (keySplitedAnd.includes("IsFalse")) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsFalse.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = false;
-            keySplitedAnd = keySplitedAnd.replace("IsFalse", "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsFalse, "");
         }
         else {
-            if (keySplitedAnd.includes("IgnoreCase")) {
+            if (DynamicMethodsResolver.fieldModifiers.IgnoreCase.test(keySplitedAnd)) {
                 uglyWhere.properties = {};
                 uglyWhere.properties.ignoreCase = true;
-                keySplitedAnd = keySplitedAnd.replace("IgnoreCase", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IgnoreCase, "");
             }
-            if (keySplitedAnd.includes("Optional")) {
-                keySplitedAnd = keySplitedAnd.replace("Optional", "");
+            if (DynamicMethodsResolver.fieldModifiers.Optional.test(keySplitedAnd)) {
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Optional, "");
             }
-            if (keySplitedAnd.includes("NotBetween")) {
+            if (DynamicMethodsResolver.fieldModifiers.NotBetween.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace("NotBetween", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotBetween, "");
             }
-            else if (keySplitedAnd.includes("Between")) {
+            else if (DynamicMethodsResolver.fieldModifiers.Between.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "$$$";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace("Between", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Between, "");
             }
-            else if (keySplitedAnd.includes("NotStartsWith")) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotStartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.startsWith";
-                keySplitedAnd = keySplitedAnd.replace("NotStartsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotStartsWith, "");
             }
-            else if (keySplitedAnd.includes("StartsWith")) {
+            else if (DynamicMethodsResolver.fieldModifiers.StartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "startsWith";
-                keySplitedAnd = keySplitedAnd.replace("StartsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.StartsWith, "");
             }
-            else if (keySplitedAnd.includes("NotEndsWith")) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotEndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.endsWith";
-                keySplitedAnd = keySplitedAnd.replace("NotEndsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotEndsWith, "");
             }
-            else if (keySplitedAnd.includes("EndsWith")) {
+            else if (DynamicMethodsResolver.fieldModifiers.EndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "endsWith";
-                keySplitedAnd = keySplitedAnd.replace("EndsWith", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.EndsWith, "");
             }
-            else if (keySplitedAnd.includes("NotContains")) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotContains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.contains";
-                keySplitedAnd = keySplitedAnd.replace("NotContains", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotContains, "");
             }
-            else if (keySplitedAnd.includes("Contains")) {
+            else if (DynamicMethodsResolver.fieldModifiers.Contains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "contains";
-                keySplitedAnd = keySplitedAnd.replace("Contains", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Contains, "");
+            }
+            else if (DynamicMethodsResolver.fieldModifiers.NotEquals.test(keySplitedAnd)) {
+                uglyWhere.pushProperty = "not";
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotEquals, "");
             }
-            else if (keySplitedAnd.includes("LessThanEqual")) {
+            else if (DynamicMethodsResolver.fieldModifiers.Equals.test(keySplitedAnd)) {
+                uglyWhere.pushProperty = "$$$";
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Equals, "");
+            }
+            else if (DynamicMethodsResolver.fieldModifiers.LessThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lte";
-                keySplitedAnd = keySplitedAnd.replace("LessThanEqual", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.LessThanEqual, "");
             }
-            else if (keySplitedAnd.includes("LessThan")) {
+            else if (DynamicMethodsResolver.fieldModifiers.LessThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lt";
-                keySplitedAnd = keySplitedAnd.replace("LessThan", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.LessThan, "");
             }
-            else if (keySplitedAnd.includes("GreaterThanEqual")) {
+            else if (DynamicMethodsResolver.fieldModifiers.GreaterThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gte";
-                keySplitedAnd = keySplitedAnd.replace("GreaterThanEqual", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.GreaterThanEqual, "");
             }
-            else if (keySplitedAnd.includes("GreaterThan")) {
+            else if (DynamicMethodsResolver.fieldModifiers.GreaterThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gt";
-                keySplitedAnd = keySplitedAnd.replace("GreaterThan", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.GreaterThan, "");
             }
-            else if (keySplitedAnd.includes("NotIn")) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotIn.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "notIn";
-                keySplitedAnd = keySplitedAnd.replace("NotIn", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotIn, "");
             }
-            else if (keySplitedAnd.includes("In")) {
+            else if (DynamicMethodsResolver.fieldModifiers.In.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "in";
-                keySplitedAnd = keySplitedAnd.replace("In", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.In, "");
             }
-            else if (keySplitedAnd.includes("Not")) {
+            else if (DynamicMethodsResolver.fieldModifiers.Not.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
-                keySplitedAnd = keySplitedAnd.replace("Not", "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Not, "");
             }
             else {
                 uglyWhere.pushProperty = "$$$";
             }
         }
-        if (keySplitedAnd.includes("Without")) {
-            const keySplitedConector = keySplitedAnd.split("Without");
+        if (DynamicMethodsResolver.fieldModifiers.Without.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.Without);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -487,12 +552,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 (DynamicMethodsResolver.fieldModifiers.With.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.With);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -504,43 +569,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 (DynamicMethodsResolver.fieldModifiers.Some.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.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 (DynamicMethodsResolver.fieldModifiers.Every.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.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 (DynamicMethodsResolver.fieldModifiers.None.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.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 +619,29 @@ class DynamicMethodsResolver {
             prettyWheres: [],
         };
         let ANDMode = false;
-        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split("AND");
+        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split(DynamicMethodsResolver.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(DynamicMethodsResolver.operators.Or);
+            }
+            else {
+                if (DynamicMethodsResolver.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(DynamicMethodsResolver.operators.And);
                 for (const keySplitedAnd of keysSplitedAnd) {
                     if (keySplitedAnd === "")
                         continue;
@@ -643,10 +717,9 @@ class DynamicMethodsResolver {
         vsrepoArgs.options = { db: options.db ?? this.adapter.getDbClient() };
         if (!withoutWhere) {
             vsrepoArgs.where =
-                // * Essa validação é so para o debug mode
-                specificWhere === debug_arg_symbol_constant_1.DEBUG_ARG_SYMBOL
-                    ? // * 0 pois o whereIndex sempre vem no 0, se algum dia ele puder aparecer em outro lugar irá precisar corrigir isso
-                        "<args>[0]"
+                // * Validação necessária para o DEBUG MODE
+                typeof specificWhere === "string"
+                    ? specificWhere
                     : this.mergeWheresResolver.resolve(options.see, specificWhere);
         }
         if (!withoutSelect) {
@@ -718,9 +791,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 +853,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 +867,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,
@@ -814,7 +883,7 @@ class DynamicMethodsResolver {
                 else if (dynamicMethodInfo.onlyBaseWheres) {
                     vsrepoResolveArgsData.specificWhere =
                         dynamicMethodInfo.whereIndex !== undefined
-                            ? this.validateIndexedArg(args, dynamicMethodInfo.whereIndex, value => this.validator.validateWhere(value), false)
+                            ? this.validateIndexedArg(args, dynamicMethodInfo.whereIndex, value => this.validator.validateWhere(value))
                             : {};
                 }
                 return this.resolveVSRepoArgs(vsrepoResolveArgsData);
@@ -825,7 +894,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 +902,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 +914,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
@@ -867,7 +934,6 @@ class DynamicMethodsResolver {
                     return result;
                 }
                 catch (err) {
-                    // ? Deixar o catch para se quiser fazer algum tratamento antes de lançar o erro
                     this.logger.endPerformLog(start);
                     this.logger.logError(`Failed to run dynamic method '${String(originalKey)}' (-> ${dynamicMethodInfo.method})`, err);
                     throw err;
@@ -883,7 +949,7 @@ class DynamicMethodsResolver {
             const originalKey = method.propertyKey;
             const modifyingQueryMethod = method.modifying ?? false;
             const valueQueryMethod = method.value;
-            const singleResult = method.singleResult;
+            const singleResult = method.singleResult ?? false;
             const spreadArgsMode = method.spreadArgs;
             instance[originalKey] = async (...args) => {
                 let db;
@@ -909,11 +975,24 @@ class DynamicMethodsResolver {
                     queryArgs = queryArgValidated.args;
                 }
                 db ??= this.adapter.getDbClient();
+                let finalQuery = valueQueryMethod;
+                let finalArgs = queryArgs;
+                if (this.vsPlaceholders) {
+                    const compiled = vs_placeholder_parser_util_1.VSPlaceholdersParser.parse(valueQueryMethod, queryArgs ?? []).compile(index => this.adapter.getPlaceholder(index));
+                    finalQuery = compiled.text;
+                    finalArgs = compiled.args;
+                }
+                this.logger.logDebug(`QueryMethod '${String(originalKey)}':`, {
+                    query: finalQuery,
+                    args: finalArgs ?? [],
+                    modifying: modifyingQueryMethod,
+                    singleResult,
+                });
                 const start = this.logger.startPerformLog(`run ${String(originalKey)} (Modifying: ${modifyingQueryMethod})`);
                 try {
-                    const result = await this.adapter.query(valueQueryMethod, {
+                    const result = await this.adapter.query(finalQuery, {
                         db,
-                        args: queryArgs,
+                        args: finalArgs,
                         modifying: modifyingQueryMethod,
                     });
                     const resolved = singleResult && Array.isArray(result) ? (result[0] ?? null) : result;