@r5v/mongoose-paginate 1.0.13 → 1.0.15

package/dist/tests/findProtectedPaths.spec.js

@@ -1,11 +1,133 @@
 "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");
-// Build Test Schemas
+const findProtectedPaths_1 = require("../utils/findProtectedPaths");
+const mongoose_1 = __importStar(require("mongoose"));
 describe('findProtectedPaths', () => {
-    it('returns expected array', () => {
-        /*        mockingoose();
-                const results = findProtectedPaths()
-                console.log(results)*/
+    afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
+        // Clean up mongoose connections
+        yield mongoose_1.default.disconnect();
+    }));
+    test('should return empty array for schema with no protected paths', () => {
+        const schema = new mongoose_1.Schema({
+            name: { type: String },
+            age: { type: Number }
+        });
+        const model = mongoose_1.default.model('NoProtectedModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results).toEqual([]);
+    });
+    test('should find paths with select: false', () => {
+        const schema = new mongoose_1.Schema({
+            name: { type: String },
+            password: { type: String, select: false },
+            email: { type: String }
+        });
+        const model = mongoose_1.default.model('ProtectedModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results).toContain('password');
+    });
+    test('should find multiple protected paths', () => {
+        const schema = new mongoose_1.Schema({
+            name: { type: String },
+            password: { type: String, select: false },
+            secretKey: { type: String, select: false },
+            email: { type: String }
+        });
+        const model = mongoose_1.default.model('MultiProtectedModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results).toContain('password');
+        expect(results).toContain('secretKey');
+        expect(results.length).toBe(2);
+    });
+    test('should find protected paths in nested objects', () => {
+        const schema = new mongoose_1.Schema({
+            name: { type: String },
+            profile: {
+                bio: { type: String },
+                privateData: { type: String, select: false }
+            }
+        });
+        const model = mongoose_1.default.model('NestedProtectedModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results.some(p => p.includes('privateData'))).toBe(true);
+    });
+    test('should handle schema with mixed regular and protected fields', () => {
+        const schema = new mongoose_1.Schema({
+            username: { type: String, required: true },
+            email: { type: String, unique: true },
+            password: { type: String, select: false },
+            apiKey: { type: String, select: false },
+            createdAt: { type: Date, default: Date.now }
+        });
+        const model = mongoose_1.default.model('MixedFieldsModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results).toContain('password');
+        expect(results).toContain('apiKey');
+        expect(results).not.toContain('username');
+        expect(results).not.toContain('email');
+        expect(results).not.toContain('createdAt');
+    });
+    test('should handle deeply nested schema with protected paths', () => {
+        const nestedSchema = new mongoose_1.Schema({
+            secret: { type: String, select: false }
+        }, { _id: false });
+        const schema = new mongoose_1.Schema({
+            name: { type: String },
+            nested: nestedSchema
+        });
+        const model = mongoose_1.default.model('DeepNestedModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(results.some(p => p.includes('secret'))).toBe(true);
+    });
+    test('should return empty array when schema has simple array fields', () => {
+        const schema = new mongoose_1.Schema({
+            tags: [String],
+            scores: [Number]
+        });
+        const model = mongoose_1.default.model('ArrayFieldsModel', schema);
+        const results = (0, findProtectedPaths_1.findProtectedPaths)(model);
+        expect(Array.isArray(results)).toBe(true);
     });
 });

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

@@ -1,28 +1,102 @@
 "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 },
+const sampleSchemaData = [
+    { "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 },
+    { "schemaOptions": { "strict": 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": "author", "instance": "ObjectId", "validators": [], "getters": [], "setters": [], "_presplitPath": ["author"], "options": { "ref": "Author" }, "_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 }
+    { "path": "_id", "instance": "ObjectId", "validators": [], "getters": [], "setters": [null], "_presplitPath": ["_id"], "options": { "auto": true, "type": "ObjectId" }, "_index": null }
 ];
 describe('getPathsWithRef', () => {
-    it('returns correct values', () => {
-        const results = (0, getPathsWithRef_1.getPathsWithRef)(data);
+    test('should return correct paths with ref from array data', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        expect(Array.isArray(results)).toBe(true);
+        expect(results.length).toBeGreaterThan(0);
+        const paths = results.map(r => r.path);
+        expect(paths).toContain('books');
+        expect(paths).toContain('author');
+    });
+    test('should return path and options for each ref', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        results.forEach(result => {
+            expect(result).toHaveProperty('path');
+            expect(result).toHaveProperty('options');
+        });
+    });
+    test('should correctly identify ref in options', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        const authorRef = results.find(r => r.path === 'author');
+        expect(authorRef).toBeDefined();
+        expect(authorRef === null || authorRef === void 0 ? void 0 : authorRef.options.ref).toBe('Author');
+    });
+    test('should correctly identify ref in array type', () => {
+        var _a, _b;
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        const booksRef = results.find(r => r.path === 'books');
+        expect(booksRef).toBeDefined();
+        // For array types, the ref is in options.type[0].ref or caster.options.ref
+        expect(((_b = (_a = booksRef === null || booksRef === void 0 ? void 0 : booksRef.options.type) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.ref) || (booksRef === null || booksRef === void 0 ? void 0 : booksRef.options.ref)).toBe('Book');
+    });
+    test('should not include paths without ref', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        const paths = results.map(r => r.path);
+        expect(paths).not.toContain('firstName');
+        expect(paths).not.toContain('lastName');
+        expect(paths).not.toContain('email');
+        expect(paths).not.toContain('isActive');
+        expect(paths).not.toContain('_id');
+    });
+    test('should handle empty array', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)([]);
+        expect(Array.isArray(results)).toBe(true);
+        expect(results.length).toBe(0);
+    });
+    test('should handle array with no refs', () => {
+        const dataWithoutRefs = [
+            { "path": "name", "instance": "String", "options": { "required": true } },
+            { "path": "age", "instance": "Number", "options": {} }
+        ];
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(dataWithoutRefs);
+        expect(results.length).toBe(0);
+    });
+    test('should handle string input', () => {
+        const stringData = JSON.stringify({ "path": "user", "instance": "ObjectId", "options": { "ref": "User" } });
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(stringData);
+        expect(Array.isArray(results)).toBe(true);
+    });
+    test('should not have duplicate paths', () => {
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(sampleSchemaData);
+        const paths = results.map(r => r.path);
+        const uniquePaths = [...new Set(paths)];
+        expect(paths.length).toBe(uniquePaths.length);
+    });
+    test('should handle nested refs in options.type array', () => {
+        const nestedRefData = [
+            {
+                "path": "categories",
+                "instance": "Array",
+                "options": {
+                    "type": [{ "ref": "Category" }]
+                }
+            }
+        ];
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(nestedRefData);
+        expect(results.some(r => r.path === 'categories')).toBe(true);
+    });
+    test('should handle ref in options.type object', () => {
+        const typeObjectRefData = [
+            {
+                "path": "parent",
+                "instance": "ObjectId",
+                "options": {
+                    "type": { "ref": "Parent" }
+                }
+            }
+        ];
+        const results = (0, getPathsWithRef_1.getPathsWithRef)(typeObjectRefData);
+        expect(results.some(r => r.path === 'parent')).toBe(true);
     });
 });

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/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/isJsonString.spec.d.ts

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

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

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

package/dist/tests/isJsonString.spec.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isJsonString_1 = require("../utils/isJsonString");
+describe('isJsonString', () => {
+    describe('valid JSON strings', () => {
+        test('should return true for empty object', () => {
+            expect((0, isJsonString_1.isJsonString)('{}')).toBe(true);
+        });
+        test('should return true for empty array', () => {
+            expect((0, isJsonString_1.isJsonString)('[]')).toBe(true);
+        });
+        test('should return true for simple object', () => {
+            expect((0, isJsonString_1.isJsonString)('{"name":"John"}')).toBe(true);
+        });
+        test('should return true for simple array', () => {
+            expect((0, isJsonString_1.isJsonString)('[1,2,3]')).toBe(true);
+        });
+        test('should return true for nested object', () => {
+            expect((0, isJsonString_1.isJsonString)('{"user":{"name":"John","age":30}}')).toBe(true);
+        });
+        test('should return true for array of objects', () => {
+            expect((0, isJsonString_1.isJsonString)('[{"id":1},{"id":2}]')).toBe(true);
+        });
+        test('should return true for string value', () => {
+            expect((0, isJsonString_1.isJsonString)('"hello"')).toBe(true);
+        });
+        test('should return true for number value', () => {
+            expect((0, isJsonString_1.isJsonString)('123')).toBe(true);
+        });
+        test('should return true for boolean true', () => {
+            expect((0, isJsonString_1.isJsonString)('true')).toBe(true);
+        });
+        test('should return true for boolean false', () => {
+            expect((0, isJsonString_1.isJsonString)('false')).toBe(true);
+        });
+        test('should return true for null', () => {
+            expect((0, isJsonString_1.isJsonString)('null')).toBe(true);
+        });
+        test('should return true for complex nested structure', () => {
+            const complex = JSON.stringify({
+                users: [
+                    { id: 1, profile: { name: 'John', tags: ['admin', 'user'] } },
+                    { id: 2, profile: { name: 'Jane', tags: ['user'] } }
+                ],
+                meta: { total: 2, page: 1 }
+            });
+            expect((0, isJsonString_1.isJsonString)(complex)).toBe(true);
+        });
+        test('should return true for JSON with special characters', () => {
+            expect((0, isJsonString_1.isJsonString)('{"message":"Hello\\nWorld"}')).toBe(true);
+        });
+        test('should return true for JSON with unicode', () => {
+            expect((0, isJsonString_1.isJsonString)('{"emoji":"\\u2764"}')).toBe(true);
+        });
+    });
+    describe('invalid JSON strings', () => {
+        test('should return false for plain text', () => {
+            expect((0, isJsonString_1.isJsonString)('hello world')).toBe(false);
+        });
+        test('should return false for single quotes', () => {
+            expect((0, isJsonString_1.isJsonString)("{'name':'John'}")).toBe(false);
+        });
+        test('should return false for missing quotes on keys', () => {
+            expect((0, isJsonString_1.isJsonString)('{name:"John"}')).toBe(false);
+        });
+        test('should return false for trailing comma', () => {
+            expect((0, isJsonString_1.isJsonString)('{"name":"John",}')).toBe(false);
+        });
+        test('should return false for unclosed object', () => {
+            expect((0, isJsonString_1.isJsonString)('{"name":"John"')).toBe(false);
+        });
+        test('should return false for unclosed array', () => {
+            expect((0, isJsonString_1.isJsonString)('[1,2,3')).toBe(false);
+        });
+        test('should return false for undefined', () => {
+            expect((0, isJsonString_1.isJsonString)('undefined')).toBe(false);
+        });
+        test('should return false for NaN', () => {
+            expect((0, isJsonString_1.isJsonString)('NaN')).toBe(false);
+        });
+        test('should return false for Infinity', () => {
+            expect((0, isJsonString_1.isJsonString)('Infinity')).toBe(false);
+        });
+        test('should return false for JavaScript object literal', () => {
+            expect((0, isJsonString_1.isJsonString)('{name: "John"}')).toBe(false);
+        });
+        test('should return false for empty string', () => {
+            expect((0, isJsonString_1.isJsonString)('')).toBe(false);
+        });
+        test('should return false for whitespace only', () => {
+            expect((0, isJsonString_1.isJsonString)('   ')).toBe(false);
+        });
+        test('should return false for function', () => {
+            expect((0, isJsonString_1.isJsonString)('function() {}')).toBe(false);
+        });
+        test('should return false for date string', () => {
+            expect((0, isJsonString_1.isJsonString)('2023-01-01')).toBe(false);
+        });
+    });
+    describe('edge cases', () => {
+        test('should return true for deeply nested structure', () => {
+            const deep = '{"a":{"b":{"c":{"d":{"e":"value"}}}}}';
+            expect((0, isJsonString_1.isJsonString)(deep)).toBe(true);
+        });
+        test('should return true for large array', () => {
+            const arr = JSON.stringify(Array.from({ length: 1000 }, (_, i) => i));
+            expect((0, isJsonString_1.isJsonString)(arr)).toBe(true);
+        });
+        test('should return true for JSON with whitespace', () => {
+            expect((0, isJsonString_1.isJsonString)('{ "name" : "John" }')).toBe(true);
+        });
+        test('should return true for JSON with newlines', () => {
+            expect((0, isJsonString_1.isJsonString)('{\n  "name": "John"\n}')).toBe(true);
+        });
+    });
+});

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

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

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

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

package/dist/tests/isValidDateString.spec.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isValidDateString_1 = require("../utils/isValidDateString");
+describe('isValidDateString', () => {
+    describe('valid ISO 8601 date strings', () => {
+        test('should return true for date only (YYYY-MM-DD)', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15')).toBe(true);
+        });
+        test('should return true for date with UTC time', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00Z')).toBe(true);
+        });
+        test('should return true for date with milliseconds and UTC', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.000Z')).toBe(true);
+        });
+        test('should return true for date with positive timezone offset', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00+05:30')).toBe(true);
+        });
+        test('should return true for date with negative timezone offset', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00-08:00')).toBe(true);
+        });
+        test('should return true for date with milliseconds and positive offset', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.123+05:30')).toBe(true);
+        });
+        test('should return true for date with milliseconds and negative offset', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.999-08:00')).toBe(true);
+        });
+        test('should return true for midnight UTC', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T00:00:00Z')).toBe(true);
+        });
+        test('should return true for end of day UTC', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T23:59:59Z')).toBe(true);
+        });
+        test('should return true for leap year date', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2024-02-29')).toBe(true);
+        });
+    });
+    describe('invalid date strings', () => {
+        test('should return false for empty string', () => {
+            expect((0, isValidDateString_1.isValidDateString)('')).toBe(false);
+        });
+        test('should return false for plain text', () => {
+            expect((0, isValidDateString_1.isValidDateString)('hello')).toBe(false);
+        });
+        test('should return false for number string', () => {
+            expect((0, isValidDateString_1.isValidDateString)('12345')).toBe(false);
+        });
+        test('should return false for MM/DD/YYYY format', () => {
+            expect((0, isValidDateString_1.isValidDateString)('01/15/2023')).toBe(false);
+        });
+        test('should return false for DD/MM/YYYY format', () => {
+            expect((0, isValidDateString_1.isValidDateString)('15/01/2023')).toBe(false);
+        });
+        test('should return false for date with spaces', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023 01 15')).toBe(false);
+        });
+        test('should return false for date without leading zeros', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-1-15')).toBe(false);
+        });
+        test('should return false for time only', () => {
+            expect((0, isValidDateString_1.isValidDateString)('10:30:00')).toBe(false);
+        });
+        test('should return false for Unix timestamp', () => {
+            expect((0, isValidDateString_1.isValidDateString)('1673784600')).toBe(false);
+        });
+        test('should return false for date with invalid month', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-13-15')).toBe(false);
+        });
+        test('should return false for date with invalid day', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-32')).toBe(false);
+        });
+        test('should handle Feb 29 on non-leap year', () => {
+            // Note: The function checks format and Date.parse, not calendar validity
+            // Date.parse('2023-02-29') returns a valid date (March 1, 2023)
+            // This is expected behavior as the function validates ISO format, not calendar semantics
+            expect((0, isValidDateString_1.isValidDateString)('2023-02-29')).toBe(true);
+        });
+        test('should return false for incomplete date', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01')).toBe(false);
+        });
+        test('should return false for date with invalid time separator', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15 10:30:00')).toBe(false);
+        });
+        test('should return false for timezone without colon', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00+0530')).toBe(false);
+        });
+        test('should return false for date string with text', () => {
+            expect((0, isValidDateString_1.isValidDateString)('January 15, 2023')).toBe(false);
+        });
+        test('should return false for ISO week date', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-W03-7')).toBe(false);
+        });
+        test('should return false for ordinal date', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-015')).toBe(false);
+        });
+    });
+    describe('edge cases', () => {
+        test('should return true for year boundary', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-12-31')).toBe(true);
+            expect((0, isValidDateString_1.isValidDateString)('2024-01-01')).toBe(true);
+        });
+        test('should return true for various millisecond lengths', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.1Z')).toBe(true);
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.12Z')).toBe(true);
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00.123Z')).toBe(true);
+        });
+        test('should return true for UTC midnight', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T00:00:00.000Z')).toBe(true);
+        });
+        test('should return false for date with extra characters', () => {
+            expect((0, isValidDateString_1.isValidDateString)('2023-01-15T10:30:00Zextra')).toBe(false);
+        });
+        test('should return false for date with prefix', () => {
+            expect((0, isValidDateString_1.isValidDateString)('date:2023-01-15')).toBe(false);
+        });
+    });
+});

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