@r5v/mongoose-paginate 1.0.13 → 1.0.15

package/dist/tests/aggregationPagingQuery.spec.js

@@ -0,0 +1,419 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const aggregationPagingQuery_1 = require("../aggregationPagingQuery");
+const node_mocks_http_1 = require("node-mocks-http");
+const mongoose_1 = __importStar(require("mongoose"));
+const mockingoose = require('mockingoose');
+// Create a test schema and model
+const AggTestSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    age: { type: Number },
+    email: { type: String },
+    active: { type: Boolean, default: true },
+    createdAt: { type: Date, default: Date.now },
+    category: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Category' }
+});
+const AggTestModel = mongoose_1.default.model('AggTestModel', AggTestSchema);
+// Create a test schema with protected fields
+const ProtectedSchema = new mongoose_1.Schema({
+    username: { type: String, required: true },
+    email: { type: String },
+    password: { type: String, select: false },
+    secretKey: { type: String, select: false },
+    profile: {
+        name: { type: String },
+        ssn: { type: String, select: false }
+    }
+});
+const ProtectedModel = mongoose_1.default.model('ProtectedModel', ProtectedSchema);
+// Default pipeline with at least one stage to avoid undefined error
+const defaultPipeline = [{ $match: {} }];
+describe('AggregationPagingQuery', () => {
+    beforeEach(() => {
+        mockingoose.resetAll();
+    });
+    describe('constructor', () => {
+        test('should throw error if request is invalid', () => {
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(null, AggTestModel, { pipeline: [] });
+            }).toThrow('Invalid request object: must have a query property');
+        });
+        test('should throw error if request has no query property', () => {
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery({}, AggTestModel, { pipeline: [] });
+            }).toThrow('Invalid request object: must have a query property');
+        });
+        test('should throw error if model is invalid', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, null, { pipeline: [] });
+            }).toThrow('Invalid model: must be a Mongoose model');
+        });
+        test('should throw error if model does not have aggregate function', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, {}, { pipeline: [] });
+            }).toThrow('Invalid model: must be a Mongoose model');
+        });
+        test('should throw error if options is missing pipeline', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {});
+            }).toThrow('Invalid options: pipeline must be an array');
+        });
+        test('should throw error if pipeline is not an array', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: 'invalid' });
+            }).toThrow('Invalid options: pipeline must be an array');
+        });
+        test('should create instance with default params', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            // Need at least one pipeline stage to avoid undefined error
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: [{ $match: {} }] });
+            expect(apq.params.$limit).toBe(25);
+            expect(apq.params.$skip).toBe(0);
+            expect(apq.params.$paging).toBe(true);
+            expect(apq.params.$filter).toEqual({});
+            expect(apq.params.$sort).toEqual({});
+            expect(apq.params.$populate).toEqual([]);
+            expect(apq.params.$select).toBe('');
+            expect(apq.params.$count).toEqual([]);
+            expect(apq.params.$postFilter).toEqual({});
+            expect(apq.params.$preSort).toEqual({});
+        });
+        test('should parse filter from query string', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $filter: '{"name":"John"}' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                enableFilter: true
+            });
+            expect(apq.params.$filter).toEqual({ name: 'John' });
+        });
+        test('should parse sort string for aggregate', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $sort: 'name 1, age -1' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.params.$sort).toEqual({ name: 1, age: -1 });
+        });
+        test('should parse preSort string', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $preSort: 'createdAt -1' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.params.$preSort).toEqual({ createdAt: -1 });
+        });
+        test('should parse count array', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $count: 'items, orders' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.params.$count).toEqual(['items', 'orders']);
+        });
+        test('should parse postFilter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $postFilter: '{"verified":true}' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                enablePostFilter: true
+            });
+            expect(apq.params.$postFilter).toEqual({ verified: true });
+        });
+    });
+    describe('options', () => {
+        test('should set default options', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.options.enableFilter).toBe(false);
+            expect(apq.options.enablePostFilter).toBe(false);
+            expect(apq.options.enablePreSort).toBe(true);
+        });
+        test('should merge provided options', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: [{ $match: { active: true } }],
+                enableFilter: true,
+                enablePostFilter: true,
+                staticFilter: { type: 'test' }
+            });
+            expect(apq.options.enableFilter).toBe(true);
+            expect(apq.options.enablePostFilter).toBe(true);
+            expect(apq.options.staticFilter).toEqual({ type: 'test' });
+        });
+    });
+    describe('typeCastObject', () => {
+        test('should convert valid ObjectId strings', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const objectIdStr = '507f1f77bcf86cd799439011';
+            const result = apq.typeCastObject(objectIdStr);
+            expect(result).toBeInstanceOf(mongoose_1.Types.ObjectId);
+            expect(result.toString()).toBe(objectIdStr);
+        });
+        test('should keep already cast ObjectIds', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const objectId = new mongoose_1.Types.ObjectId();
+            const result = apq.typeCastObject(objectId);
+            expect(result).toBe(objectId);
+        });
+        test('should convert valid date strings', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const dateStr = '2023-01-15T10:30:00Z';
+            const result = apq.typeCastObject(dateStr);
+            expect(result).toBeInstanceOf(Date);
+        });
+        test('should keep numbers as-is', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.typeCastObject(123)).toBe(123);
+            expect(apq.typeCastObject(0)).toBe(0);
+            expect(apq.typeCastObject(-5)).toBe(-5);
+        });
+        test('should keep regular strings as-is', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.typeCastObject('hello')).toBe('hello');
+            expect(apq.typeCastObject('John Doe')).toBe('John Doe');
+        });
+        test('should recursively process arrays', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const objectIdStr = '507f1f77bcf86cd799439011';
+            const result = apq.typeCastObject([objectIdStr, 'hello', 123]);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result[0]).toBeInstanceOf(mongoose_1.Types.ObjectId);
+            expect(result[1]).toBe('hello');
+            expect(result[2]).toBe(123);
+        });
+        test('should recursively process objects', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const objectIdStr = '507f1f77bcf86cd799439011';
+            const result = apq.typeCastObject({
+                _id: objectIdStr,
+                name: 'John',
+                age: 30
+            });
+            expect(result._id).toBeInstanceOf(mongoose_1.Types.ObjectId);
+            expect(result.name).toBe('John');
+            expect(result.age).toBe(30);
+        });
+        test('should handle nested objects with ObjectIds', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const objectIdStr = '507f1f77bcf86cd799439011';
+            const result = apq.typeCastObject({
+                $and: [
+                    { userId: objectIdStr },
+                    { active: true }
+                ]
+            });
+            expect(result.$and[0].userId).toBeInstanceOf(mongoose_1.Types.ObjectId);
+            expect(result.$and[1].active).toBe(true);
+        });
+    });
+    describe('createCounts', () => {
+        test('should create count fields from $count params', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $count: 'items,orders' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            expect(apq.params.$count).toEqual(['items', 'orders']);
+        });
+    });
+    describe('exec', () => {
+        test('should throw error if query is not present', () => __awaiter(void 0, void 0, void 0, function* () {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            apq.query = undefined;
+            yield expect(apq.exec()).rejects.toThrow('No Query Present in AggregationQuery');
+        }));
+        test('should execute without paging when disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = [{ name: 'John' }, { name: 'Jane' }];
+            mockingoose(AggTestModel).toReturn(mockData, 'aggregate');
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $paging: 'false' }
+            });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                disablePaging: true
+            });
+            const result = yield apq.exec();
+            expect(result).toEqual(mockData);
+        }));
+        test('should execute with paging and return paginated structure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = [{
+                    items: [{ name: 'John' }, { name: 'Jane' }],
+                    totalRows: 100,
+                    limit: 25,
+                    skip: 0,
+                    rows: 2
+                }];
+            mockingoose(AggTestModel).toReturn(mockData, 'aggregate');
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            const result = yield apq.exec();
+            expect(result).toHaveProperty('items');
+            expect(result).toHaveProperty('totalRows');
+            expect(result).toHaveProperty('limit');
+            expect(result).toHaveProperty('skip');
+            expect(result).toHaveProperty('rows');
+        }));
+    });
+    describe('pipeline handling', () => {
+        test('should prepend $search stage if present in first position', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: [
+                    { $search: { index: 'default', text: { query: 'test', path: 'name' } } },
+                    { $project: { name: 1 } }
+                ]
+            });
+            expect(apq.query).toBeDefined();
+        });
+        test('should prepend $geoNear stage if present in first position', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: [
+                    { $geoNear: { near: { type: 'Point', coordinates: [0, 0] }, distanceField: 'dist' } },
+                    { $project: { name: 1 } }
+                ]
+            });
+            expect(apq.query).toBeDefined();
+        });
+        test('should handle $match in first position', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: [
+                    { $match: { active: true } },
+                    { $project: { name: 1 } }
+                ]
+            });
+            expect(apq.query).toBeDefined();
+        });
+        test('should apply static filter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                staticFilter: { type: 'premium' }
+            });
+            expect(apq.options.staticFilter).toEqual({ type: 'premium' });
+        });
+        test('should apply static post filter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                staticPostFilter: { verified: true }
+            });
+            expect(apq.options.staticPostFilter).toEqual({ verified: true });
+        });
+    });
+    describe('error handling', () => {
+        test('should throw error for invalid JSON in filter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $filter: 'invalid json' }
+            });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            }).toThrow('Invalid JSON in $filter parameter');
+        });
+        test('should throw error for invalid JSON in postFilter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $postFilter: 'invalid json' }
+            });
+            expect(() => {
+                new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, { pipeline: defaultPipeline });
+            }).toThrow('Invalid JSON in $postFilter parameter');
+        });
+    });
+    describe('removeProtected', () => {
+        test('should find protected paths when removeProtected is enabled', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, ProtectedModel, {
+                pipeline: defaultPipeline,
+                removeProtected: true
+            });
+            expect(apq.protectedPaths).toContain('password');
+            expect(apq.protectedPaths).toContain('secretKey');
+        });
+        test('should not find protected paths when removeProtected is disabled', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, ProtectedModel, {
+                pipeline: defaultPipeline,
+                removeProtected: false
+            });
+            expect(apq.protectedPaths).toEqual([]);
+        });
+        test('should not find protected paths by default', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, ProtectedModel, {
+                pipeline: defaultPipeline
+            });
+            expect(apq.protectedPaths).toEqual([]);
+        });
+        test('should set removeProtected option correctly', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, ProtectedModel, {
+                pipeline: defaultPipeline,
+                removeProtected: true
+            });
+            expect(apq.options.removeProtected).toBe(true);
+        });
+        test('should have empty protected paths for model without protected fields', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const apq = new aggregationPagingQuery_1.AggregationPagingQuery(req, AggTestModel, {
+                pipeline: defaultPipeline,
+                removeProtected: true
+            });
+            expect(apq.protectedPaths).toEqual([]);
+        });
+    });
+});

