@r5v/mongoose-paginate 1.0.0

package/dist/tests/parseSortString.spec.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const parseSortString_1 = require("../utils/parseSortString");
+describe('sortParser', () => {
+    const testInputs = [
+        "",
+        "name",
+        "name 1",
+        "name -1",
+        "name asc",
+        "name desc",
+        "name, address",
+        "name, address 1",
+        "name -1, address 1",
+        "name -1, address desc",
+        "name asc, address desc",
+    ];
+    it('should return empty array', () => {
+        const fun = (0, parseSortString_1.parseSortString)("");
+        (0, strict_1.default)(Array.isArray(fun));
+        (0, strict_1.default)(fun.length === 0);
+    });
+    it('should return sort value of -1', () => {
+        const fun = (0, parseSortString_1.parseSortString)("name -1");
+        (0, strict_1.default)(Array.isArray(fun));
+        (0, strict_1.default)(Array.length > 0);
+        const [r1] = fun;
+        strict_1.default.strictEqual(r1[1], -1, 'sortstring is not returning a negative value');
+    });
+    testInputs.forEach((value) => {
+        it('should return a 2d matrix', () => {
+            const fun = (0, parseSortString_1.parseSortString)(value);
+            (0, strict_1.default)(Array.isArray(fun));
+            (0, strict_1.default)(Array.length > 0);
+            (0, strict_1.default)(fun.every(item => Array.isArray(item)));
+        });
+        it('should return sub arrays with length of 2', () => {
+            const fun = (0, parseSortString_1.parseSortString)(value);
+            (0, strict_1.default)(Array.isArray(fun));
+            (0, strict_1.default)(Array.length > 0);
+            (0, strict_1.default)(fun.every(item => Array.isArray(item) && item.length === 2), 'Every Item in sub arrays must have a length of 2');
+        });
+        it('should return sub arrays that have name:sortOrder', () => {
+            const fun = (0, parseSortString_1.parseSortString)(value);
+            (0, strict_1.default)(Array.isArray(fun));
+            (0, strict_1.default)(Array.length > 0);
+            (0, strict_1.default)(fun.every(item => {
+                return typeof item[0] === 'string';
+            }), 'Every Item in sub arrays must be a string');
+            (0, strict_1.default)(fun.every(item => {
+                return [-1, 1, 'asc', 'desc'].includes(item[1]);
+            }), 'Every Item in sub arrays must be one of `-1, 1, asc, desc`');
+        });
+    });
+});

package/dist/utils/dotNotation.d.ts

@@ -0,0 +1,10 @@
+export declare const getPropertyFromDotNotation: (obj: any, path: string) => any;
+export declare const dotNotationToObject: (dotString: any, value?: any) => {};
+export declare const createObjectFromDotNotation: (dotNotationMap: {
+    [key: string]: any;
+}) => {};
+export declare const setPropertyFromDotNotation: (obj: any, path: any, value: any) => any;
+export declare const setPropertiesFromDotNotation: (obj: any, dotNotationMap: any) => any;
+export declare const setPropertyFromDotNotationImmutable: (obj: any, path: any, value: any) => any;
+export declare const setPropertiesFromDotNotationImmutable: (obj: any, dotNotationMap: any) => any;
+//# sourceMappingURL=dotNotation.d.ts.map

package/dist/utils/dotNotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotNotation.d.ts","sourceRoot":"","sources":["../../src/utils/dotNotation.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,GAAI,KAAI,GAAG,EAAE,MAAK,MAAM,QAI9D,CAAA;AACD,eAAO,MAAM,mBAAmB,GAAI,cAAS,EAAE,QAAM,GAAU,OAoB9D,CAAA;AAGD,eAAO,MAAO,2BAA2B,GAAI,gBAAe;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAA;CAAC,OAwB7E,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,QAAG,EAAE,SAAI,EAAE,UAAK,QA4B1D,CAAC;AAGF,eAAO,MAAM,4BAA4B,GAAI,QAAG,EAAE,mBAAc,QAc/D,CAAC;AAGF,eAAO,MAAM,mCAAmC,GAAI,QAAG,EAAE,SAAI,EAAE,UAAK,QA6BnE,CAAC;AAGF,eAAO,MAAM,qCAAqC,GAAI,QAAG,EAAE,mBAAc,QAgBxE,CAAC"}

