@r5v/mongoose-paginate 1.0.0

package/dist/tests/dotNotation.spec.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotNotation_1 = require("../utils/dotNotation");
+describe('dotNotationToObject', () => {
+    test('should create simple nested object', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('user.name', 'John Doe');
+        expect(result).toEqual({
+            user: {
+                name: 'John Doe'
+            }
+        });
+    });
+    test('should create deeply nested object', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('user.profile.personal.name', 'Jane Smith');
+        expect(result).toEqual({
+            user: {
+                profile: {
+                    personal: {
+                        name: 'Jane Smith'
+                    }
+                }
+            }
+        });
+    });
+    test('should handle single key (no dots)', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('name', 'Alice');
+        expect(result).toEqual({
+            name: 'Alice'
+        });
+    });
+    test('should handle null value', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('user.name', null);
+        expect(result).toEqual({
+            user: {
+                name: null
+            }
+        });
+    });
+    test('should handle undefined value', () => {
+        let a;
+        const result = (0, dotNotation_1.dotNotationToObject)('user.name', a);
+        expect(result).toEqual({
+            user: {
+                name: null
+            }
+        });
+    });
+    test('should handle different value types', () => {
+        expect((0, dotNotation_1.dotNotationToObject)('user.age', 25)).toEqual({
+            user: { age: 25 }
+        });
+        expect((0, dotNotation_1.dotNotationToObject)('user.active', true)).toEqual({
+            user: { active: true }
+        });
+        expect((0, dotNotation_1.dotNotationToObject)('user.tags', ['admin', 'user'])).toEqual({
+            user: { tags: ['admin', 'user'] }
+        });
+        expect((0, dotNotation_1.dotNotationToObject)('user.meta', { created: '2023-01-01' })).toEqual({
+            user: { meta: { created: '2023-01-01' } }
+        });
+    });
+    test('should handle empty string key', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('user..name', 'Test');
+        expect(result).toEqual({
+            user: {
+                '': {
+                    name: 'Test'
+                }
+            }
+        });
+    });
+    test('should use null as default value when no value provided', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('user.name');
+        expect(result).toEqual({
+            user: {
+                name: null
+            }
+        });
+    });
+});
+describe('createObjectFromDotNotation', () => {
+    test('should create object from single dot notation entry', () => {
+        const input = {
+            'user.name': 'John Doe'
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            user: {
+                name: 'John Doe'
+            }
+        });
+    });
+    test('should merge multiple dot notation entries', () => {
+        const input = {
+            'user.profile.name': 'John Doe',
+            'user.profile.age': 30,
+            'user.settings.theme': 'dark'
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            user: {
+                profile: {
+                    name: 'John Doe',
+                    age: 30
+                },
+                settings: {
+                    theme: 'dark'
+                }
+            }
+        });
+    });
+    test('should handle complex nested structure', () => {
+        const input = {
+            'app.name': 'MyApp',
+            'app.version': '1.0.0',
+            'app.config.database.host': 'localhost',
+            'app.config.database.port': 5432,
+            'app.config.redis.host': 'redis-server',
+            'app.features.auth.enabled': true,
+            'app.features.auth.providers': ['google', 'github'],
+            'app.features.notifications.email': true,
+            'app.features.notifications.push': false
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            app: {
+                name: 'MyApp',
+                version: '1.0.0',
+                config: {
+                    database: {
+                        host: 'localhost',
+                        port: 5432
+                    },
+                    redis: {
+                        host: 'redis-server'
+                    }
+                },
+                features: {
+                    auth: {
+                        enabled: true,
+                        providers: ['google', 'github']
+                    },
+                    notifications: {
+                        email: true,
+                        push: false
+                    }
+                }
+            }
+        });
+    });
+    test('should handle conflicting paths by overwriting', () => {
+        const input = {
+            'user.name': 'John',
+            'user.name.first': 'John',
+            'user.name.last': 'Doe'
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        // The object should be overwritten when there's a conflict
+        expect(result).toEqual({
+            user: {
+                name: {
+                    first: 'John',
+                    last: 'Doe'
+                }
+            }
+        });
+    });
+    test('should handle empty object', () => {
+        const result = (0, dotNotation_1.createObjectFromDotNotation)({});
+        expect(result).toEqual({});
+    });
+    test('should handle single key without dots', () => {
+        const input = {
+            'name': 'John Doe',
+            'age': 30
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            name: 'John Doe',
+            age: 30
+        });
+    });
+    test('should handle various value types', () => {
+        const input = {
+            'string': 'text',
+            'number': 42,
+            'boolean': true,
+            'null': null,
+            'undefined': undefined,
+            'array': [1, 2, 3],
+            'object': { nested: 'value' }
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            string: 'text',
+            number: 42,
+            boolean: true,
+            null: null,
+            undefined: undefined,
+            array: [1, 2, 3],
+            object: { nested: 'value' }
+        });
+    });
+    test('should handle empty string keys', () => {
+        const input = {
+            'user..name': 'Test',
+            'user...deep': 'Value'
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            user: {
+                '': {
+                    name: 'Test',
+                    '': {
+                        deep: 'Value'
+                    }
+                }
+            }
+        });
+    });
+});
+describe('Edge cases and error handling', () => {
+    test('dotNotationToObject should handle empty string', () => {
+        const result = (0, dotNotation_1.dotNotationToObject)('', 'value');
+        expect(result).toEqual({
+            '': 'value'
+        });
+    });
+    test('createObjectFromDotNotation should handle keys with empty string', () => {
+        const input = {
+            '': 'root value'
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result).toEqual({
+            '': 'root value'
+        });
+    });
+    test('should preserve object references', () => {
+        const sharedObject = { shared: 'data' };
+        const input = {
+            'user.meta': sharedObject,
+            'app.config': sharedObject
+        };
+        const result = (0, dotNotation_1.createObjectFromDotNotation)(input);
+        expect(result.user.meta).toBe(sharedObject);
+        expect(result.app.config).toBe(sharedObject);
+        expect(result.user.meta).toBe(result.app.config);
+    });
+});

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

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

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":""}

