@r5v/mongoose-paginate 1.0.12 → 1.0.14

package/dist/types/index.d.ts

@@ -1,4 +1,67 @@
-export { PagingQuery } from './pagingQuery';
-export { AggregationPagingQuery } from './aggregationPagingQuery';
-export { buildPopulate } from './utils/buildPopulateFromString';
+import mongoose, { QueryOptions, SortOrder, AggregateOptions } from "mongoose";
+import { ParsedQs } from "qs";
+/**
+ * Minimal request interface that only requires a query property.
+ * This allows consumers to use custom Express request types without
+ * running into index signature compatibility issues.
+ */
+export interface RequestLike {
+    query: ParsedQs | Record<string, unknown>;
+}
+export interface QueryParameters extends ParsedQs {
+    $filter: string;
+    $limit: string;
+    $skip: string;
+    $sort: string;
+    $paging: "yes" | "no" | "0" | "false";
+    $populate: string;
+    $select: string;
+    $count: string;
+}
+export interface StandardParsedRequestParams {
+    $filter?: {
+        [key: string]: any;
+    };
+    $limit: number;
+    $skip: number;
+    $paging?: boolean;
+    $populate?: string[];
+    $select?: string;
+}
+export interface PagingQueryParsedRequestParams extends StandardParsedRequestParams {
+    $lean?: boolean;
+    $sort?: [string, SortOrder][];
+}
+export interface AggregateQueryParsedRequestParams extends StandardParsedRequestParams {
+    $preSort: {
+        [key: string]: SortOrder;
+    };
+    $sort: {
+        [key: string]: SortOrder;
+    };
+    $count: string[];
+    $postFilter: {
+        [key: string]: any;
+    };
+}
+export interface StandardQueryOptions extends QueryOptions {
+    disablePaging?: boolean;
+    disableFilter?: boolean;
+}
+export interface PagingQueryOptions extends StandardQueryOptions {
+    staticFilter?: {
+        [key: string]: any;
+    };
+    single?: boolean;
+}
+export interface AggregateQueryOptions extends Omit<AggregateOptions, 'comment'> {
+    enableFilter?: boolean;
+    disablePaging?: boolean;
+    disablePostFilter?: boolean;
+    disablePreSort?: boolean;
+    staticPostFilter?: {
+        [key: string]: any;
+    };
+    pipeline: mongoose.PipelineStage[];
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAA;AACzC,OAAO,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,EAAE,EAAC,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAC,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAC,QAAQ,EAAC,MAAM,IAAI,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,eAAgB,SAAQ,QAAQ;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,GAAG,OAAO,CAAA;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IACxC,OAAO,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IAChC,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,8BAA+B,SAAQ,2BAA2B;IAC/E,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAA;CAEhC;AACD,MAAM,WAAW,iCAAkC,SAAQ,2BAA2B;IAClF,QAAQ,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;IACtC,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;IACnC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,WAAW,EAAE;QAAC,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAA;KAAC,CAAA;CAClC;AACD,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACtD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC5D,YAAY,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,gBAAgB,EAAC,SAAS,CAAC;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gBAAgB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAC,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IACxC,QAAQ,EAAE,QAAQ,CAAC,aAAa,EAAE,CAAA;CACrC"}

package/dist/utils/buildPopulateFromString.d.ts

@@ -0,0 +1,8 @@
+interface PopulateItem {
+    path: string;
+    select?: string;
+    populate?: PopulateItem[];
+}
+export declare function buildPopulate(pathString: string): PopulateItem[];
+export {};
+//# sourceMappingURL=buildPopulateFromString.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildPopulateFromString.d.ts","sourceRoot":"","sources":["../../src/utils/buildPopulateFromString.ts"],"names":[],"mappings":"AACA,UAAU,YAAY;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;CAC5B;AAgED,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,EAAE,CAQhE"}

package/dist/utils/buildPopulateFromString.js

@@ -1,58 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPopulate = buildPopulate;
+const SEGMENT_PATTERN = /^([^\[]+)(?:\[([^\]]+)\])?$/;
+// Private module-level functions
+function splitPaths(str) {
+    const paths = [];
+    let current = '';
+    let depth = 0;
+    for (const char of str) {
+        if (char === '[')
+            depth++;
+        else if (char === ']')
+            depth--;
+        if (char === ',' && depth === 0) {
+            paths.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        paths.push(current.trim());
+    return paths;
+}
+function parseSegment(segment) {
+    var _a;
+    const match = segment.match(SEGMENT_PATTERN);
+    if (!match)
+        return { name: segment };
+    return {
+        name: match[1],
+        select: (_a = match[2]) === null || _a === void 0 ? void 0 : _a.replace(/,/g, ' ')
+    };
+}
+function processLevel(paths) {
+    if (!(paths === null || paths === void 0 ? void 0 : paths.length))
+        return [];
+    const groups = {};
+    for (const [first, ...rest] of paths) {
+        const key = first.name;
+        if (!groups[key])
+            groups[key] = { select: first.select, children: [] };
+        if (rest.length)
+            groups[key].children.push(rest);
+    }
+    return Object.entries(groups).map(([key, { select, children }]) => {
+        const obj = { path: key };
+        if (select)
+            obj.select = select;
+        if (children.length)
+            obj.populate = processLevel(children);
+        return obj;
+    });
+}
+// Only this is exported
 function buildPopulate(pathString) {
     if (!pathString)
         return [];
-    const splitPaths = (str) => {
-        const paths = [];
-        let current = '';
-        let depth = 0;
-        for (const char of str) {
-            if (char === '[')
-                depth++;
-            else if (char === ']')
-                depth--;
-            if (char === ',' && depth === 0) {
-                paths.push(current.trim());
-                current = '';
-            }
-            else {
-                current += char;
-            }
-        }
-        if (current)
-            paths.push(current.trim());
-        return paths;
-    };
-    const parseSegment = (segment) => {
-        var _a;
-        const match = segment.match(/^([^\[]+)(?:\[([^\]]+)\])?$/);
-        if (!match)
-            return { name: segment };
-        return {
-            name: match[1],
-            select: (_a = match[2]) === null || _a === void 0 ? void 0 : _a.replace(/,/g, ' ')
-        };
-    };
     const paths = splitPaths(pathString).map(p => p.split('.').map(parseSegment));
-    const processLevel = (paths) => {
-        const groups = {};
-        for (const [first, ...rest] of paths) {
-            const key = first.name;
-            if (!groups[key])
-                groups[key] = { select: first.select, children: [] };
-            if (rest.length)
-                groups[key].children.push(rest);
-        }
-        return Object.entries(groups).map(([key, { select, children }]) => {
-            const obj = { path: key };
-            if (select)
-                obj.select = select;
-            if (children.length)
-                obj.populate = processLevel(children);
-            return obj;
-        });
-    };
     return processLevel(paths);
 }

package/dist/utils/dotNotation.d.ts

@@ -0,0 +1,11 @@
+export declare const getPropertyFromDotNotation: (obj: any, path: string) => any;
+export declare const dotNotationToObject: (dotString: string, value?: unknown) => {};
+export declare const createObjectFromDotNotation: (dotNotationMap: {
+    [key: string]: any;
+}) => {};
+export declare const setPropertyFromDotNotation: (obj: Record<string, unknown>, path: string, value: unknown) => Record<string, unknown>;
+export declare const setPropertiesFromDotNotation: (obj: Record<string, unknown>, dotNotationMap: Record<string, unknown>) => Record<string, unknown>;
+export declare const setPropertyFromDotNotationImmutable: (obj: Record<string, unknown>, path: string, value: unknown) => Record<string, unknown>;
+export declare const setPropertiesFromDotNotationImmutable: (obj: Record<string, unknown>, dotNotationMap: Record<string, unknown>) => Record<string, unknown>;
+export type setPropertiesFromDotNotationImmutable = typeof setPropertiesFromDotNotationImmutable;
+//# 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,WAAW,MAAM,EAAE,QAAO,OAAc,OAoB3E,CAAA;AAGD,eAAO,MAAO,2BAA2B,GAAI,gBAAe;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAA;CAAC,OAwB7E,CAAA;AAED,eAAO,MAAM,0BAA0B,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,MAAM,EAAE,OAAO,OAAO,4BA4BpG,CAAC;AAGF,eAAO,MAAM,4BAA4B,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,4BAcjH,CAAC;AAGF,eAAO,MAAM,mCAAmC,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,MAAM,EAAE,OAAO,OAAO,4BA6B7G,CAAC;AAGF,eAAO,MAAM,qCAAqC,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,4BAgB1H,CAAC;AACF,MAAM,MAAM,qCAAqC,GAAG,OAAO,qCAAqC,CAAC"}

package/dist/utils/dotNotation.js

@@ -95,7 +95,7 @@ const setPropertyFromDotNotationImmutable = (obj, path, value) => {
         throw new Error('Path must be a non-empty string');
     }
     const keys = path.split('.');
-    const result = JSON.parse(JSON.stringify(obj)); // Deep clone
+    const result = structuredClone(obj);
     let current = result;
     // Navigate to the parent of the target property
     for (let i = 0; i < keys.length - 1; i++) {
@@ -120,7 +120,7 @@ const setPropertiesFromDotNotationImmutable = (obj, dotNotationMap) => {
     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
+    const result = structuredClone(obj);
     for (const [path, value] of Object.entries(dotNotationMap)) {
         (0, exports.setPropertyFromDotNotation)(result, path, value);
     }

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/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;AAG/B,eAAO,MAAM,kBAAkB,GAAI,OAAO,KAAK,CAAC,GAAG,CAAC,KAAG,MAAM,EAqB5D,CAAC"}

package/dist/utils/findProtectedPaths.js

@@ -1,66 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findProtectedPaths = void 0;
+const schemaTraversal_1 = require("./schemaTraversal");
 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);
+    schema.eachPath((path, schemaType) => {
+        (0, schemaTraversal_1.traverseSchemaObject)(schemaType, (obj, currentPath) => {
+            // Check if current object has selected === false
+            if (obj.selected === false && obj.path) {
+                const fullPath = (0, schemaTraversal_1.buildFullPath)(currentPath, obj.path);
+                pathsSet.add(fullPath);
+            }
+            // Check options.selected
+            if (obj.options && obj.options.selected === false && obj.path) {
+                const fullPath = (0, schemaTraversal_1.buildFullPath)(currentPath, obj.path);
+                pathsSet.add(fullPath);
             }
-        }
-        // 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[] | string) => {
+    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":"AAsBA,eAAO,MAAM,eAAe,GAAI,MAAM,GAAG,EAAE,GAAG,MAAM,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,EAqDpF,CAAC"}

package/dist/utils/getPathsWithRef.js

@@ -1,110 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPathsWithRef = void 0;
+const schemaTraversal_1 = require("./schemaTraversal");
+// Private module-level function
+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;
+}
 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);
+    const processedPaths = new Set();
+    // Normalize input to array of objects
+    let objects;
+    if (typeof data === 'string') {
+        try {
+            const parsed = JSON.parse(data);
+            objects = Array.isArray(parsed) ? parsed : [parsed];
         }
-        // Check in nested type object
-        if (options.type && typeof options.type === 'object' && options.type.ref) {
-            return true;
+        catch (_a) {
+            // If it's not valid JSON, return empty results
+            return results;
         }
-        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
-                });
+    else if (Array.isArray(data)) {
+        objects = data;
+    }
+    else {
+        return results;
+    }
+    for (const obj of objects) {
+        (0, schemaTraversal_1.traverseSchemaObject)(obj, (schemaObj, currentPath) => {
+            var _a, _b;
+            const fullPath = (0, schemaTraversal_1.buildFullPath)(currentPath, schemaObj.path);
+            // Check direct options.ref
+            if (schemaObj.path && schemaObj.options && hasRefInOptions(schemaObj.options)) {
+                if (!processedPaths.has(fullPath)) {
+                    processedPaths.add(fullPath);
+                    results.push({ path: fullPath, options: schemaObj.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 caster.options.ref (for arrays)
+            if (((_a = schemaObj.caster) === null || _a === void 0 ? void 0 : _a.options) && hasRefInOptions(schemaObj.caster.options)) {
+                const casterPath = (0, schemaTraversal_1.buildFullPath)(currentPath, schemaObj.path || schemaObj.caster.path);
+                if (!processedPaths.has(casterPath)) {
+                    processedPaths.add(casterPath);
+                    results.push({ path: casterPath, options: schemaObj.caster.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 $embeddedSchemaType.options.ref (for arrays)
+            if (((_b = schemaObj.$embeddedSchemaType) === null || _b === void 0 ? void 0 : _b.options) && hasRefInOptions(schemaObj.$embeddedSchemaType.options)) {
+                const embeddedPath = (0, schemaTraversal_1.buildFullPath)(currentPath, schemaObj.path || schemaObj.$embeddedSchemaType.path);
+                if (!processedPaths.has(embeddedPath)) {
+                    processedPaths.add(embeddedPath);
+                    results.push({ path: embeddedPath, options: schemaObj.$embeddedSchemaType.options });
+                }
             }
-        }
-        // 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;
 };

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { buildPopulate } from './buildPopulateFromString';
+export { parsePopulateArray } from './parsePopulateQuery';
+export { parseSortString, parseAggregateSortString } from './parseSortString';
+export { getPropertyFromDotNotation, dotNotationToObject, createObjectFromDotNotation, setPropertyFromDotNotation, setPropertiesFromDotNotation, setPropertyFromDotNotationImmutable, setPropertiesFromDotNotationImmutable } from './dotNotation';
+export { isJsonString } from './isJsonString';
+export { isValidDateString } from './isValidDateString';
+export { parseParams } from './parseParams';
+export { buildFullPath, traverseSchemaObject } from './schemaTraversal';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAGzD,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAG7E,OAAO,EACH,0BAA0B,EAC1B,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,EAC5B,mCAAmC,EACnC,qCAAqC,EACxC,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG3C,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSchemaObject = exports.buildFullPath = exports.parseParams = exports.isValidDateString = exports.isJsonString = exports.setPropertiesFromDotNotationImmutable = exports.setPropertyFromDotNotationImmutable = exports.setPropertiesFromDotNotation = exports.setPropertyFromDotNotation = exports.createObjectFromDotNotation = exports.dotNotationToObject = exports.getPropertyFromDotNotation = exports.parseAggregateSortString = exports.parseSortString = exports.parsePopulateArray = exports.buildPopulate = void 0;
+// Populate utilities
+var buildPopulateFromString_1 = require("./buildPopulateFromString");
+Object.defineProperty(exports, "buildPopulate", { enumerable: true, get: function () { return buildPopulateFromString_1.buildPopulate; } });
+var parsePopulateQuery_1 = require("./parsePopulateQuery");
+Object.defineProperty(exports, "parsePopulateArray", { enumerable: true, get: function () { return parsePopulateQuery_1.parsePopulateArray; } });
+// Sort utilities
+var parseSortString_1 = require("./parseSortString");
+Object.defineProperty(exports, "parseSortString", { enumerable: true, get: function () { return parseSortString_1.parseSortString; } });
+Object.defineProperty(exports, "parseAggregateSortString", { enumerable: true, get: function () { return parseSortString_1.parseAggregateSortString; } });
+// Dot notation utilities
+var dotNotation_1 = require("./dotNotation");
+Object.defineProperty(exports, "getPropertyFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.getPropertyFromDotNotation; } });
+Object.defineProperty(exports, "dotNotationToObject", { enumerable: true, get: function () { return dotNotation_1.dotNotationToObject; } });
+Object.defineProperty(exports, "createObjectFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.createObjectFromDotNotation; } });
+Object.defineProperty(exports, "setPropertyFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.setPropertyFromDotNotation; } });
+Object.defineProperty(exports, "setPropertiesFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.setPropertiesFromDotNotation; } });
+Object.defineProperty(exports, "setPropertyFromDotNotationImmutable", { enumerable: true, get: function () { return dotNotation_1.setPropertyFromDotNotationImmutable; } });
+Object.defineProperty(exports, "setPropertiesFromDotNotationImmutable", { enumerable: true, get: function () { return dotNotation_1.setPropertiesFromDotNotationImmutable; } });
+// Validation utilities
+var isJsonString_1 = require("./isJsonString");
+Object.defineProperty(exports, "isJsonString", { enumerable: true, get: function () { return isJsonString_1.isJsonString; } });
+var isValidDateString_1 = require("./isValidDateString");
+Object.defineProperty(exports, "isValidDateString", { enumerable: true, get: function () { return isValidDateString_1.isValidDateString; } });
+// Parameter parsing
+var parseParams_1 = require("./parseParams");
+Object.defineProperty(exports, "parseParams", { enumerable: true, get: function () { return parseParams_1.parseParams; } });
+// Schema traversal utilities
+var schemaTraversal_1 = require("./schemaTraversal");
+Object.defineProperty(exports, "buildFullPath", { enumerable: true, get: function () { return schemaTraversal_1.buildFullPath; } });
+Object.defineProperty(exports, "traverseSchemaObject", { enumerable: true, get: function () { return schemaTraversal_1.traverseSchemaObject; } });

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/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/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,EACR,8BAA8B,EAC9B,iCAAiC,EACpC,MAAM,UAAU,CAAA;AAGjB,eAAO,MAAM,WAAW,GAAI,eAAe,8BAA8B,GAAG,iCAAiC,EAAE,QAAQ,QAAQ,EAAE,qBAAmB,KAAG,8BAA8B,GAAG,iCA6CvL,CAAA"}

package/dist/utils/parseParams.js

@@ -12,29 +12,31 @@ const parseParams = (defaultParams, params, isAggregate = false) => {
     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 (typeof params[k] === "string") {
+                    try {
+                        parsedParams[k] = JSON.parse(params[k]);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid JSON in ${k} parameter: ${e.message}`);
+                    }
+                }
+                else {
+                    parsedParams[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');
+                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") {
+            if (k === "$count" || k === "$populate") {
                 const v = params[k].split(",").map((v) => v.trim());
-                if (k === "$includes") {
-                    parsedParams["$populate"] = v;
-                }
-                else {
-                    parsedParams[k] = v;
-                }
+                parsedParams[k] = v;
             }
             if (k === "$select") {
                 parsedParams[k] = params[k];

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

@@ -4,7 +4,7 @@ exports.parsePopulateArray = void 0;
 const parsePopulateArray = (populateArr, selectArr) => {
     return populateArr.reduce((acc, curr) => {
         const matched = selectArr.filter(item => {
-            const rgx = new RegExp(`^${curr}($|\.?)`, "g");
+            const rgx = new RegExp(`^${curr}($|\.?)`);
             return rgx.test(item);
         });
         const pop = { path: curr };

package/dist/{types/utils → utils}/parseSortString.d.ts

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