@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/data/orm/data-query.mongo.test.js

@@ -1,367 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const data_query_mongo_1 = require("./data-query.mongo");
-describe("dataFilterToMongoQuery", () => {
-    describe("Scalar values", () => {
-        it("should handle null values", () => {
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(null)).toBe(null);
-        });
-        it("should handle undefined values", () => {
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(undefined)).toBe(undefined);
-        });
-        it("should handle primitive values", () => {
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(42)).toBe(42);
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)("test")).toBe("test");
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(true)).toBe(true);
-        });
-        it("should handle Date objects", () => {
-            const date = new Date("2023-01-01");
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(date)).toBe(date);
-        });
-    });
-    describe("Empty filters", () => {
-        it("should handle empty object filters", () => {
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)({})).toEqual({});
-        });
-        it("should handle empty array filters", () => {
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)([])).toEqual({});
-        });
-    });
-    describe("Simple field conditions", () => {
-        it("should handle basic field equality", () => {
-            const filter = { name: "John" };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John" });
-        });
-        it("should handle multiple fields", () => {
-            const filter = { name: "John", age: 30 };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John", age: 30 });
-        });
-        it("should handle null field values", () => {
-            const filter = { name: null };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
-        });
-        it("should handle undefined field values", () => {
-            const filter = { name: undefined };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
-        });
-        it("should throw error for direct array usage", () => {
-            const filter = { names: ["John", "Jane"] };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Invalid filter: Arrays are not allowed as direct field values. Use $in instead");
-        });
-    });
-    describe("MongoDB operators (direct mapping)", () => {
-        describe("$eq operator", () => {
-            it("should handle $eq operator", () => {
-                const filter = { age: { $eq: 30 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $eq: 30 } });
-            });
-        });
-        describe("$ne operator", () => {
-            it("should handle $ne operator", () => {
-                const filter = { age: { $ne: 30 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $ne: 30 } });
-            });
-        });
-        describe("Comparison operators", () => {
-            it("should handle $gt operator", () => {
-                const filter = { age: { $gt: 18 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gt: 18 } });
-            });
-            it("should handle $gte operator", () => {
-                const filter = { age: { $gte: 18 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18 } });
-            });
-            it("should handle $lt operator", () => {
-                const filter = { age: { $lt: 65 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lt: 65 } });
-            });
-            it("should handle $lte operator", () => {
-                const filter = { age: { $lte: 65 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lte: 65 } });
-            });
-            it("should handle multiple comparison operators", () => {
-                const filter = { age: { $gte: 18, $lt: 65 } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18, $lt: 65 } });
-            });
-        });
-        describe("$in and $nin operators", () => {
-            it("should handle $in operator", () => {
-                const filter = { status: { $in: ["active", "pending"] } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: ["active", "pending"] } });
-            });
-            it("should handle $nin operator", () => {
-                const filter = { status: { $nin: ["inactive", "deleted"] } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    status: { $nin: ["inactive", "deleted"] },
-                });
-            });
-            it("should handle empty arrays", () => {
-                const filter = { status: { $in: [] } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: [] } });
-            });
-        });
-        describe("$exists operator", () => {
-            it("should handle $exists: true", () => {
-                const filter = { email: { $exists: true } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: true } });
-            });
-            it("should handle $exists: false", () => {
-                const filter = { email: { $exists: false } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: false } });
-            });
-        });
-    });
-    describe("Logical operators", () => {
-        describe("$or operator", () => {
-            it("should handle $or with multiple conditions", () => {
-                const filter = { $or: [{ name: "John" }, { age: 30 }] };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: "John" }, { age: 30 }],
-                });
-            });
-            it("should handle empty $or array", () => {
-                const filter = { $or: [] };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ $or: [] });
-            });
-            it("should handle $or with complex conditions", () => {
-                const filter = {
-                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
-                };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
-                });
-            });
-        });
-        describe("$and operator", () => {
-            it("should handle $and with multiple conditions", () => {
-                const filter = { $and: [{ name: "John" }, { age: 30 }] };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $and: [{ name: "John" }, { age: 30 }],
-                });
-            });
-            it("should handle empty $and array", () => {
-                const filter = { $and: [] };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({});
-            });
-            it("should handle nested $and and $or", () => {
-                const filter = {
-                    $and: [
-                        { status: "active" },
-                        {
-                            $or: [{ age: { $gte: 18 } }, { verified: true }],
-                        },
-                    ],
-                };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $and: [
-                        { status: "active" },
-                        {
-                            $or: [{ age: { $gte: 18 } }, { verified: true }],
-                        },
-                    ],
-                });
-            });
-        });
-        describe("Array filters (OR logic)", () => {
-            it("should handle single condition arrays", () => {
-                const filter = [{ name: "John" }];
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John" });
-            });
-            it("should handle multiple condition arrays", () => {
-                const filter = [{ name: "John" }, { age: 30 }, { city: "NYC" }];
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: "John" }, { age: 30 }, { city: "NYC" }],
-                });
-            });
-            it("should handle complex array conditions", () => {
-                const filter = [
-                    { name: "John", age: { $gte: 18 } },
-                    { status: { $in: ["active", "pending"] } },
-                ];
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
-                });
-            });
-        });
-    });
-    describe("Custom operators", () => {
-        describe("$matchWords operator", () => {
-            it("should throw error for $matchWords (needs field context)", () => {
-                const filter = { $matchWords: "hello world" };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords with multiple words requires field context");
-            });
-            it("should throw error for non-string values", () => {
-                const filter = { $matchWords: 123 };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords value must be a string");
-            });
-        });
-        describe("$substr operator", () => {
-            it("should convert $substr to MongoDB $expr format", () => {
-                const filter = { $substr: ["$fieldName", 1, 3] };
-                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
-                expect(result).toEqual({
-                    $expr: {
-                        $substr: ["$fieldName", 1, 3],
-                    },
-                });
-            });
-            it("should handle string literals in $substr", () => {
-                const filter = { $substr: ["literal text", 0, 5] };
-                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
-                expect(result).toEqual({
-                    $expr: {
-                        $substr: ["literal text", 0, 5],
-                    },
-                });
-            });
-            it("should throw error for invalid $substr arguments", () => {
-                const filter = { $substr: ["$field"] }; // Missing arguments
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr requires exactly 3 arguments");
-            });
-            it("should throw error for non-array $substr", () => {
-                const filter = { $substr: "invalid" };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr requires exactly 3 arguments");
-            });
-        });
-        describe("$expr operator", () => {
-            it("should convert simple $expr to MongoDB format", () => {
-                const filter = { $expr: [{ $substr: ["$id", 0, 1] }, { $eq: "A" }] };
-                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
-                expect(result).toEqual({
-                    $expr: {
-                        $eq: [{ $substr: ["$id", 0, 1] }, "A"],
-                    },
-                });
-            });
-            it("should handle $expr with different operators", () => {
-                const filter = { $expr: [{ $substr: ["$name", 0, 1] }, { $ne: "Z" }] };
-                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
-                expect(result).toEqual({
-                    $expr: {
-                        $ne: [{ $substr: ["$name", 0, 1] }, "Z"],
-                    },
-                });
-            });
-            it("should default to $eq for simple expressions", () => {
-                const filter = { $expr: ["$field1", "$field2"] };
-                const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
-                expect(result).toEqual({
-                    $expr: {
-                        $eq: ["$field1", "$field2"],
-                    },
-                });
-            });
-            it("should throw error for invalid $expr format", () => {
-                const filter = { $expr: ["single_argument"] };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$expr requires exactly 2 arguments");
-            });
-        });
-    });
-    describe("Error cases", () => {
-        it("should throw error for unknown operators", () => {
-            const filter = { field: { $unknown: "value" } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Unknown operator: $unknown");
-        });
-        it("should throw error for operators without $ prefix", () => {
-            const filter = { field: { invalidOp: "value" } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Invalid operator: invalidOp. Operators must start with $");
-        });
-        it("should throw error for nested $matchWords", () => {
-            const filter = { field: { $matchWords: "test" } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords should be handled at field level");
-        });
-        it("should throw error for nested $substr", () => {
-            const filter = { field: { $substr: ["$other", 0, 1] } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr should be handled at field level");
-        });
-        it("should throw error for nested $expr", () => {
-            const filter = { field: { $expr: ["$a", "$b"] } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$expr should be handled at field level");
-        });
-    });
-    describe("Complex nested scenarios", () => {
-        it("should handle deeply nested conditions", () => {
-            const filter = {
-                $and: [
-                    { status: "active" },
-                    {
-                        $or: [{ age: { $gte: 18, $lt: 65 } }, { verified: true }],
-                    },
-                    { role: { $in: ["user", "admin"] } },
-                ],
-            };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                $and: [
-                    { status: "active" },
-                    {
-                        $or: [{ age: { $gte: 18, $lt: 65 } }, { verified: true }],
-                    },
-                    { role: { $in: ["user", "admin"] } },
-                ],
-            });
-        });
-        it("should handle mixed array and object filters", () => {
-            const filter = [
-                { name: "John", age: { $gte: 18 } },
-                {
-                    $and: [{ status: "active" }, { verified: true }],
-                },
-            ];
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                $or: [
-                    { name: "John", age: { $gte: 18 } },
-                    {
-                        $and: [{ status: "active" }, { verified: true }],
-                    },
-                ],
-            });
-        });
-    });
-});
-describe("sortByToMongoSort", () => {
-    it("should handle empty sort", () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)()).toEqual({});
-        expect((0, data_query_mongo_1.sortByToMongoSort)([])).toEqual({});
-    });
-    it("should handle ascending sort", () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(["name"])).toEqual({ name: 1 });
-    });
-    it("should handle descending sort", () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(["-name"])).toEqual({ name: -1 });
-    });
-    it("should handle multiple sort fields", () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(["name", "-age", "created"])).toEqual({
-            name: 1,
-            age: -1,
-            created: 1,
-        });
-    });
-    it("should handle complex field names", () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(["-user.name", "profile.age"])).toEqual({
-            "user.name": -1,
-            "profile.age": 1,
-        });
-    });
-});
-describe("paginationToMongoSkipLimit", () => {
-    it("should handle no pagination", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)()).toEqual({});
-    });
-    it("should handle only pageSize", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(undefined, 10)).toEqual({ limit: 10 });
-    });
-    it("should handle only page (no effect without pageSize)", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2)).toEqual({});
-    });
-    it("should handle page and pageSize", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(1, 10)).toEqual({ limit: 10 });
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2, 10)).toEqual({ limit: 10, skip: 10 });
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(3, 20)).toEqual({ limit: 20, skip: 40 });
-    });
-    it("should handle fractional numbers", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2.7, 10.3)).toEqual({ limit: 10, skip: 21 });
-    });
-    it("should handle zero page", () => {
-        expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(0, 10)).toEqual({ limit: 10 });
-    });
-});

package/dist/data/orm/data-query.sqlite.test.d.ts

@@ -1 +0,0 @@
-export {};