package/dist/tests/findProtectedPaths.spec.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockingoose = require("mockingoose");
+// Build Test Schemas
+describe('findProtectedPaths', () => {
+    it('returns expected array', () => {
+        /*        mockingoose();
+                const results = findProtectedPaths()
+                console.log(results)*/
+    });
+});

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

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

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

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

package/dist/tests/getPathsWithRef.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPathsWithRef_1 = require("../utils/getPathsWithRef");
+const data = [{ "enumValues": [], "regExp": null, "path": "firstName", "instance": "String", "validators": [{ "message": "Path `{PATH}` is required.", "type": "required" }], "getters": [], "setters": [null], "_presplitPath": ["firstName"], "options": { "required": true, "trim": true }, "_index": null, "isRequired": true, "originalRequiredValue": true },
+    { "enumValues": [], "regExp": null, "path": "lastName", "instance": "String", "validators": [{ "message": "Path `{PATH}` is required.", "type": "required" }], "getters": [], "setters": [null], "_presplitPath": ["lastName"], "options": { "required": true, "trim": true }, "_index": null, "isRequired": true, "originalRequiredValue": true },
+    { "enumValues": [], "regExp": null, "path": "email", "instance": "String", "validators": [], "getters": [], "setters": [null, null], "_presplitPath": ["email"], "options": { "unique": true, "lowercase": true, "trim": true }, "_index": { "unique": true, "background": true } },
+    { "enumValues": [], "regExp": null, "path": "c.child.str", "instance": "String", "validators": [], "getters": [], "setters": [], "_presplitPath": ["c", "child", "str"], "options": { "selected": false }, "_index": null },
+    { "path": "c.child.grandchild", "options": { "type": { "obj": { "test": { "select": false } }, "paths": { "test": { "enumValues": [], "regExp": null, "path": "test", "instance": "String", "validators": [], "getters": [], "setters": [], "_presplitPath": ["test"], "options": { "select": false }, "_index": null, "selected": false }, "_id": { "path": "_id", "instance": "ObjectId", "validators": [], "getters": [], "setters": [null], "_presplitPath": ["_id"], "options": { "auto": true, "type": "ObjectId" }, "_index": null } }, "aliases": {}, "subpaths": {}, "virtuals": { "id": { "path": "id", "getters": [null], "setters": [], "options": {} } }, "singleNestedPaths": {}, "nested": {}, "inherits": {}, "callQueue": [], "_indexes": [], "_searchIndexes": [], "methods": {}, "methodOptions": {}, "statics": {}, "tree": { "test": { "select": false }, "_id": { "auto": true, "type": "ObjectId" }, "id": { "path": "id", "getters": [null], "setters": [], "options": {} } }, "query": {}, "childSchemas": [], "plugins": [{ "opts": { "deduplicate": true } }, { "opts": { "deduplicate": true } }, { "opts": { "deduplicate": true } }, { "opts": { "deduplicate": true } }, { "opts": { "deduplicate": true } }], "$id": 1, "mapPaths": [], "encryptedFields": {}, "s": { "hooks": { "_pres": {}, "_posts": {} } }, "_userProvidedOptions": {}, "options": { "strict": true, "strictQuery": false, "bufferCommands": true, "capped": false, "versionKey": "__v", "optimisticConcurrency": false, "minimize": true, "autoIndex": null, "discriminatorKey": "__t", "shardKey": null, "read": null, "validateBeforeSave": true, "validateModifiedOnly": false, "_id": true, "id": true, "typeKey": "type" }, "$globalPluginsApplied": true } } },
+    { "enumValues": [], "regExp": null, "path": "biography", "instance": "String", "validators": [{ "message": "Path `{PATH}` (`{VALUE}`) is longer than the maximum allowed length (2000).", "type": "maxlength", "maxlength": 2000 }], "getters": [], "setters": [], "_presplitPath": ["biography"], "options": { "select": false, "maxlength": 2000 }, "_index": null, "selected": false },
+    { "path": "birthDate", "instance": "Date", "validators": [], "getters": [], "setters": [], "_presplitPath": ["birthDate"], "options": {}, "_index": null },
+    { "enumValues": [], "regExp": null, "path": "nationality", "instance": "String", "validators": [], "getters": [], "setters": [null], "_presplitPath": ["nationality"], "options": { "trim": true }, "_index": null },
+    { "enumValues": [], "regExp": null, "path": "website", "instance": "String", "validators": [], "getters": [], "setters": [null], "_presplitPath": ["website"], "options": { "trim": true }, "_index": null },
+    { "enumValues": [], "regExp": null, "path": "socialMedia.twitter", "instance": "String", "validators": [], "getters": [], "setters": [], "_presplitPath": ["socialMedia", "twitter"], "options": {}, "_index": null },
+    { "enumValues": [], "regExp": null, "path": "socialMedia.instagram", "instance": "String", "validators": [], "getters": [], "setters": [], "_presplitPath": ["socialMedia", "instagram"], "options": {}, "_index": null },
+    { "enumValues": [], "regExp": null, "path": "socialMedia.facebook", "instance": "String", "validators": [], "getters": [], "setters": [], "_presplitPath": ["socialMedia", "facebook"], "options": {}, "_index": null },
+    { "schemaOptions": { "strict": true, "strictQuery": false, "bufferCommands": true, "capped": false, "versionKey": "__v", "optimisticConcurrency": false, "minimize": true, "autoIndex": null, "discriminatorKey": "__t", "shardKey": null, "read": null, "validateBeforeSave": true, "validateModifiedOnly": false, "_id": true, "id": true, "typeKey": "type", "timestamps": true, "toJSON": { "virtuals": true }, "toObject": { "virtuals": true }, "pluralization": true }, "caster": { "path": "books", "instance": "ObjectId", "validators": [], "getters": [], "setters": [], "_presplitPath": ["books"], "options": { "ref": "Book" }, "_index": null, "_arrayPath": "books.$", "_arrayParentPath": "books" }, "$embeddedSchemaType": { "path": "books", "instance": "ObjectId", "validators": [], "getters": [], "setters": [], "_presplitPath": ["books"], "options": { "ref": "Book" }, "_index": null, "_arrayPath": "books.$", "_arrayParentPath": "books" }, "$isMongooseArray": true, "path": "books", "instance": "Array", "validators": [], "getters": [], "setters": [], "_presplitPath": ["books"], "options": { "type": [{ "ref": "Book" }] }, "_index": null },
+    { "path": "book", "instance": "ObjectId", "validators": [], "getters": [], "setters": [], "_presplitPath": ["book"], "options": { "ref": "Book" }, "_index": null },
+    { "path": "isActive", "instance": "Boolean", "validators": [], "getters": [], "setters": [], "_presplitPath": ["isActive"], "options": { "default": true }, "_index": null, "defaultValue": true },
+    { "path": "_id", "instance": "ObjectId", "validators": [], "getters": [], "setters": [null], "_presplitPath": ["_id"], "options": { "auto": true, "type": "ObjectId" }, "_index": null },
+    { "path": "createdAt", "instance": "Date", "validators": [], "getters": [], "setters": [null, null], "_presplitPath": ["createdAt"], "options": { "immutable": true }, "_index": null, "$immutable": true },
+    { "path": "updatedAt", "instance": "Date", "validators": [], "getters": [], "setters": [], "_presplitPath": ["updatedAt"], "options": {}, "_index": null },
+    { "path": "__v", "instance": "Number", "validators": [], "getters": [], "setters": [], "_presplitPath": ["__v"], "options": {}, "_index": null }
+];
+describe('getPathsWithRef', () => {
+    it('returns correct values', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(data);
+    });
+});

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

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

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

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