package/dist/tests/buildPopulateFromString.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buildPopulateFromString.spec.d.ts.map

package/dist/tests/buildPopulateFromString.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildPopulateFromString.spec.d.ts","sourceRoot":"","sources":["../../src/tests/buildPopulateFromString.spec.ts"],"names":[],"mappings":""}

package/dist/tests/buildPopulateFromString.spec.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildPopulateFromString_1 = require("../utils/buildPopulateFromString");
+describe('buildPopulate', () => {
+    describe('basic path parsing', () => {
+        test('should return empty array for empty string', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('');
+            expect(result).toEqual([]);
+        });
+        test('should return empty array for null/undefined', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)(null);
+            expect(result).toEqual([]);
+        });
+        test('should parse single path', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author');
+            expect(result).toEqual([{ path: 'author' }]);
+        });
+        test('should parse multiple paths', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author, books');
+            expect(result).toEqual([
+                { path: 'author' },
+                { path: 'books' }
+            ]);
+        });
+        test('should trim whitespace from paths', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('  author  ,  books  ');
+            expect(result).toEqual([
+                { path: 'author' },
+                { path: 'books' }
+            ]);
+        });
+    });
+    describe('nested path parsing', () => {
+        test('should parse nested path with dot notation', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [{ path: 'profile' }]
+                }
+            ]);
+        });
+        test('should parse deeply nested path', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile.avatar');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [
+                        {
+                            path: 'profile',
+                            populate: [{ path: 'avatar' }]
+                        }
+                    ]
+                }
+            ]);
+        });
+        test('should merge nested paths with same root', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile, author.books');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [
+                        { path: 'profile' },
+                        { path: 'books' }
+                    ]
+                }
+            ]);
+        });
+    });
+    describe('select field parsing', () => {
+        test('should parse path with select in brackets', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name,email]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name email'
+                }
+            ]);
+        });
+        test('should parse path with single select field', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name'
+                }
+            ]);
+        });
+        test('should parse multiple paths with select', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name], books[title,isbn]');
+            expect(result).toEqual([
+                { path: 'author', select: 'name' },
+                { path: 'books', select: 'title isbn' }
+            ]);
+        });
+    });
+    describe('nested paths with select', () => {
+        test('should parse nested path with select on child', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile[bio,avatar]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [
+                        {
+                            path: 'profile',
+                            select: 'bio avatar'
+                        }
+                    ]
+                }
+            ]);
+        });
+        test('should parse nested path with select on parent', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name].profile');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name',
+                    populate: [{ path: 'profile' }]
+                }
+            ]);
+        });
+        test('should parse nested path with select on both', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name].profile[bio]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name',
+                    populate: [
+                        {
+                            path: 'profile',
+                            select: 'bio'
+                        }
+                    ]
+                }
+            ]);
+        });
+    });
+    describe('complex scenarios', () => {
+        test('should handle multiple nested paths with different depths', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile, books.publisher.location');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [{ path: 'profile' }]
+                },
+                {
+                    path: 'books',
+                    populate: [
+                        {
+                            path: 'publisher',
+                            populate: [{ path: 'location' }]
+                        }
+                    ]
+                }
+            ]);
+        });
+        test('should merge multiple nested paths correctly', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author.profile, author.books, author.followers');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    populate: [
+                        { path: 'profile' },
+                        { path: 'books' },
+                        { path: 'followers' }
+                    ]
+                }
+            ]);
+        });
+        test('should handle commas inside brackets correctly', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name,email,bio]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name email bio'
+                }
+            ]);
+        });
+        test('should handle complex combination', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[name].profile[bio], books[title]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: 'name',
+                    populate: [
+                        {
+                            path: 'profile',
+                            select: 'bio'
+                        }
+                    ]
+                },
+                {
+                    path: 'books',
+                    select: 'title'
+                }
+            ]);
+        });
+    });
+    describe('edge cases', () => {
+        test('should handle path with empty brackets', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[]');
+            // Empty brackets are preserved in the path name
+            expect(result).toEqual([{ path: 'author[]' }]);
+        });
+        test('should handle whitespace around brackets', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('author[ name , email ]');
+            expect(result).toEqual([
+                {
+                    path: 'author',
+                    select: ' name   email '
+                }
+            ]);
+        });
+        test('should handle single character paths', () => {
+            const result = (0, buildPopulateFromString_1.buildPopulate)('a, b, c');
+            expect(result).toEqual([
+                { path: 'a' },
+                { path: 'b' },
+                { path: 'c' }
+            ]);
+        });
+    });
+});

package/dist/tests/dotNotation.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotNotation.spec.d.ts","sourceRoot":"","sources":["../../src/tests/dotNotation.spec.ts"],"names":[],"mappings":""}

package/dist/tests/findProtectedPaths.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findProtectedPaths.spec.d.ts","sourceRoot":"","sources":["../../src/tests/findProtectedPaths.spec.ts"],"names":[],"mappings":""}