vsrepo 2.6.0 → 2.7.0

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

@@ -13,21 +13,24 @@ 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;
     }
-    keywordTemplate = (keyword, allowAtTheEnd = false) => new RegExp(`${keyword}(?=[\\p{Lu}]|[^\\p{ASCII}]${allowAtTheEnd ? "|$" : ""})`, "u");
-    fieldModifiers = {
+    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),
@@ -57,12 +60,12 @@ class DynamicMethodsResolver {
         Every: this.keywordTemplate("Every", true),
         None: this.keywordTemplate("None", true),
     };
-    operators = {
+    static operators = {
         And: this.keywordTemplate("And"),
         Or: this.keywordTemplate("Or"),
         AND: this.keywordTemplate("AND"),
     };
-    customizationModifiers = {
+    static customizationModifiers = {
         Distinct: this.keywordTemplate("Distinct"),
         OrderBy: this.keywordTemplate("OrderBy"),
         PaginatedAndOrdered: /PaginatedAndOrdered$/,
@@ -75,12 +78,10 @@ class DynamicMethodsResolver {
         this.logger.logError(errorMessage);
         throw new VSRepoError_1.VSRepoError(errorMessage, vsrepo_error_type_enum_1.VSRepoErrorType.RESOLVER);
     }
-    validateIndexedArg(args, positionIndex, validate, parseDebugToString = true) {
+    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);
     }
@@ -351,49 +352,51 @@ class DynamicMethodsResolver {
     resolveDynamicMethodCustomization(dynamicMethodInfo, methodData) {
         const dynamicMethodCustomization = {};
         if (!dynamicMethodInfo.ignoreIgnoreConflicts) {
-            if (this.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.IgnoreConflicts, "");
+            if (DynamicMethodsResolver.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.IgnoreConflicts, "");
                 dynamicMethodCustomization.ignoreConflicts = true;
             }
         }
-        else if (this.customizationModifiers.IgnoreConflicts.test(dynamicMethodInfo.keyToMapReplaced)) {
+        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 (this.customizationModifiers.PaginatedAndOrdered.test(dynamicMethodInfo.keyToMapReplaced)) {
+            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(this.customizationModifiers.PaginatedAndOrdered, "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.PaginatedAndOrdered, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (this.customizationModifiers.OrderedAndPaginated.test(dynamicMethodInfo.keyToMapReplaced)) {
+            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(this.customizationModifiers.OrderedAndPaginated, "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.OrderedAndPaginated, "");
                 dynamicMethodInfo.argsCount += 2;
             }
-            else if (this.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced)) {
+            else if (DynamicMethodsResolver.customizationModifiers.Paginated.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.paginationPosition = -2;
                 dynamicMethodInfo.otherParams.push("pagination");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.Paginated, "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.Paginated, "");
                 dynamicMethodInfo.argsCount++;
             }
-            else if (this.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced)) {
+            else if (DynamicMethodsResolver.customizationModifiers.Ordered.test(dynamicMethodInfo.keyToMapReplaced)) {
                 dynamicMethodCustomization.orderPosition = -2;
                 dynamicMethodInfo.otherParams.push("order");
-                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(this.customizationModifiers.Ordered, "");
+                dynamicMethodInfo.keyToMapReplaced = dynamicMethodInfo.keyToMapReplaced.replace(DynamicMethodsResolver.customizationModifiers.Ordered, "");
                 dynamicMethodInfo.argsCount++;
             }
-            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split(this.customizationModifiers.OrderBy);
+            const keySplitedOrderBy = dynamicMethodInfo.keyToMapReplaced.split(DynamicMethodsResolver.customizationModifiers.OrderBy);
             if (keySplitedOrderBy[1]) {
-                if (this.customizationModifiers.Distinct.test(keySplitedOrderBy[1])) {
+                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(this.operators.And).map(uncapitalize_util_1.uncapitalize);
+                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$/, "");
@@ -409,21 +412,21 @@ 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)) {
+        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(this.customizationModifiers.Distinct);
+            const keySplitedDistinct = dynamicMethodInfo.keyToMapReplaced.split(DynamicMethodsResolver.customizationModifiers.Distinct);
             if (keySplitedDistinct[1]) {
                 dynamicMethodCustomization.distinctKeys = keySplitedDistinct[1]
-                    .split(this.operators.And)
+                    .split(DynamicMethodsResolver.operators.And)
                     .map(uncapitalize_util_1.uncapitalize);
             }
             dynamicMethodInfo.keyToMapReplaced = keySplitedDistinct[0];
         }
-        else if (this.customizationModifiers.Distinct.test(dynamicMethodInfo.keyToMapReplaced)) {
+        else if (DynamicMethodsResolver.customizationModifiers.Distinct.test(dynamicMethodInfo.keyToMapReplaced)) {
             this.logAndThrowError(`This dynamic method prefix doesn't support the "Distinct" modifier: ${dynamicMethodInfo.originalDynamicMethodName}.`);
         }
         return dynamicMethodCustomization;
@@ -431,113 +434,113 @@ class DynamicMethodsResolver {
     resolveUglyWhere(keySplitedAnd) {
         const uglyWhere = { name: "", pushProperty: "$$$" };
         let nullMode = undefined;
-        if (this.fieldModifiers.IsNull.test(keySplitedAnd)) {
+        if (DynamicMethodsResolver.fieldModifiers.IsNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = null;
             nullMode = "is";
-            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsNull, "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsNull, "");
         }
-        else if (this.fieldModifiers.IsNotNull.test(keySplitedAnd)) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsNotNull.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "not";
             uglyWhere.autoInjectVal = null;
             nullMode = "not";
-            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsNotNull, "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsNotNull, "");
         }
-        else if (this.fieldModifiers.IsTrue.test(keySplitedAnd)) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsTrue.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = true;
-            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsTrue, "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsTrue, "");
         }
-        else if (this.fieldModifiers.IsFalse.test(keySplitedAnd)) {
+        else if (DynamicMethodsResolver.fieldModifiers.IsFalse.test(keySplitedAnd)) {
             uglyWhere.pushProperty = "$$$";
             uglyWhere.autoInjectVal = false;
-            keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IsFalse, "");
+            keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IsFalse, "");
         }
         else {
-            if (this.fieldModifiers.IgnoreCase.test(keySplitedAnd)) {
+            if (DynamicMethodsResolver.fieldModifiers.IgnoreCase.test(keySplitedAnd)) {
                 uglyWhere.properties = {};
                 uglyWhere.properties.ignoreCase = true;
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.IgnoreCase, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.IgnoreCase, "");
             }
-            if (this.fieldModifiers.Optional.test(keySplitedAnd)) {
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Optional, "");
+            if (DynamicMethodsResolver.fieldModifiers.Optional.test(keySplitedAnd)) {
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Optional, "");
             }
-            if (this.fieldModifiers.NotBetween.test(keySplitedAnd)) {
+            if (DynamicMethodsResolver.fieldModifiers.NotBetween.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotBetween, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotBetween, "");
             }
-            else if (this.fieldModifiers.Between.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.Between.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "$$$";
                 uglyWhere.betweenMode = true;
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Between, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Between, "");
             }
-            else if (this.fieldModifiers.NotStartsWith.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotStartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.startsWith";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotStartsWith, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotStartsWith, "");
             }
-            else if (this.fieldModifiers.StartsWith.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.StartsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "startsWith";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.StartsWith, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.StartsWith, "");
             }
-            else if (this.fieldModifiers.NotEndsWith.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotEndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.endsWith";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotEndsWith, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotEndsWith, "");
             }
-            else if (this.fieldModifiers.EndsWith.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.EndsWith.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "endsWith";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.EndsWith, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.EndsWith, "");
             }
-            else if (this.fieldModifiers.NotContains.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotContains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not.contains";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotContains, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotContains, "");
             }
-            else if (this.fieldModifiers.Contains.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.Contains.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "contains";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Contains, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Contains, "");
             }
-            else if (this.fieldModifiers.NotEquals.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotEquals.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotEquals, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotEquals, "");
             }
-            else if (this.fieldModifiers.Equals.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.Equals.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "$$$";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Equals, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Equals, "");
             }
