axiodb 21.7.8 → 22.2.0

package/lib/Helper/Console.helper.js

@@ -20,4 +20,3 @@ class Console {
     }
 }
 exports.default = Console;
-//# sourceMappingURL=Console.helper.js.map

package/lib/Helper/Converter.helper.js

@@ -22,4 +22,3 @@ class Converter {
     }
 }
 exports.default = Converter;
-//# sourceMappingURL=Converter.helper.js.map

package/lib/Helper/DocumentLoader.helper.js

@@ -51,4 +51,3 @@ class DocumentLoader {
 }
 DocumentLoader.ResponseHelper = new response_helper_1.default();
 exports.default = DocumentLoader;
-//# sourceMappingURL=DocumentLoader.helper.js.map

package/lib/Helper/Logger.helper.js

@@ -42,4 +42,3 @@ class Logger {
     }
 }
 exports.default = Logger;
-//# sourceMappingURL=Logger.helper.js.map

package/lib/Helper/PathSanitizer.helper.js

@@ -104,4 +104,3 @@ class PathSanitizer {
     }
 }
 exports.default = PathSanitizer;
-//# sourceMappingURL=PathSanitizer.helper.js.map

package/lib/Helper/RegexGuard.helper.d.ts

@@ -0,0 +1,85 @@
+/**
+ * RegexGuard - Static ReDoS guard for user-supplied regex patterns.
+ *
+ * Rejects patterns that are too long, contain nested unbounded quantifiers
+ * (`(a+)+`), or have overlapping alternation branches inside an unboundedly
+ * quantified group (`(a|aa)+`). Bounded quantifiers like `{2,9}` are allowed.
+ *
+ * @class RegexGuard
+ * @example
+ * const safe = RegexGuard.compileRegex("(a+)b", "");
+ * const guarded = RegexGuard.compileRegex("(a+)+$", ""); // throws
+ */
+export default class RegexGuard {
+    /** Upper bound on pattern length. */
+    static readonly MAX_PATTERN_LENGTH = 512;
+    /**
+     * Compiles a user-supplied pattern into a RegExp after proving it is safe.
+     * @param pattern - The regex source to compile.
+     * @param flags - Optional regex flags (e.g. "i").
+     * @returns A compiled RegExp.
+     * @throws Error if the pattern is empty, too long, or prone to catastrophic backtracking.
+     */
+    static compileRegex(pattern: string, flags?: string): RegExp;
+    /**
+     * Returns true when the pattern does not contain the catastrophic
+     * nested-quantifier shape. Pure check - callers decide what to do.
+     * @param pattern - The regex source to inspect.
+     * @returns true if the pattern is considered safe, false otherwise.
+     */
+    static isSafePattern(pattern: string): boolean;
+    /**
+     * Static scan for the catastrophic-backtracking shape.
+     *
+     * Two classes are rejected:
+     *  1. Nested unbounded quantifiers: a group that contains an internally
+     *     quantified atom and is itself unboundedly quantified, e.g. `(a+)+`.
+     *  2. Overlapping alternation inside an unboundedly quantified group: two
+     *     branches where one is a strict prefix of another, e.g. `(a|aa)+` -
+     *     the parser cannot decide where a branch ends, causing exponential work.
+     *
+     * @param pattern - The regex source to inspect.
+     * @throws Error describing the dangerous construct when detected.
+     */
+    static assertSafePattern(pattern: string): void;
+    /**
+     * Splits a group body on top-level alternation operators and reports whether
+     * any two branches overlap, i.e. one is a strict prefix of another. Branch
+     * overlap on an unboundedly quantified group is what produces exponential
+     * backtracking in patterns like `(a|aa)+`.
+     * @param body - The characters between a group's '(' and ')'.
+     * @returns true when an overlapping branch pair is found.
+     */
+    private static hasOverlappingAlternation;
+    /**
+     * Strips the special group marker (`?:`, `?=`, `?!`, `?<=`, `?<!`, `?<name>`)
+     * from a group body so branch analysis sees the actual alternation content.
+     * @param body - The raw text between '(' and ')'.
+     * @returns The body without its leading marker, if one was present.
+     */
+    private static stripGroupMarker;
+    /**
+     * Splits a group body on '|' operators that are not nested inside a
+     * sub-group or character class.
+     * @param body - The group's raw body text.
+     * @returns The top-level alternation branches (at least one element).
+     */
+    private static splitTopLevel;
+    /**
+     * Determines what kind of quantifier (if any) follows a closing parenthesis.
+     * @param pattern - The full regex source.
+     * @param closeIndex - Index of the ')' that just closed a group.
+     * @returns "none" when no quantifier follows, "unbounded" for `*`, `+`, or an
+     *          open-ended `{n,}` range, otherwise "bounded".
+     */
+    private static peekGroupQuantifier;
+    /**
+     * Parses a `{...}` quantifier starting at the given index.
+     * @param pattern - The full regex source.
+     * @param openIndex - Index of the '{'.
+     * @returns true for an unbounded `{n,}` range, false for a bounded `{n}` or
+     *          `{n,m}`, and null when the character is not actually a quantifier
+     *          (e.g. a literal brace inside a larger construct).
+     */
+    private static isUnboundedRange;
+}