package/dist/tests/getPropertyFromDotNotation.spec.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import the function (assuming it's exported from a module)
+const dotNotation_1 = require("../utils/dotNotation");
+describe('getPropertyFromDotNotation', () => {
+    const testObject = {
+        user: {
+            profile: {
+                name: 'John Doe',
+                age: 30,
+                address: {
+                    street: '123 Main St',
+                    city: 'New York',
+                    zipCode: '10001'
+                }
+            },
+            settings: {
+                theme: 'dark',
+                notifications: {
+                    email: true,
+                    push: false,
+                    sms: null
+                }
+            },
+            tags: ['admin', 'user'],
+            active: true,
+            score: 0,
+            metadata: {
+                created: '2023-01-01',
+                updated: null
+            }
+        },
+        app: {
+            version: '1.0.0',
+            features: {
+                auth: true
+            }
+        }
+    };
+    test('should retrieve simple nested property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.profile.name');
+        expect(result).toBe('John Doe');
+    });
+    test('should retrieve deeply nested property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.profile.address.street');
+        expect(result).toBe('123 Main St');
+    });
+    test('should retrieve top-level property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'app');
+        expect(result).toEqual({
+            version: '1.0.0',
+            features: {
+                auth: true
+            }
+        });
+    });
+    test('should retrieve array property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.tags');
+        expect(result).toEqual(['admin', 'user']);
+    });
+    test('should retrieve boolean property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.active');
+        expect(result).toBe(true);
+        const result2 = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.settings.notifications.push');
+        expect(result2).toBe(false);
+    });
+    test('should retrieve number property including zero', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.profile.age');
+        expect(result).toBe(30);
+        const result2 = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.score');
+        expect(result2).toBe(0);
+    });
+    test('should retrieve null values', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.settings.notifications.sms');
+        expect(result).toBeNull();
+        const result2 = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.metadata.updated');
+        expect(result2).toBeNull();
+    });
+    test('should return undefined for non-existent property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.nonExistent');
+        expect(result).toBeUndefined();
+    });
+    test('should return undefined for deeply nested non-existent property', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, 'user.profile.nonExistent.deeply.nested');
+        expect(result).toBeUndefined();
+    });
+    test('should handle empty path', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(testObject, '');
+        expect(result).toBeUndefined();
+    });
+    test('should handle single property name (no dots)', () => {
+        const simpleObject = { name: 'test' };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(simpleObject, 'name');
+        expect(result).toBe('test');
+    });
+    test('should handle null object', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(null, 'user.name');
+        expect(result).toBeNull();
+    });
+    test('should handle undefined object', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(undefined, 'user.name');
+        expect(result).toBeUndefined();
+    });
+    test('should handle empty object', () => {
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)({}, 'user.name');
+        expect(result).toBeUndefined();
+    });
+    test('should handle path with empty string segments', () => {
+        const objWithEmptyKey = {
+            user: {
+                '': {
+                    name: 'test'
+                }
+            }
+        };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithEmptyKey, 'user..name');
+        expect(result).toBe('test');
+    });
+    test('should handle numeric string keys', () => {
+        const objWithNumericKeys = {
+            items: {
+                '0': 'first',
+                '1': 'second'
+            }
+        };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithNumericKeys, 'items.0');
+        expect(result).toBe('first');
+    });
+    test('should handle array access with numeric keys', () => {
+        const objWithArray = {
+            list: ['item1', 'item2', 'item3']
+        };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithArray, 'list.1');
+        expect(result).toBe('item2');
+    });
+    test('should handle special characters in keys', () => {
+        const objWithSpecialKeys = {
+            'user-name': 'test',
+            'user_id': 123,
+            'user@domain': 'email'
+        };
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(objWithSpecialKeys, 'user-name')).toBe('test');
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(objWithSpecialKeys, 'user_id')).toBe(123);
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(objWithSpecialKeys, 'user@domain')).toBe('email');
+    });
+    test('should handle complex nested structures', () => {
+        const complexObject = {
+            data: {
+                results: [
+                    { id: 1, name: 'First' },
+                    { id: 2, name: 'Second' }
+                ],
+                pagination: {
+                    total: 2,
+                    page: 1
+                }
+            }
+        };
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(complexObject, 'data.results.0.name')).toBe('First');
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(complexObject, 'data.pagination.total')).toBe(2);
+    });
+    test('should handle function properties', () => {
+        const objWithFunction = {
+            utils: {
+                getValue: () => 'function result'
+            }
+        };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithFunction, 'utils.getValue');
+        expect(typeof result).toBe('function');
+        expect(result()).toBe('function result');
+    });
+    test('should handle Symbol keys', () => {
+        const symbolKey = Symbol('test');
+        const objWithSymbol = {
+            data: {
+                [symbolKey]: 'symbol value'
+            }
+        };
+        // This should return undefined since symbols can't be accessed via string paths
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithSymbol, 'data.Symbol(test)');
+        expect(result).toBeUndefined();
+    });
+    test('should handle prototype chain properties', () => {
+        function TestClass() {
+            this.instanceProp = 'instance';
+        }
+        TestClass.prototype.prototypeProp = 'prototype';
+        const instance = new TestClass();
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(instance, 'instanceProp')).toBe('instance');
+        expect((0, dotNotation_1.getPropertyFromDotNotation)(instance, 'prototypeProp')).toBe('prototype');
+    });
+    test('should handle Date objects', () => {
+        const objWithDate = {
+            event: {
+                date: new Date('2023-01-01T10:00:00Z')
+            }
+        };
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(objWithDate, 'event.date');
+        expect(result).toBeInstanceOf(Date);
+        expect(result.getFullYear()).toBe(2023);
+    });
+    test('should handle performance with deeply nested objects', () => {
+        // Create a deeply nested object
+        let deepObject = { value: 'deep' };
+        let path = 'value';
+        for (let i = 0; i < 100; i++) {
+            deepObject = { level: deepObject };
+            path = 'level.' + path;
+        }
+        const result = (0, dotNotation_1.getPropertyFromDotNotation)(deepObject, path);
+        expect(result).toBe('deep');
+    });
+});

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

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

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

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

