@r5v/mongoose-paginate 1.0.13 → 1.0.15

package/dist/tests/pagingQuery.spec.js

@@ -1,21 +1,246 @@
 "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 mockingoose = require('mockingoose');
+const pagingQuery_1 = require("../pagingQuery");
 const node_mocks_http_1 = require("node-mocks-http");
-const req = (0, node_mocks_http_1.createRequest)({ query: {
-        $filter: '{"a":123}',
-        $sort: 'name 1', '$populate': 'books'
-    } });
+const mockingoose = require('mockingoose');
+const mongoose_1 = __importStar(require("mongoose"));
+// Create a test schema and model
+const TestSchema = 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 }
+});
+const TestModel = mongoose_1.default.model('TestModel', TestSchema);
 describe('PagingQuery', () => {
     beforeEach(() => {
-        // Reset mockingoose before each test to ensure isolation
-        // mockingoose.resetAll();
+        mockingoose.resetAll();
+    });
+    describe('constructor', () => {
+        test('should throw error if request is invalid', () => {
+            expect(() => {
+                new pagingQuery_1.PagingQuery(null, TestModel);
+            }).toThrow('Invalid request object: must have a query property');
+        });
+        test('should throw error if request has no query property', () => {
+            expect(() => {
+                new pagingQuery_1.PagingQuery({}, TestModel);
+            }).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 pagingQuery_1.PagingQuery(req, null);
+            }).toThrow('Invalid model: must be a Mongoose model');
+        });
+        test('should throw error if model does not have find function', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            expect(() => {
+                new pagingQuery_1.PagingQuery(req, {});
+            }).toThrow('Invalid model: must be a Mongoose model');
+        });
+        test('should create instance with default params', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$limit).toBe(25);
+            expect(pq.params.$skip).toBe(0);
+            expect(pq.params.$paging).toBe(true);
+            expect(pq.params.$filter).toEqual({});
+            expect(pq.params.$sort).toEqual([]);
+            expect(pq.params.$populate).toEqual([]);
+            expect(pq.params.$select).toBe('');
+            expect(pq.params.$lean).toBe(false);
+        });
+        test('should parse filter from query string', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $filter: '{"name":"John"}' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$filter).toEqual({ name: 'John' });
+        });
+        test('should parse limit and skip', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $limit: '50', $skip: '10' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$limit).toBe(50);
+            expect(pq.params.$skip).toBe(10);
+        });
+        test('should parse sort string', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $sort: 'name 1, age -1' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$sort).toEqual([
+                ['name', 1],
+                ['age', -1]
+            ]);
+        });
+        test('should parse populate array', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $populate: 'author, books' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$populate).toEqual(['author', 'books']);
+        });
+        test('should parse paging false', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $paging: 'false' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$paging).toBe(false);
+        });
+        test('should parse paging no', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $paging: 'no' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$paging).toBe(false);
+        });
+        test('should parse paging 0', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $paging: '0' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$paging).toBe(false);
+        });
+        test('should parse select string', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $select: 'name,age,email' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$select).toBe('name,age,email');
+        });
+        test('should parse lean option', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $lean: 'true' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            expect(pq.params.$lean).toBe(true);
+        });
+    });
+    describe('options', () => {
+        test('should disable paging when disablePaging option is set', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel, { disablePaging: true });
+            expect(pq.params.$paging).toBe(false);
+        });
+        test('should disable paging when single option is set', () => {
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel, { single: true });
+            expect(pq.params.$paging).toBe(false);
+        });
+        test('should apply static filter', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $filter: '{"name":"John"}' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel, {
+                staticFilter: { active: true }
+            });
+            expect(pq.params.$filter).toEqual({ name: 'John' });
+            expect(pq.options.staticFilter).toEqual({ active: true });
+        });
+        test('should disable filter when disableFilter option is set', () => {
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $filter: '{"name":"John"}' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel, {
+                disableFilter: true,
+                staticFilter: { active: true }
+            });
+            expect(pq.options.disableFilter).toBe(true);
+        });
+    });
+    describe('exec', () => {
+        test('should execute query without paging and return results', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }];
+            mockingoose(TestModel).toReturn(mockData, 'find');
+            const req = (0, node_mocks_http_1.createRequest)({
+                query: { $paging: 'false' }
+            });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            const result = yield pq.exec();
+            // mockingoose adds additional fields like _id, createdAt, active
+            expect(result).toHaveLength(2);
+            expect(result[0]).toMatchObject({ name: 'John', age: 30 });
+            expect(result[1]).toMatchObject({ name: 'Jane', age: 25 });
+        }));
+        test('should execute query with paging and return paginated results', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }];
+            mockingoose(TestModel).toReturn(mockData, 'find');
+            mockingoose(TestModel).toReturn(100, 'countDocuments');
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel);
+            const result = yield pq.exec();
+            expect(result).toHaveProperty('items');
+            expect(result).toHaveProperty('totalRows');
+            expect(result).toHaveProperty('rows');
+            expect(result).toHaveProperty('limit');
+            expect(result).toHaveProperty('skip');
+            expect(result.limit).toBe(25);
+            expect(result.skip).toBe(0);
+        }));
+        test('should execute single query (findOne)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = { name: 'John', age: 30 };
+            mockingoose(TestModel).toReturn(mockData, 'findOne');
+            const req = (0, node_mocks_http_1.createRequest)({ query: {} });
+            const pq = new pagingQuery_1.PagingQuery(req, TestModel, { single: true });
+            const result = yield pq.exec();
+            // mockingoose adds additional fields like _id, createdAt, active
+            expect(result).toMatchObject({ name: 'John', age: 30 });
+        }));
     });