package/lib/Helper/RegexGuard.helper.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * RegexGuard - Static ReDoS guard for user-supplied regex patterns.
+ *
+ * Rejects patterns that are too long, contain nested unbounded quantifiers
+ * (`(a+)+`), or have overlapping alternation branches inside an unboundedly
+ * quantified group (`(a|aa)+`). Bounded quantifiers like `{2,9}` are allowed.
+ *
+ * @class RegexGuard
+ * @example
+ * const safe = RegexGuard.compileRegex("(a+)b", "");
+ * const guarded = RegexGuard.compileRegex("(a+)+$", ""); // throws
+ */
+class RegexGuard {
+    /**
+     * Compiles a user-supplied pattern into a RegExp after proving it is safe.
+     * @param pattern - The regex source to compile.
+     * @param flags - Optional regex flags (e.g. "i").
+     * @returns A compiled RegExp.
+     * @throws Error if the pattern is empty, too long, or prone to catastrophic backtracking.
+     */
+    static compileRegex(pattern, flags) {
+        if (!pattern || typeof pattern !== "string") {
+            throw new Error("Invalid regex pattern: must be a non-empty string");
+        }
+        if (pattern.length > this.MAX_PATTERN_LENGTH) {
+            throw new Error(`Regex pattern exceeds maximum length of ${this.MAX_PATTERN_LENGTH}`);
+        }
+        this.assertSafePattern(pattern);
+        return new RegExp(pattern, flags || "");
+    }
+    /**
+     * Returns true when the pattern does not contain the catastrophic
+     * nested-quantifier shape. Pure check - callers decide what to do.
+     * @param pattern - The regex source to inspect.
+     * @returns true if the pattern is considered safe, false otherwise.
+     */
+    static isSafePattern(pattern) {
+        try {
+            this.assertSafePattern(pattern);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Static scan for the catastrophic-backtracking shape.
+     *
+     * Two classes are rejected:
+     *  1. Nested unbounded quantifiers: a group that contains an internally
+     *     quantified atom and is itself unboundedly quantified, e.g. `(a+)+`.
+     *  2. Overlapping alternation inside an unboundedly quantified group: two
+     *     branches where one is a strict prefix of another, e.g. `(a|aa)+` -
+     *     the parser cannot decide where a branch ends, causing exponential work.
+     *
+     * @param pattern - The regex source to inspect.
+     * @throws Error describing the dangerous construct when detected.
+     */
+    static assertSafePattern(pattern) {
+        let inClass = false;
+        let escaped = false;
+        // Stack of currently-open groups; each tracks whether it contains an
+        // internally quantified atom and where it opened (for branch analysis).
+        const groups = [];
+        for (let i = 0; i < pattern.length; i++) {
+            const c = pattern[i];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (c === "\\") {
+                escaped = true;
+                continue;
+            }
+            // Inside a character class like [abc+]: '+' is a literal there, not a quantifier.
+            if (inClass) {
+                if (c === "]")
+                    inClass = false;
+                continue;
+            }
+            if (c === "[") {
+                inClass = true;
+                continue;
+            }
+            if (c === "(") {
+                groups.push({ openIndex: i, hasQuantifiedAtom: false });
+                continue;
+            }
+            if (c === ")") {
+                const group = groups.pop();
+                if (!group)
+                    continue;
+                const quantifier = this.peekGroupQuantifier(pattern, i);
+                const isUnbounded = quantifier === "unbounded";
+                if (isUnbounded) {
+                    if (group.hasQuantifiedAtom) {
+                        throw new Error("Regex pattern rejected: contains nested quantifiers that can cause catastrophic backtracking");
+                    }
+                    const body = pattern.slice(group.openIndex + 1, i);
+                    if (this.hasOverlappingAlternation(this.stripGroupMarker(body))) {
+                        throw new Error("Regex pattern rejected: quantified alternation with overlapping branches can cause catastrophic backtracking");
+                    }
+                }
+                // A quantified group, or a group containing quantified atoms, is itself
+                // a quantified atom to its parent group.
+                const isQuantifiedAtom = group.hasQuantifiedAtom || isUnbounded;
+                if (isQuantifiedAtom && groups.length > 0) {
+                    groups[groups.length - 1].hasQuantifiedAtom = true;
+                }
+                continue;
+            }
+            // Track unbounded quantifiers (+ or * or {n,}): the atom before them is a
+            // quantified atom. '?' is deliberately excluded - a single optional atom
+            // cannot blow up on its own. `{m}` bounded and `{m,n}` bounded are also excluded.
+            let isUnbounded = false;
+            if (c === "+" || c === "*") {
+                isUnbounded = true;
+            }
+            else if (c === "{") {
+                isUnbounded = this.isUnboundedRange(pattern, i) === true;
+            }
+            if (isUnbounded && groups.length > 0) {
+                groups[groups.length - 1].hasQuantifiedAtom = true;
+            }
+        }
+    }
+    /**
+     * Splits a group body on top-level alternation operators and reports whether
+     * any two branches overlap, i.e. one is a strict prefix of another. Branch
+     * overlap on an unboundedly quantified group is what produces exponential
+     * backtracking in patterns like `(a|aa)+`.
+     * @param body - The characters between a group's '(' and ')'.
+     * @returns true when an overlapping branch pair is found.
+     */
+    static hasOverlappingAlternation(body) {
+        const branches = this.splitTopLevel(body);
+        if (branches.length < 2)
+            return false;
+        for (let i = 0; i < branches.length; i++) {
+            for (let j = 0; j < branches.length; j++) {
+                if (i === j)
+                    continue;
+                const a = branches[i];
+                const b = branches[j];
+                // An empty branch can match zero width, so no line is consumed - the
+                // classic `(|x)+` / `(a|)+` ambiguity.
+                if (a === "" || b === "")
+                    return true;
+                if (b.length > a.length && b.startsWith(a))
+                    return true;
+                if (a.length > b.length && a.startsWith(b))
+                    return true;
+                if (a === b)
+                    return true; // duplicate branches are always ambiguous
+            }
+        }
+        return false;
+    }
+    /**
+     * Strips the special group marker (`?:`, `?=`, `?!`, `?<=`, `?<!`, `?<name>`)
+     * from a group body so branch analysis sees the actual alternation content.
+     * @param body - The raw text between '(' and ')'.
+     * @returns The body without its leading marker, if one was present.
+     */
+    static stripGroupMarker(body) {
+        if (body[0] === "?" && body[1] === "<") {
+            const close = body.indexOf(">");
+            return close >= 0 ? body.slice(close + 1) : body;
+        }
+        if (body[0] === "?" && (body[1] === ":" || body[1] === "=" || body[1] === "!")) {
+            return body.slice(2);
+        }
+        return body;
+    }
+    /**
+     * Splits a group body on '|' operators that are not nested inside a
+     * sub-group or character class.
+     * @param body - The group's raw body text.
+     * @returns The top-level alternation branches (at least one element).
+     */
+    static splitTopLevel(body) {
+        const branches = [];
+        let depth = 0;
+        let inClass = false;
+        let escaped = false;
+        let current = "";
+        for (const c of body) {
+            if (escaped) {
+                escaped = false;
+                current += c;
+                continue;
+            }
+            if (c === "\\") {
+                escaped = true;
+                current += c;
+                continue;
+            }
+            if (inClass) {
+                current += c;
+                if (c === "]")
+                    inClass = false;
+                continue;
+            }
+            if (c === "[") {
+                inClass = true;
+                current += c;
+                continue;
+            }
+            if (c === "(") {
+                depth++;
+                current += c;
+                continue;
+            }
+            if (c === ")") {
+                depth--;
+                current += c;
+                continue;
+            }
+            if (c === "|" && depth === 0) {
+                branches.push(current);
+                current = "";
+                continue;
+            }
+            current += c;
+        }
+        branches.push(current);
+        return branches;
+    }
+    /**
+     * Determines what kind of quantifier (if any) follows a closing parenthesis.
+     * @param pattern - The full regex source.
+     * @param closeIndex - Index of the ')' that just closed a group.
+     * @returns "none" when no quantifier follows, "unbounded" for `*`, `+`, or an
+     *          open-ended `{n,}` range, otherwise "bounded".
+     */
+    static peekGroupQuantifier(pattern, closeIndex) {
+        const next = pattern[closeIndex + 1];
+        if (next === "*" || next === "+")
+            return "unbounded";
+        if (next === "{") {
+            const bounded = this.isUnboundedRange(pattern, closeIndex + 1);
+            return bounded === true ? "unbounded" : bounded === false ? "bounded" : "none";
+        }
+        if (next === "?")
+            return "bounded";
+        return "none";
+    }
+    /**
+     * Parses a `{...}` quantifier starting at the given index.
+     * @param pattern - The full regex source.
+     * @param openIndex - Index of the '{'.
+     * @returns true for an unbounded `{n,}` range, false for a bounded `{n}` or
+     *          `{n,m}`, and null when the character is not actually a quantifier
+     *          (e.g. a literal brace inside a larger construct).
+     */
+    static isUnboundedRange(pattern, openIndex) {
+        let closeIndex = openIndex + 1;
+        while (closeIndex < pattern.length && pattern[closeIndex] !== "}") {
+            closeIndex++;
+        }
+        if (closeIndex >= pattern.length)
+            return null;
+        const body = pattern.slice(openIndex + 1, closeIndex);
+        if (/^\d+$/.test(body))
+            return false;
+        if (/^\d+,\d+$/.test(body))
+            return false;
+        if (/^\d+,$/.test(body))
+            return true;
+        return null;
+    }
+}
+/** Upper bound on pattern length. */
+RegexGuard.MAX_PATTERN_LENGTH = 512;
+exports.default = RegexGuard;

package/lib/Helper/SafeErrorMessage.helper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SafeErrorMessage - Redacts filesystem paths and internal details from error
+ * messages before they are returned to remote clients.
+ * @class SafeErrorMessage
+ * @example
+ * SafeErrorMessage.sanitize(new Error("open '/home/user/db'"));
+ * // 'open <path>'
+ */
+export default class SafeErrorMessage {
+    static readonly MAX_MESSAGE_LENGTH = 300;
+    static readonly FALLBACK_MESSAGE = "An internal error occurred. Please try again later.";
+    /**
+     * Sanitizes an error for transmission to a remote client.
+     * @param error - The caught error (may be any unknown).
+     * @returns A single-line, path-redacted message with a bounded length.
+     */
+    static sanitize(error: unknown): string;
+}

package/lib/Helper/SafeErrorMessage.helper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * SafeErrorMessage - Redacts filesystem paths and internal details from error
+ * messages before they are returned to remote clients.
+ * @class SafeErrorMessage
+ * @example
+ * SafeErrorMessage.sanitize(new Error("open '/home/user/db'"));
+ * // 'open <path>'
+ */
+class SafeErrorMessage {
+    /**
+     * Sanitizes an error for transmission to a remote client.
+     * @param error - The caught error (may be any unknown).
+     * @returns A single-line, path-redacted message with a bounded length.
+     */
+    static sanitize(error) {
+        const raw = error instanceof Error
+            ? error.message
+            : typeof error === "string"
+                ? error
+                : error !== undefined
+                    ? String(error)
+                    : "";
+        let message = raw;
+        message = message.replace(/[a-zA-Z]:\\[^\s"'`]+/g, "<path>");
+        message = message.replace(/(^|[\s(['"`])[\/][^\s"'`]+/g, "$1<path>");
+        message = message.replace(/(^|[\s(['"`])(?:\.\.?(?:[\/\\]|$))[^\s"'`]*/g, "$1<path>");
+        message = message.replace(/['"`]\s*<path>\s*['"`]/g, "<path>");
+        message = message.replace(/\r?\n/g, " | ").replace(/\s{2,}/g, " ").trim();
+        if (!message || message === "<path>")
+            return this.FALLBACK_MESSAGE;
+        if (message.length > this.MAX_MESSAGE_LENGTH) {
+            message = message.slice(0, this.MAX_MESSAGE_LENGTH - 3) + "...";
+        }
+        return message;
+    }
+}
+SafeErrorMessage.MAX_MESSAGE_LENGTH = 300;
+SafeErrorMessage.FALLBACK_MESSAGE = "An internal error occurred. Please try again later.";
+exports.default = SafeErrorMessage;

package/lib/Helper/SortedIndexValues.helper.js

@@ -102,4 +102,3 @@ class SortedIndexValues {
     }
 }
 exports.default = SortedIndexValues;
-//# sourceMappingURL=SortedIndexValues.helper.js.map

package/lib/Helper/UniqueGenerator.helper.js

@@ -25,4 +25,3 @@ class UniqueGenerator {
     }
 }
 exports.default = UniqueGenerator;
-//# sourceMappingURL=UniqueGenerator.helper.js.map

package/lib/Helper/response.helper.js

@@ -46,4 +46,3 @@ class ResponseHelper {
     }
 }
 exports.default = ResponseHelper;
-//# sourceMappingURL=response.helper.js.map

package/lib/Memory/memory.operation.js

@@ -293,4 +293,3 @@ class InMemoryCache {
     }
 }
 exports.InMemoryCache = InMemoryCache;
-//# sourceMappingURL=memory.operation.js.map

package/lib/Services/Aggregation/Aggregation.Operation.js

@@ -102,4 +102,3 @@ class Aggregation {
     }
 }
 exports.default = Aggregation;
-//# sourceMappingURL=Aggregation.Operation.js.map

package/lib/Services/Aggregation/OperatorRegistry.js

@@ -32,4 +32,3 @@ class OperatorRegistry {
 }
 exports.OperatorRegistry = OperatorRegistry;
 OperatorRegistry.operators = new Map();
-//# sourceMappingURL=OperatorRegistry.js.map

package/lib/Services/Aggregation/operators/accumulatorOperators.js

@@ -134,4 +134,3 @@ exports.BUILT_IN_ACCUMULATORS = {
     $stdDevSamp: accumulatorStdDevSamp,
     $count: accumulatorCount,
 };
-//# sourceMappingURL=accumulatorOperators.js.map

package/lib/Services/Aggregation/operators/expressionOperators.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNestedValue = getNestedValue;
 exports.setNestedValue = setNestedValue;
 exports.evaluateExpression = evaluateExpression;
+const RegexGuard_helper_1 = __importDefault(require("../../../Helper/RegexGuard.helper"));
 function getNestedValue(obj, path) {
     if (!path || !obj)
         return undefined;
@@ -153,7 +157,7 @@ function evaluateExpression(doc, expr) {
         case "$regexMatch": {
             const input = exprObj.$regexMatch;
             const str = String(evaluateExpression(doc, input.input));
-            const regex = new RegExp(input.regex, input.options || "");
+            const regex = RegexGuard_helper_1.default.compileRegex(input.regex, input.options || "");
             return regex.test(str);
         }
         case "$cmp": {
@@ -587,4 +591,3 @@ function convertType(value, to) {
         default: return value;
     }
 }
-//# sourceMappingURL=expressionOperators.js.map

package/lib/Services/Aggregation/operators/stageOperators.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILT_IN_STAGE_OPERATORS = void 0;
 exports.executeMatch = executeMatch;
@@ -32,6 +35,7 @@ exports.executeMergeObjects = executeMergeObjects;
 const expressionOperators_1 = require("./expressionOperators");
 const accumulatorOperators_1 = require("./accumulatorOperators");
 const OperatorRegistry_1 = require("../OperatorRegistry");
+const RegexGuard_helper_1 = __importDefault(require("../../../Helper/RegexGuard.helper"));
 function matchesCondition(itemValue, condition) {
     if (condition === null || condition === undefined) {
         return itemValue === null || itemValue === undefined;
@@ -44,7 +48,7 @@ function matchesCondition(itemValue, condition) {
     if (typeof condition === "object") {
         if ("$regex" in condition) {
             try {
-                return new RegExp(String(condition.$regex), condition.$options || "").test(String(itemValue));
+                return RegexGuard_helper_1.default.compileRegex(String(condition.$regex), condition.$options || "").test(String(itemValue));
             }
             catch (_a) {
                 return false;
@@ -561,4 +565,3 @@ exports.BUILT_IN_STAGE_OPERATORS = {
     $replaceRoot: executeReplaceRoot,
     $replaceWith: executeReplaceRoot,
 };
-//# sourceMappingURL=stageOperators.js.map

package/lib/Services/Auth/AuthEvents.service.js

@@ -14,4 +14,3 @@ const events_1 = require("events");
 class AuthEvents extends events_1.EventEmitter {
 }
 exports.default = new AuthEvents();
-//# sourceMappingURL=AuthEvents.service.js.map

package/lib/Services/Auth/AuthSeeder.service.js

@@ -95,4 +95,3 @@ class AuthSeeder {
     }
 }
 exports.default = AuthSeeder;
-//# sourceMappingURL=AuthSeeder.service.js.map

package/lib/Services/Auth/AuthService.service.js

@@ -263,4 +263,3 @@ class AuthService {
     }
 }
 exports.default = AuthService;
-//# sourceMappingURL=AuthService.service.js.map

package/lib/Services/Auth/ConfigDatabase.service.js

@@ -44,4 +44,3 @@ class ConfigDatabase {
     }
 }
 exports.default = ConfigDatabase.getInstance();
-//# sourceMappingURL=ConfigDatabase.service.js.map

package/lib/Services/Auth/CookieCodec.helper.js

@@ -27,4 +27,3 @@ class CookieCodec {
     }
 }
 exports.default = CookieCodec;
-//# sourceMappingURL=CookieCodec.helper.js.map

package/lib/Services/Auth/LoginRateLimiter.service.js

@@ -86,4 +86,3 @@ class LoginRateLimiter {
     }
 }
 exports.default = LoginRateLimiter.getInstance();
-//# sourceMappingURL=LoginRateLimiter.service.js.map

package/lib/Services/Auth/PasswordHasher.helper.js

@@ -51,4 +51,3 @@ class PasswordHasher {
     }
 }
 exports.default = PasswordHasher;
-//# sourceMappingURL=PasswordHasher.helper.js.map

package/lib/Services/Auth/PermissionChecker.helper.js

@@ -41,4 +41,3 @@ class PermissionChecker {
     }
 }
 exports.default = PermissionChecker.getInstance();
-//# sourceMappingURL=PermissionChecker.helper.js.map

package/lib/Services/Auth/SessionStore.service.js

@@ -93,4 +93,3 @@ class SessionStore {
     }
 }
 exports.default = SessionStore.getInstance();
-//# sourceMappingURL=SessionStore.service.js.map

package/lib/Services/CRUD Operation/Create.operation.js

@@ -92,4 +92,3 @@ class Insertion {
     }
 }
 exports.default = Insertion;
-//# sourceMappingURL=Create.operation.js.map

package/lib/Services/CRUD Operation/Delete.operation.js

@@ -185,4 +185,3 @@ class DeleteOperation {
     }
 }
 exports.default = DeleteOperation;
-//# sourceMappingURL=Delete.operation.js.map

package/lib/Services/CRUD Operation/Reader.operation.js

@@ -475,4 +475,3 @@ class Reader {
     }
 }
 exports.default = Reader;
-//# sourceMappingURL=Reader.operation.js.map

package/lib/Services/CRUD Operation/Update.operation.js

@@ -202,4 +202,3 @@ class UpdateOperation {
     }
 }
 exports.default = UpdateOperation;
-//# sourceMappingURL=Update.operation.js.map

package/lib/Services/Collection/collection.operation.js

@@ -314,4 +314,3 @@ class Collection {
     }
 }
 exports.default = Collection;
-//# sourceMappingURL=collection.operation.js.map