-            else if (this.fieldModifiers.LessThanEqual.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.LessThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lte";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.LessThanEqual, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.LessThanEqual, "");
             }
-            else if (this.fieldModifiers.LessThan.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.LessThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "lt";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.LessThan, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.LessThan, "");
             }
-            else if (this.fieldModifiers.GreaterThanEqual.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.GreaterThanEqual.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gte";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.GreaterThanEqual, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.GreaterThanEqual, "");
             }
-            else if (this.fieldModifiers.GreaterThan.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.GreaterThan.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "gt";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.GreaterThan, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.GreaterThan, "");
             }
-            else if (this.fieldModifiers.NotIn.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.NotIn.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "notIn";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.NotIn, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.NotIn, "");
             }
-            else if (this.fieldModifiers.In.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.In.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "in";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.In, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.In, "");
             }
-            else if (this.fieldModifiers.Not.test(keySplitedAnd)) {
+            else if (DynamicMethodsResolver.fieldModifiers.Not.test(keySplitedAnd)) {
                 uglyWhere.pushProperty = "not";
-                keySplitedAnd = keySplitedAnd.replace(this.fieldModifiers.Not, "");
+                keySplitedAnd = keySplitedAnd.replace(DynamicMethodsResolver.fieldModifiers.Not, "");
             }
             else {
                 uglyWhere.pushProperty = "$$$";
             }
         }