-    test('should have standard params on new', () => {
-        /*
-                mockingoose(Author)
-                const obj = new PagingQuery(req, Author, {sanitizeFilter: true})
-        
-                assert.equal(obj.params.$limit,25)*/
+    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 pagingQuery_1.PagingQuery(req, TestModel);
+            }).toThrow('Invalid JSON in $filter parameter');
+        });
     });
 });

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

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

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

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

package/dist/tests/parseParams.spec.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseParams_1 = require("../utils/parseParams");
+describe('parseParams', () => {
+    const defaultPagingParams = {
+        $filter: {},
+        $limit: 25,
+        $skip: 0,
+        $sort: [],
+        $paging: true,
+        $populate: [],
+        $select: '',
+        $lean: false
+    };
+    const defaultAggregateParams = {
+        $filter: {},
+        $limit: 25,
+        $skip: 0,
+        $sort: {},
+        $paging: true,
+        $populate: [],
+        $select: '',
+        $count: [],
+        $postFilter: {},
+        $preSort: {}
+    };
+    describe('basic parsing', () => {
+        test('should return empty object for null params', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, null);
+            expect(result).toEqual({});
+        });
+        test('should return default params when no matching keys', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { unknownKey: 'value' });
+            expect(result.$limit).toBe(25);
+            expect(result.$skip).toBe(0);
+        });
+    });
+    describe('$filter parsing', () => {
+        test('should parse JSON filter string', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $filter: '{"name":"John"}' });
+            expect(result.$filter).toEqual({ name: 'John' });
+        });
+        test('should handle complex filter object', () => {
+            const filter = '{"$and":[{"age":{"$gt":18}},{"active":true}]}';
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $filter: filter });
+            expect(result.$filter).toEqual({
+                $and: [{ age: { $gt: 18 } }, { active: true }]
+            });
+        });
+        test('should throw error for invalid JSON filter', () => {
+            expect(() => {
+                (0, parseParams_1.parseParams)(defaultPagingParams, { $filter: 'invalid json' });
+            }).toThrow('Invalid JSON in $filter parameter');
+        });
+        test('should pass through object filter', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $filter: { name: 'John' } });
+            expect(result.$filter).toEqual({ name: 'John' });
+        });
+    });
+    describe('$postFilter parsing', () => {
+        test('should parse JSON postFilter string', () => {
+            const result = (0, parseParams_1.parseParams)(defaultAggregateParams, { $postFilter: '{"status":"active"}' }, true);
+            expect(result.$postFilter).toEqual({ status: 'active' });
+        });
+        test('should throw error for invalid JSON postFilter', () => {
+            expect(() => {
+                (0, parseParams_1.parseParams)(defaultAggregateParams, { $postFilter: 'invalid' }, true);
+            }).toThrow('Invalid JSON in $postFilter parameter');
+        });
+    });
+    describe('$limit and $skip parsing', () => {
+        test('should parse limit as integer', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $limit: '50' });
+            expect(result.$limit).toBe(50);
+        });
+        test('should parse skip as integer', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $skip: '100' });
+            expect(result.$skip).toBe(100);
+        });
+        test('should handle string numbers', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $limit: '10', $skip: '20' });
+            expect(result.$limit).toBe(10);
+            expect(result.$skip).toBe(20);
+        });
+        test('should handle NaN values', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $limit: 'abc' });
+            expect(Number.isNaN(result.$limit)).toBe(true);
+        });
+    });
+    describe('$paging parsing', () => {
+        test('should set paging false for "false"', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: 'false' });
+            expect(result.$paging).toBe(false);
+        });
+        test('should set paging false for "no"', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: 'no' });
+            expect(result.$paging).toBe(false);
+        });
+        test('should set paging false for "0"', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: '0' });
+            expect(result.$paging).toBe(false);
+        });
+        test('should set paging true for "true"', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: 'true' });
+            expect(result.$paging).toBe(true);
+        });
+        test('should set paging true for "yes"', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: 'yes' });
+            expect(result.$paging).toBe(true);
+        });
+        test('should be case insensitive', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $paging: 'FALSE' });
+            expect(result.$paging).toBe(false);
+        });
+    });
+    describe('$sort parsing', () => {
+        test('should parse sort string for paging query', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $sort: 'name 1' });
+            expect(result.$sort).toEqual([['name', 1]]);
+        });
+        test('should parse multiple sort fields', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $sort: 'name 1, age -1' });
+            expect(result.$sort).toEqual([['name', 1], ['age', -1]]);
+        });
+        test('should parse sort string for aggregate query', () => {
+            const result = (0, parseParams_1.parseParams)(defaultAggregateParams, { $sort: 'name 1' }, true);
+            expect(result.$sort).toEqual({ name: 1 });
+        });
+        test('should parse preSort for aggregate query', () => {
+            const result = (0, parseParams_1.parseParams)(defaultAggregateParams, { $preSort: 'createdAt -1' }, true);
+            expect(result.$preSort).toEqual({ createdAt: -1 });
+        });
+    });
+    describe('$count and $populate parsing', () => {
+        test('should parse count as array', () => {
+            const result = (0, parseParams_1.parseParams)(defaultAggregateParams, { $count: 'items,orders' }, true);
+            expect(result.$count).toEqual(['items', 'orders']);
+        });
+        test('should parse populate as array', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $populate: 'author,books' });
+            expect(result.$populate).toEqual(['author', 'books']);
+        });
+        test('should trim whitespace from array items', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $populate: 'author , books , category' });
+            expect(result.$populate).toEqual(['author', 'books', 'category']);
+        });
+    });
+    describe('$select parsing', () => {
+        test('should parse select string', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $select: 'name,age,email' });
+            expect(result.$select).toBe('name,age,email');
+        });
+        test('should preserve select string as-is', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $select: '-password -secret' });
+            expect(result.$select).toBe('-password -secret');
+        });
+    });
+    describe('$lean parsing', () => {
+        test('should set lean to true when present', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $lean: 'true' });
+            expect(result.$lean).toBe(true);
+        });
+        test('should set lean to true for any value', () => {
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, { $lean: 'anything' });
+            expect(result.$lean).toBe(true);
+        });
+    });
+    describe('combined parsing', () => {
+        test('should parse all params together', () => {
+            const params = {
+                $filter: '{"active":true}',
+                $limit: '10',
+                $skip: '5',
+                $sort: 'name 1',
+                $paging: 'true',
+                $populate: 'author',
+                $select: 'name,email',
+                $lean: 'true'
+            };
+            const result = (0, parseParams_1.parseParams)(defaultPagingParams, params);
+            expect(result.$filter).toEqual({ active: true });
+            expect(result.$limit).toBe(10);
+            expect(result.$skip).toBe(5);
+            expect(result.$sort).toEqual([['name', 1]]);
+            expect(result.$paging).toBe(true);
+            expect(result.$populate).toEqual(['author']);
+            expect(result.$select).toBe('name,email');
+            expect(result.$lean).toBe(true);
+        });
+        test('should parse aggregate params together', () => {
+            const params = {
+                $filter: '{"status":"active"}',
+                $limit: '20',
+                $skip: '10',
+                $sort: 'createdAt -1',
+                $preSort: 'priority 1',
+                $postFilter: '{"verified":true}',
+                $count: 'items',
+                $select: 'name,status'
+            };
+            const result = (0, parseParams_1.parseParams)(defaultAggregateParams, params, true);
+            expect(result.$filter).toEqual({ status: 'active' });
+            expect(result.$limit).toBe(20);
+            expect(result.$skip).toBe(10);
+            expect(result.$sort).toEqual({ createdAt: -1 });
+            expect(result.$preSort).toEqual({ priority: 1 });
+            expect(result.$postFilter).toEqual({ verified: true });
+            expect(result.$count).toEqual(['items']);
+            expect(result.$select).toBe('name,status');
+        });
+    });
+});

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

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

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

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

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

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