package/dist/utils/dotNotation.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPropertiesFromDotNotationImmutable = exports.setPropertyFromDotNotationImmutable = exports.setPropertiesFromDotNotation = exports.setPropertyFromDotNotation = exports.createObjectFromDotNotation = exports.dotNotationToObject = exports.getPropertyFromDotNotation = void 0;
+const getPropertyFromDotNotation = (obj, path) => {
+    return path.split('.').reduce((currentObject, key) => {
+        return currentObject && currentObject[key];
+    }, obj);
+};
+exports.getPropertyFromDotNotation = getPropertyFromDotNotation;
+const dotNotationToObject = (dotString, value = null) => {
+    const keys = dotString.split('.');
+    const result = {};
+    let current = result;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (i === keys.length - 1) {
+            // Last key, assign the value
+            current[key] = value;
+        }
+        else {
+            // Not the last key, create nested object
+            current[key] = {};
+            current = current[key];
+        }
+    }
+    return result;
+};
+exports.dotNotationToObject = dotNotationToObject;
+const createObjectFromDotNotation = (dotNotationMap) => {
+    const result = {};
+    for (const [dotString, value] of Object.entries(dotNotationMap)) {
+        const keys = dotString.split('.');
+        let current = result;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (i === keys.length - 1) {
+                // Last key, assign the value
+                current[key] = value;
+            }
+            else {
+                // Not the last key, create nested object if it doesn't exist
+                if (!current[key] || typeof current[key] !== 'object') {
+                    current[key] = {};
+                }
+                current = current[key];
+            }
+        }
+    }
+    return result;
+};
+exports.createObjectFromDotNotation = createObjectFromDotNotation;
+const setPropertyFromDotNotation = (obj, path, value) => {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('Target object must be a valid object');
+    }
+    if (!path || typeof path !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    const keys = path.split('.');
+    let current = obj;
+    // Navigate to the parent of the target property
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        // If the property doesn't exist or isn't an object, create it
+        if (!current[key] || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    // Set the final property
+    const finalKey = keys[keys.length - 1];
+    current[finalKey] = value;
+    return obj;
+};
+exports.setPropertyFromDotNotation = setPropertyFromDotNotation;
+// Set multiple properties using dot notation map
+const setPropertiesFromDotNotation = (obj, dotNotationMap) => {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('Target object must be a valid object');
+    }
+    if (!dotNotationMap || typeof dotNotationMap !== 'object') {
+        throw new Error('Dot notation map must be a valid object');
+    }
+    for (const [path, value] of Object.entries(dotNotationMap)) {
+        (0, exports.setPropertyFromDotNotation)(obj, path, value);
+    }
+    return obj;
+};
+exports.setPropertiesFromDotNotation = setPropertiesFromDotNotation;
+const setPropertyFromDotNotationImmutable = (obj, path, value) => {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('Target object must be a valid object');
+    }
+    if (!path || typeof path !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    const keys = path.split('.');
+    const result = JSON.parse(JSON.stringify(obj)); // Deep clone
+    let current = result;
+    // Navigate to the parent of the target property
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        // If the property doesn't exist or isn't an object, create it
+        if (!current[key] || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    // Set the final property
+    const finalKey = keys[keys.length - 1];
+    current[finalKey] = value;
+    return result;
+};
+exports.setPropertyFromDotNotationImmutable = setPropertyFromDotNotationImmutable;
+// Set multiple properties using dot notation map (immutable version)
+const setPropertiesFromDotNotationImmutable = (obj, dotNotationMap) => {
+    if (!obj || typeof obj !== 'object') {
+        throw new Error('Target object must be a valid object');
+    }
+    if (!dotNotationMap || typeof dotNotationMap !== 'object') {
+        throw new Error('Dot notation map must be a valid object');
+    }
+    const result = JSON.parse(JSON.stringify(obj)); // Deep clone
+    for (const [path, value] of Object.entries(dotNotationMap)) {
+        (0, exports.setPropertyFromDotNotation)(result, path, value);
+    }
+    return result;
+};
+exports.setPropertiesFromDotNotationImmutable = setPropertiesFromDotNotationImmutable;

package/dist/utils/findKeyWithValue.d.ts

@@ -0,0 +1,2 @@
+export declare const findKeyWithValue: (obj: any, targetKey: any, targetValue: any) => boolean;
+//# sourceMappingURL=findKeyWithValue.d.ts.map

package/dist/utils/findKeyWithValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findKeyWithValue.d.ts","sourceRoot":"","sources":["../../src/utils/findKeyWithValue.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,GAAI,QAAG,EAAE,cAAS,EAAE,gBAAW,YAe3D,CAAA"}

package/dist/utils/findKeyWithValue.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findKeyWithValue = void 0;
+const findKeyWithValue = (obj, targetKey, targetValue) => {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (key === targetKey && obj[key] === targetValue) {
+                return true; // Key with matching value found
+            }
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                if ((0, exports.findKeyWithValue)(obj[key], targetKey, targetValue)) {
+                    return true; // Found in a nested object
+                }
+            }
+        }
+    }
+    return false; // Not found
+};
+exports.findKeyWithValue = findKeyWithValue;