-        if (this.fieldModifiers.Without.test(keySplitedAnd)) {
-            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Without);
+        if (DynamicMethodsResolver.fieldModifiers.Without.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.Without);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -553,8 +556,8 @@ class DynamicMethodsResolver {
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (this.fieldModifiers.With.test(keySplitedAnd)) {
-            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.With);
+        else if (DynamicMethodsResolver.fieldModifiers.With.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.With);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 if (nullMode) {
@@ -570,8 +573,8 @@ class DynamicMethodsResolver {
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (this.fieldModifiers.Some.test(keySplitedAnd)) {
-            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Some);
+        else if (DynamicMethodsResolver.fieldModifiers.Some.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.Some);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_some";
@@ -582,8 +585,8 @@ class DynamicMethodsResolver {
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (this.fieldModifiers.Every.test(keySplitedAnd)) {
-            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.Every);
+        else if (DynamicMethodsResolver.fieldModifiers.Every.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.Every);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_every";
@@ -594,8 +597,8 @@ class DynamicMethodsResolver {
             }
             keySplitedAnd = keySplitedConector[0];
         }
-        else if (this.fieldModifiers.None.test(keySplitedAnd)) {
-            const keySplitedConector = keySplitedAnd.split(this.fieldModifiers.None);
+        else if (DynamicMethodsResolver.fieldModifiers.None.test(keySplitedAnd)) {
+            const keySplitedConector = keySplitedAnd.split(DynamicMethodsResolver.fieldModifiers.None);
             const specificField = keySplitedConector[1];
             if (!specificField) {
                 uglyWhere.pushProperty = "_none";
@@ -616,7 +619,7 @@ class DynamicMethodsResolver {
             prettyWheres: [],
         };
         let ANDMode = false;
-        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split(this.operators.AND);
+        let keysSplitedAND = dynamicMethodInfo.keyToMapReplaced.split(DynamicMethodsResolver.operators.AND);
         if (keysSplitedAND.length > 1) {
             ANDMode = true;
         }
@@ -624,10 +627,10 @@ class DynamicMethodsResolver {
             let orMode = false;
             let keysSplitedOr;
             if (idx === 0) {
-                keysSplitedOr = keySplitedAND.split(this.operators.Or);
+                keysSplitedOr = keySplitedAND.split(DynamicMethodsResolver.operators.Or);
             }
             else {
-                if (this.operators.Or.test(keySplitedAND)) {
+                if (DynamicMethodsResolver.operators.Or.test(keySplitedAND)) {
                     this.logAndThrowError(`The logical operator "Or" cannot appear after an "AND" (all caps): ${dynamicMethodInfo.originalDynamicMethodName}.`);
                 }
                 keysSplitedOr = [keySplitedAND];
@@ -638,7 +641,7 @@ class DynamicMethodsResolver {
             for (let i = 0; i < keysSplitedOr.length; i++) {
                 if (keysSplitedOr[i] === "")
                     continue;
-                const keysSplitedAnd = keysSplitedOr[i].split(this.operators.And);
+                const keysSplitedAnd = keysSplitedOr[i].split(DynamicMethodsResolver.operators.And);
                 for (const keySplitedAnd of keysSplitedAnd) {
                     if (keySplitedAnd === "")
                         continue;
@@ -714,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) {
@@ -881,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);
@@ -932,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;
@@ -948,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;
@@ -974,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;