package/dist/tests/schemaTraversal.spec.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schemaTraversal_1 = require("../utils/schemaTraversal");
+describe('schemaTraversal', () => {
+    describe('buildFullPath', () => {
+        test('should return child path when parent is empty', () => {
+            expect((0, schemaTraversal_1.buildFullPath)('', 'child')).toBe('child');
+        });
+        test('should return parent path when child is empty', () => {
+            expect((0, schemaTraversal_1.buildFullPath)('parent', '')).toBe('parent');
+        });
+        test('should combine parent and child with dot notation', () => {
+            expect((0, schemaTraversal_1.buildFullPath)('parent', 'child')).toBe('parent.child');
+        });
+        test('should handle deeply nested paths', () => {
+            expect((0, schemaTraversal_1.buildFullPath)('parent.nested', 'child')).toBe('parent.nested.child');
+        });
+        test('should handle empty strings for both', () => {
+            expect((0, schemaTraversal_1.buildFullPath)('', '')).toBe('');
+        });
+    });
+    describe('traverseSchemaObject', () => {
+        test('should call callback for current object', () => {
+            const obj = { path: 'test', options: { type: 'String' } };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            expect(callback).toHaveBeenCalledWith(obj, '');
+        });
+        test('should handle null object', () => {
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(null, callback);
+            expect(callback).not.toHaveBeenCalled();
+        });
+        test('should handle undefined object', () => {
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(undefined, callback);
+            expect(callback).not.toHaveBeenCalled();
+        });
+        test('should handle non-object values', () => {
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)('string', callback);
+            (0, schemaTraversal_1.traverseSchemaObject)(123, callback);
+            (0, schemaTraversal_1.traverseSchemaObject)(true, callback);
+            expect(callback).not.toHaveBeenCalled();
+        });
+        test('should traverse nested paths in options.type.paths', () => {
+            const obj = {
+                path: 'parent',
+                options: {
+                    type: {
+                        paths: {
+                            child1: { path: 'child1', selected: false },
+                            child2: { path: 'child2', selected: true }
+                        }
+                    }
+                }
+            };
+            const visitedPaths = [];
+            const callback = jest.fn((obj, path) => {
+                if (obj.path)
+                    visitedPaths.push(obj.path);
+            });
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            expect(callback).toHaveBeenCalledTimes(3); // parent + 2 children
+            expect(visitedPaths).toContain('parent');
+            expect(visitedPaths).toContain('child1');
+            expect(visitedPaths).toContain('child2');
+        });
+        test('should traverse nested type object without paths', () => {
+            const obj = {
+                path: 'parent',
+                options: {
+                    type: {
+                        ref: 'SomeModel',
+                        nested: { path: 'nested' }
+                    }
+                }
+            };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            // Should call for parent and nested type
+            expect(callback).toHaveBeenCalled();
+        });
+        test('should use provided currentPath', () => {
+            const obj = { path: 'test' };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback, 'existingPath');
+            expect(callback).toHaveBeenCalledWith(obj, 'existingPath');
+        });
+        test('should use obj.path as parent path for nested traversal', () => {
+            const obj = {
+                path: 'parent',
+                options: {
+                    type: {
+                        paths: {
+                            child: { path: 'child', selected: false }
+                        }
+                    }
+                }
+            };
+            const paths = [];
+            const callback = jest.fn((obj, path) => {
+                paths.push(path);
+            });
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            // First call with empty path, second call with 'parent' as path
+            expect(paths).toContain('');
+            expect(paths).toContain('parent');
+        });
+        test('should handle object with no options', () => {
+            const obj = { path: 'simple' };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            expect(callback).toHaveBeenCalledWith(obj, '');
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+        test('should handle object with options but no type', () => {
+            const obj = { path: 'test', options: { required: true } };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            expect(callback).toHaveBeenCalledWith(obj, '');
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+        test('should handle empty paths object', () => {
+            const obj = {
+                path: 'parent',
+                options: {
+                    type: {
+                        paths: {}
+                    }
+                }
+            };
+            const callback = jest.fn();
+            (0, schemaTraversal_1.traverseSchemaObject)(obj, callback);
+            // Should only call for parent since paths is empty
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+    });
+});