package/dist/utils/findProtectedPaths.d.ts

@@ -0,0 +1,3 @@
+import { Model } from "mongoose";
+export declare const findProtectedPaths: (model: Model<any>) => string[];
+//# sourceMappingURL=findProtectedPaths.d.ts.map

package/dist/utils/findProtectedPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findProtectedPaths.d.ts","sourceRoot":"","sources":["../../src/utils/findProtectedPaths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,UAAU,CAAC;AAE/B,eAAO,MAAM,kBAAkB,GAAI,OAAO,KAAK,CAAC,GAAG,CAAC,KAAG,MAAM,EAsE5D,CAAA"}

package/dist/utils/findProtectedPaths.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProtectedPaths = void 0;
+const findProtectedPaths = (model) => {
+    const schema = model.schema;
+    const data = [];
+    schema.eachPath((p, i) => {
+        const str = JSON.stringify(i);
+        data.push(str);
+    });
+    const pathsSet = new Set();
+    function buildFullPath(parentPath, childPath) {
+        if (!parentPath)
+            return childPath;
+        if (!childPath)
+            return parentPath;
+        return `${parentPath}.${childPath}`;
+    }
+    // Recursive function to traverse nested objects and find selected: false
+    function traverseObject(obj, currentPath = '') {
+        // Check if current object has selected === false
+        if (obj.selected === false && obj.path) {
+            const fullPath = buildFullPath(currentPath, obj.path);
+            pathsSet.add(fullPath);
+        }
+        // Check options.selected
+        if (obj.options && obj.options.selected === false && obj.path) {
+            const fullPath = buildFullPath(currentPath, obj.path);
+            pathsSet.add(fullPath);
+        }
+        // Check for nested paths in complex schema objects
+        if (obj.options && obj.options.type && obj.options.type.paths) {
+            const nestedPaths = obj.options.type.paths;
+            const parentPath = obj.path || currentPath;
+            for (const [key, nestedObj] of Object.entries(nestedPaths)) {
+                if (nestedObj.selected === false) {
+                    const fullPath = buildFullPath(parentPath, nestedObj.path);
+                    pathsSet.add(fullPath);
+                }
+                // Recursively traverse nested objects
+                traverseObject(nestedObj, parentPath);
+            }
+        }
+        // Check other nested structures that might contain paths
+        if (obj.options && obj.options.type && typeof obj.options.type === 'object') {
+            const parentPath = obj.path || currentPath;
+            traverseObject(obj.options.type, parentPath);
+        }
+    }
+    // Iterate through each JSON string in the array
+    for (const jsonString of data) {
+        try {
+            // Parse the JSON string
+            const obj = JSON.parse(jsonString);
+            // Start traversal from root
+            traverseObject(obj);
+        }
+        catch (error) {
+            console.error('Error parsing JSON:', error);
+            continue;
+        }
+    }
+    // Convert Set back to Array and return
+    return Array.from(pathsSet);
+};
+exports.findProtectedPaths = findProtectedPaths;