package/dist/tests/insertPopulate.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const parsePopulateQuery_1 = require("../utils/parsePopulateQuery");
+describe('parsePopulateQuery', () => {
+    it('should return a populated path object', () => {
+        const { pop, select } = { pop: ['books'], select: [] };
+        const [r1] = (0, parsePopulateQuery_1.parsePopulateArray)(pop, select);
+        (0, node_assert_1.default)(r1.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(!r1.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.path === 'books', 'object contains expected value in path object');
+    });
+    it('should return a populated path and selectobject', () => {
+        const { pop, select } = { pop: ['books'], select: ['books.items'] };
+        const [r1] = (0, parsePopulateQuery_1.parsePopulateArray)(pop, select);
+        (0, node_assert_1.default)(r1.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(r1.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.path === 'books', 'object contains expected value in path object');
+        (0, node_assert_1.default)(r1.select.hasOwnProperty('items'), 'object contains expected value in select object');
+        (0, node_assert_1.default)(r1.select.items === 1, 'object contains expected value in select object');
+    });
+    it('should return a falsy 0 in the item select', () => {
+        const { pop, select } = { pop: ['books'], select: ['books.-items'] };
+        const [r1] = (0, parsePopulateQuery_1.parsePopulateArray)(pop, select);
+        (0, node_assert_1.default)(r1.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(r1.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.path === 'books', 'object contains expected value in path object');
+        (0, node_assert_1.default)(r1.select.hasOwnProperty('items'), 'object contains expected value in select object');
+        (0, node_assert_1.default)(r1.select.items === 0, 'object contains expected value in select object');
+    });
+    it('should return array with more than one item', () => {
+        const { pop, select } = { pop: ['books', 'author'], select: [] };
+        const popArr = (0, parsePopulateQuery_1.parsePopulateArray)(pop, select);
+        const [r1, r2] = popArr;
+        node_assert_1.default.equal(popArr.length, 2, 'array has the proper length');
+        (0, node_assert_1.default)(r1.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(!r1.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.path === 'books', 'object contains expected value in path object');
+        (0, node_assert_1.default)(r2.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(!r2.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r2.path === 'author', 'object contains expected value in path object');
+    });
+    it('should return array with more than one item and select', () => {
+        const { pop, select } = { pop: ['books', 'author'], select: ['books.items', 'author.-items.passage', 'author.test.passage'] };
+        const popArr = (0, parsePopulateQuery_1.parsePopulateArray)(pop, select);
+        const [r1, r2] = popArr;
+        node_assert_1.default.equal(popArr.length, 2, 'array has the proper length');
+        (0, node_assert_1.default)(r1.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(r1.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.select.hasOwnProperty('items'), 'object contains a select key');
+        (0, node_assert_1.default)(r1.path === 'books', 'object contains expected value in path object');
+        (0, node_assert_1.default)(r1.select.items === 1, 'object contains expected value in path object');
+        (0, node_assert_1.default)(r2.hasOwnProperty('path'), 'object does not contain path key');
+        (0, node_assert_1.default)(r2.hasOwnProperty('select'), 'object contains a select key');
+        (0, node_assert_1.default)(r2.select.hasOwnProperty('items.passage'), 'object contains a select key');
+        (0, node_assert_1.default)(r2.select.hasOwnProperty('test.passage'), 'object contains a select key');
+        node_assert_1.default.equal(r2.select['items.passage'], 0, 'objects select key is the correct value');
+        node_assert_1.default.equal(r2.select['test.passage'], 1, 'objects select key is the correct value');
+        (0, node_assert_1.default)(r2.path === 'author', 'object contains expected value in path object');
+    });
+});

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

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

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

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

package/dist/tests/pagingQuery.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockingoose = require('mockingoose');
+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'
+    } });
+describe('PagingQuery', () => {
+    beforeEach(() => {
+        // Reset mockingoose before each test to ensure isolation
+        // mockingoose.resetAll();
+    });
+    test('should have standard params on new', () => {
+        /*
+                mockingoose(Author)
+                const obj = new PagingQuery(req, Author, {sanitizeFilter: true})
+        
+                assert.equal(obj.params.$limit,25)*/
+    });
+});

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

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

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":""}