package/dist/utils/getPathsWithRef.d.ts

@@ -0,0 +1,5 @@
+export declare const getPathsWithRef: (data: any) => {
+    path: string;
+    options: any;
+}[];
+//# sourceMappingURL=getPathsWithRef.d.ts.map

package/dist/utils/getPathsWithRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPathsWithRef.d.ts","sourceRoot":"","sources":["../../src/utils/getPathsWithRef.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,GAAE,SAAI;UACT,MAAM;aAAW,GAAG;GAoH5C,CAAA"}

package/dist/utils/getPathsWithRef.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPathsWithRef = void 0;
+const getPathsWithRef = (data) => {
+    const results = [];
+    const processedPaths = new Set(); // To avoid duplicates
+    // Helper function to build full dot notation path
+    function buildFullPath(parentPath, childPath) {
+        if (!parentPath)
+            return childPath;
+        if (!childPath)
+            return parentPath;
+        return `${parentPath}.${childPath}`;
+    }
+    // Function to check if options object contains ref
+    function hasRefInOptions(options) {
+        if (!options || typeof options !== 'object')
+            return false;
+        // Direct ref property
+        if (options.ref)
+            return true;
+        // Check in nested type array
+        if (Array.isArray(options.type)) {
+            return options.type.some(item => item && typeof item === 'object' && item.ref);
+        }
+        // Check in nested type object
+        if (options.type && typeof options.type === 'object' && options.type.ref) {
+            return true;
+        }
+        return false;
+    }
+    // Recursive function to traverse nested objects and find ref options
+    function traverseObject(obj, currentPath = '') {
+        // Check if current object has options with ref
+        if (obj.path && obj.options && hasRefInOptions(obj.options)) {
+            const fullPath = buildFullPath(currentPath, obj.path);
+            if (!processedPaths.has(fullPath)) {
+                processedPaths.add(fullPath);
+                results.push({
+                    path: fullPath,
+                    options: obj.options
+                });
+            }
+        }
+        // Check caster for array types (like books array)
+        if (obj.caster && obj.caster.options && hasRefInOptions(obj.caster.options)) {
+            const fullPath = buildFullPath(currentPath, obj.path || obj.caster.path);
+            if (!processedPaths.has(fullPath)) {
+                processedPaths.add(fullPath);
+                results.push({
+                    path: fullPath,
+                    options: obj.caster.options
+                });
+            }
+        }
+        // Check $embeddedSchemaType for array types
+        if (obj.$embeddedSchemaType && obj.$embeddedSchemaType.options && hasRefInOptions(obj.$embeddedSchemaType.options)) {
+            const fullPath = buildFullPath(currentPath, obj.path || obj.$embeddedSchemaType.path);
+            if (!processedPaths.has(fullPath)) {
+                processedPaths.add(fullPath);
+                results.push({
+                    path: fullPath,
+                    options: obj.$embeddedSchemaType.options
+                });
+            }
+        }
+        // Check for nested paths in complex schema objects
+        if (obj.options && obj.options.type && obj.options.type.paths) {
+            const nestedPaths = obj.options.type.paths;
+            const parentPath = obj.path || currentPath;
+            for (const [key, nestedObj] of Object.entries(nestedPaths)) {
+                traverseObject(nestedObj, parentPath);
+            }
+        }
+        // Check other nested structures
+        if (obj.options && obj.options.type && typeof obj.options.type === 'object') {
+            const parentPath = obj.path || currentPath;
+            traverseObject(obj.options.type, parentPath);
+        }
+    }
+    // Handle the comma-separated format in the provided data
+    let jsonObjects = [];
+    if (typeof data === 'string') {
+        // Split by comma and clean up each JSON string
+        const jsonStrings = data.split(',{').map((str, index) => {
+            if (index === 0)
+                return str.startsWith(',') ? str.slice(1) : str;
+            return '{' + str;
+        }).filter(str => str.trim());
+        jsonObjects = jsonStrings;
+    }
+    else if (Array.isArray(data)) {
+        jsonObjects = data.map(item => typeof item === 'string' ? item : JSON.stringify(item));
+    }
+    // Process each JSON object
+    for (const jsonString of jsonObjects) {
+        try {
+            const cleanJsonString = jsonString.trim();
+            if (!cleanJsonString)
+                continue;
+            const obj = JSON.parse(cleanJsonString);
+            traverseObject(obj);
+        }
+        catch (error) {
+            console.error('Error parsing JSON:', error);
+            continue;
+        }
+    }
+    return results;
+};
+exports.getPathsWithRef = getPathsWithRef;

package/dist/utils/isJsonString.d.ts

@@ -0,0 +1,2 @@
+export declare const isJsonString: (str: string) => boolean;
+//# sourceMappingURL=isJsonString.d.ts.map

package/dist/utils/isJsonString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isJsonString.d.ts","sourceRoot":"","sources":["../../src/utils/isJsonString.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,YAOvC,CAAA"}

package/dist/utils/isJsonString.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsonString = void 0;
+const isJsonString = (str) => {
+    try {
+        JSON.parse(str);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.isJsonString = isJsonString;

package/dist/utils/isValidDateString.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidDateString: (value: string) => boolean;
+//# sourceMappingURL=isValidDateString.d.ts.map

package/dist/utils/isValidDateString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidDateString.d.ts","sourceRoot":"","sources":["../../src/utils/isValidDateString.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,OAKjD,CAAA"}

package/dist/utils/isValidDateString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidDateString = void 0;
+const isValidDateString = (value) => {
+    return (!isNaN(Date.parse(value)) &&
+        /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([+-]\d{2}:\d{2})))?$/.test(value));
+};
+exports.isValidDateString = isValidDateString;

package/dist/utils/parseParams.d.ts

@@ -0,0 +1,4 @@
+import { ParsedQs } from "qs";
+import type { PagingQueryParsedRequestParams, AggregateQueryParsedRequestParams } from '../index.d';
+export declare const parseParams: (defaultParams: PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams, params: ParsedQs, isAggregate?: boolean) => PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams;
+//# sourceMappingURL=parseParams.d.ts.map

package/dist/utils/parseParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseParams.d.ts","sourceRoot":"","sources":["../../src/utils/parseParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,IAAI,CAAC;AAC5B,OAAO,KAAK,EAAC,8BAA8B,EAAE,iCAAiC,EAAC,MAAM,YAAY,CAAA;AAGjG,eAAO,MAAM,WAAW,GAAI,eAAe,8BAA8B,GAAG,iCAAiC,EAAE,QAAQ,QAAQ,EAAE,qBAAmB,KAAG,8BAA8B,GAAG,iCA4CvL,CAAA"}

package/dist/utils/parseParams.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseParams = void 0;
+const parseSortString_1 = require("./parseSortString");
+const parseParams = (defaultParams, params, isAggregate = false) => {
+    if (!params) {
+        return {};
+    }
+    const keys = Object.keys(params);
+    const __params = structuredClone(defaultParams);
+    const parsedParams = Object.assign({}, defaultParams);
+    keys.forEach((k) => {
+        if (__params.hasOwnProperty(k)) {
+            if (k === "$filter" || k === "$postFilter") {
+                parsedParams[k] =
+                    typeof params[k] === "string"
+                        ? JSON.parse(params[k])
+                        : params[k];
+            }
+            if (k === "$limit" || k === "$skip") {
+                parsedParams[k] = parseInt(params[k].toString());
+            }
+            if (k === "$paging") {
+                const str = params[k].toLowerCase();
+                parsedParams[k] = str === 'false' || str === 'no' || str == '0';
+            }
+            if (k === "$sort" || k === "$preSort") {
+                parsedParams[k] = isAggregate ? (0, parseSortString_1.parseAggregateSortString)(params[k]) : (0, parseSortString_1.parseSortString)(params[k]);
+            }
+            if (k === "$count" || k === "$includes" || k === "$populate") {
+                const v = params[k].split(",").map((v) => v.trim());
+                if (k === "$includes") {
+                    parsedParams["$populate"] = v;
+                }
+                else {
+                    parsedParams[k] = v;
+                }
+            }
+            if (k === "$select") {
+                parsedParams[k] = params[k];
+            }
+            if (k === "$lean") {
+                parsedParams[k] = true;
+            }
+        }
+    });
+    return parsedParams;
+};
+exports.parseParams = parseParams;

package/dist/utils/parsePopulateQuery.d.ts

@@ -0,0 +1,5 @@
+export declare const parsePopulateArray: (populateArr: string[], selectArr: string[]) => {
+    path: string;
+    select?: any;
+}[];
+//# sourceMappingURL=parsePopulateQuery.d.ts.map

package/dist/utils/parsePopulateQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsePopulateQuery.d.ts","sourceRoot":"","sources":["../../src/utils/parsePopulateQuery.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAAI,aAAa,MAAM,EAAE,EAAE,WAAW,MAAM,EAAE;UAmB1D,MAAM;aAAW,GAAG;GAGtC,CAAA"}

package/dist/utils/parsePopulateQuery.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePopulateArray = void 0;
+const parsePopulateArray = (populateArr, selectArr) => {
+    return populateArr.reduce((acc, curr) => {
+        const matched = selectArr.filter(item => {
+            const rgx = new RegExp(`^${curr}($|\.?)`, "g");
+            return rgx.test(item);
+        });
+        const pop = { path: curr };
+        matched.forEach(item => {
+            const str = item.slice(item.indexOf(".") + 1);
+            if (str === curr) {
+                return;
+            }
+            const currSelect = {};
+            if (str.startsWith("-")) {
+                currSelect[str.slice(1).trim()] = 0;
+            }
+            else {
+                currSelect[str.trim()] = 1;
+            }
+            pop["select"] = Object.assign(Object.assign({}, pop["select"]), currSelect);
+        });
+        acc.push(pop);
+        return acc;
+    }, []);
+};
+exports.parsePopulateArray = parsePopulateArray;

package/dist/utils/parseSortString.d.ts

@@ -0,0 +1,6 @@
+import { SortOrder } from "mongoose";
+export declare const parseSortString: (sortString: string) => [string, SortOrder][];
+export declare const parseAggregateSortString: (sortString: any) => {
+    [key: string]: SortOrder;
+};
+//# sourceMappingURL=parseSortString.d.ts.map

package/dist/utils/parseSortString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSortString.d.ts","sourceRoot":"","sources":["../../src/utils/parseSortString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AAEnC,eAAO,MAAM,eAAe,GAAI,YAAY,MAAM,0BAyBjD,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,eAAU,KAAE;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,SAAS,CAAA;CAO3E,CAAA"}

package/dist/utils/parseSortString.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAggregateSortString = exports.parseSortString = void 0;
+const parseSortString = (sortString) => {
+    return sortString
+        .split(",") //["_id 1","abc -1"]
+        .map((item) => {
+        const [k, v] = item.trim().replace(/  +/g, " ").split(" "); //["_id","1"]
+        if (!k && !v) {
+            return null;
+        }
+        if (k && !v) {
+            return [k.trim(), 1];
+        }
+        let _order;
+        if (isNaN(Number(v))) {
+            _order = v.trim();
+        }
+        else {
+            _order = Number(v);
+        }
+        const order = [-1, 1, 'asc', 'desc'].includes(_order) ? _order : 1;
+        return [
+            k.trim(),
+            order
+        ];
+    })
+        .filter((v) => v !== null);
+};
+exports.parseSortString = parseSortString;
+const parseAggregateSortString = (sortString) => {
+    const sortObj = (0, exports.parseSortString)(sortString);
+    return sortObj.reduce((a, c) => {
+        const [k, v] = c;
+        a[k] = v;
+        return a;
+    }, {});
+};
+exports.parseAggregateSortString = parseAggregateSortString;