fluxor-cloud-db 1.0.0

package/tests/mongodb.test.ts

@@ -0,0 +1,486 @@
+import { MongoService } from "./../src/mongo/mongo";
+import { DatabaseAdapterError } from "./../src/types/error";
+
+const DB_NAME = "fluxor_db_tests";
+const MONGO_URI = `mongodb://localhost:27017/${DB_NAME}`;
+const tableName = "test_collection";
+
+let service: MongoService;
+
+beforeEach(async () => {
+    service = new MongoService();
+    service.setConfig({ uri: MONGO_URI, dbName: DB_NAME });
+    await service.connect();
+
+    // Clean slate before each test
+    const db = (service as any).db;
+    await db.collection(tableName).deleteMany({});
+});
+
+afterEach(async () => {
+    await service.disconnect();
+});
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+
+function makeRecord(id: number, overrides: Record<string, any> = {}) {
+    return { id, name: `Record ${id}`, status: "active", score: id * 10, ...overrides };
+}
+
+async function seedRecords(count: number, overrides: Record<string, any> = {}) {
+    const records = Array.from({ length: count }, (_, i) => makeRecord(i + 1, overrides));
+    await service.createMany(tableName, records);
+    return records;
+}
+
+// ─── tests ───────────────────────────────────────────────────────────────────
+
+describe("MongoService", () => {
+
+    // ── Connection Management ────────────────────────────────────────────────
+
+    describe("Connection Management", () => {
+        it("should connect successfully with valid config", async () => {
+            const s = new MongoService();
+            s.setConfig({ uri: MONGO_URI, dbName: DB_NAME });
+            await expect(s.connect()).resolves.toBeUndefined();
+            expect(s.isConnected()).toBe(true);
+            await s.disconnect();
+        });
+
+        it("should reject connection when no config is set", async () => {
+            const s = new MongoService();
+            await expect(s.connect()).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should reject connection with invalid uri", async () => {
+            const s = new MongoService();
+            s.setConfig({ uri: "", dbName: DB_NAME });
+            await expect(s.connect()).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should be disconnected after calling disconnect", async () => {
+            await service.disconnect();
+            expect(service.isConnected()).toBe(false);
+        });
+
+        it("should return false for healthCheck on disconnected service", async () => {
+            await service.disconnect();
+            const result = await service.healthCheck();
+            expect(result).toBe(false);
+        });
+    });
+
+    // ── createOne ────────────────────────────────────────────────────────────
+
+    describe("createOne", () => {
+        it("should insert a single record", async () => {
+            const record = makeRecord(1);
+            const result = await service.createOne(tableName, record);
+            expect(result).toMatchObject(record);
+        });
+
+        it("should return inserted data with correct types", async () => {
+            const record = { id: 1, name: "Test", score: 42, active: true };
+            const result: any = await service.createOne(tableName, record);
+            expect(typeof result.id).toBe("number");
+            expect(typeof result.name).toBe("string");
+            expect(typeof result.score).toBe("number");
+            expect(typeof result.active).toBe("boolean");
+        });
+
+        it("should handle nested objects", async () => {
+            const record = { id: 1, name: "Nested", meta: { tags: ["a", "b"], count: 2 } };
+            const result: any = await service.createOne(tableName, record);
+            expect(result.meta).toEqual({ tags: ["a", "b"], count: 2 });
+        });
+    });
+
+    // ── createMany ───────────────────────────────────────────────────────────
+
+    describe("createMany", () => {
+        it("should insert multiple records", async () => {
+            const records = [makeRecord(1), makeRecord(2), makeRecord(3)];
+            const { items, result } = await service.createMany(tableName, records);
+            expect(items).toHaveLength(3);
+            expect(result.successful).toBe(3);
+            expect(result.failed).toBe(0);
+        });
+
+        it("should handle empty array", async () => {
+            const { items, result } = await service.createMany(tableName, []);
+            expect(items).toHaveLength(0);
+            expect(result.successful).toBe(0);
+            expect(result.failed).toBe(0);
+        });
+
+        it("should throw error if data is not array", async () => {
+            await expect(
+                service.createMany(tableName, "not-an-array" as any)
+            ).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should insert large batches correctly", async () => {
+            const records = Array.from({ length: 50 }, (_, i) => makeRecord(i + 1));
+            const { items, result } = await service.createMany(tableName, records);
+            expect(result.successful).toBe(50);
+            expect(items).toHaveLength(50);
+        });
+    });
+
+    // ── selectOne ────────────────────────────────────────────────────────────
+
+    describe("selectOne", () => {
+        it("should select a single record by id", async () => {
+            await seedRecords(3);
+            const result: any = await service.selectOne(tableName, { id: { operator: "=", value: 2 } });
+            expect(result).not.toBeNull();
+            expect(result.id).toBe(2);
+        });
+
+        it("should return null when record not found", async () => {
+            const result = await service.selectOne(tableName, { id: { operator: "=", value: 9999 } });
+            expect(result).toBeNull();
+        });
+
+        it("should support projection", async () => {
+            await seedRecords(1);
+            const result: any = await service.selectOne(
+                tableName,
+                { id: { operator: "=", value: 1 } },
+                { projection: ["id", "name"] }
+            );
+            expect(result).not.toBeNull();
+            expect(result.id).toBeDefined();
+            expect(result.name).toBeDefined();
+            expect(result.score).toBeUndefined();
+        });
+    });
+
+    // ── selectMany ───────────────────────────────────────────────────────────
+
+    describe("selectMany", () => {
+        it("should select multiple records with condition", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, { status: { operator: "=", value: "active" } });
+            expect(result.items.length).toBeGreaterThan(0);
+            result.items.forEach((item: any) => {
+                expect(item.status).toBe("active");
+            });
+        });
+
+        it("should handle empty result set", async () => {
+            const result = await service.selectMany(tableName, { id: { operator: "=", value: 9999 } });
+            expect(result.items).toHaveLength(0);
+            expect(result.total).toBe(0);
+        });
+
+        it("should support limit and offset", async () => {
+            await seedRecords(10);
+            const result = await service.selectMany(tableName, undefined, { limit: 3, offset: 2 });
+            expect(result.items).toHaveLength(3);
+        });
+
+        it("should support ordering", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, undefined, {
+                orderBy: [{ field: "id", direction: "DESC" }]
+            });
+
+            if (result.items.length > 1) {
+                const ids = result.items.map((item: any) => item.id);
+                for (let i = 1; i < ids.length; i++) {
+                    expect(ids[i]).toBeLessThanOrEqual(ids[i - 1]);
+                }
+            }
+        });
+
+        it("should support projection", async () => {
+            await seedRecords(3);
+            const result = await service.selectMany(tableName, undefined, {
+                projection: ["id", "name"]
+            });
+            expect(result.items.length).toBeGreaterThan(0);
+            result.items.forEach((item: any) => {
+                expect(item.id).toBeDefined();
+                expect(item.name).toBeDefined();
+                expect(item.score).toBeUndefined();
+            });
+        });
+
+        it("should return pagination info", async () => {
+            await seedRecords(10);
+            const result = await service.selectMany(tableName, undefined, { limit: 3 });
+            expect(result.hasMore).toBe(true);
+            expect(typeof result.total).toBe("number");
+        });
+
+        it("should support greater than operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                score: { operator: ">", value: 30 }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.score).toBeGreaterThan(30);
+            });
+        });
+
+        it("should support less than operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                score: { operator: "<", value: 40 }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.score).toBeLessThan(40);
+            });
+        });
+    });
+
+    // ── updateOne ────────────────────────────────────────────────────────────
+
+    describe("updateOne", () => {
+        it("should update a single record", async () => {
+            await seedRecords(3);
+            const updated: any = await service.updateOne(
+                tableName,
+                { name: "Updated Name" },
+                { id: { operator: "=", value: 2 } }
+            );
+            expect(updated.name).toBe("Updated Name");
+            expect(updated.id).toBe(2);
+        });
+
+        it("should throw error when record not found", async () => {
+            await expect(
+                service.updateOne(
+                    tableName,
+                    { name: "Updated" },
+                    { id: { operator: "=", value: 9999 } }
+                )
+            ).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should preserve other fields during update", async () => {
+            await seedRecords(1);
+            const updated: any = await service.updateOne(
+                tableName,
+                { name: "Changed" },
+                { id: { operator: "=", value: 1 } }
+            );
+            expect(updated.name).toBe("Changed");
+            expect(updated.score).toBe(10);
+            expect(updated.status).toBe("active");
+        });
+    });
+
+    // ── updateMany ───────────────────────────────────────────────────────────
+
+    describe("updateMany", () => {
+        it("should update multiple records matching condition", async () => {
+            await seedRecords(5);
+            const { result } = await service.updateMany(
+                tableName,
+                { status: "inactive" },
+                { score: { operator: ">", value: 20 } }
+            );
+            expect(result.successful).toBeGreaterThan(0);
+            expect(result.failed).toBe(0);
+        });
+
+        it("should respect limit option", async () => {
+            await seedRecords(5);
+            const { result } = await service.updateMany(
+                tableName,
+                { status: "archived" },
+                undefined,
+                { limit: 2 }
+            );
+            expect(result.successful).toBeLessThanOrEqual(2);
+        });
+
+        it("should return empty result when no matches found", async () => {
+            const { items, result } = await service.updateMany(
+                tableName,
+                { name: "Ghost" },
+                { id: { operator: "=", value: 9999 } }
+            );
+            expect(items).toHaveLength(0);
+            expect(result.successful).toBe(0);
+        });
+    });
+
+    // ── deleteOne ────────────────────────────────────────────────────────────
+
+    describe("deleteOne", () => {
+        it("should delete a single record", async () => {
+            await seedRecords(3);
+            const { success, deletedCount } = await service.deleteOne(
+                tableName,
+                { id: { operator: "=", value: 2 } }
+            );
+            expect(success).toBe(true);
+            expect(deletedCount).toBe(1);
+
+            const check = await service.selectOne(tableName, { id: { operator: "=", value: 2 } });
+            expect(check).toBeNull();
+        });
+
+        it("should handle deletion of non-existent record", async () => {
+            const { success, deletedCount } = await service.deleteOne(
+                tableName,
+                { id: { operator: "=", value: 9999 } }
+            );
+            expect(success).toBe(false);
+            expect(deletedCount).toBe(0);
+        });
+    });
+
+    // ── deleteMany ───────────────────────────────────────────────────────────
+
+    describe("deleteMany", () => {
+        it("should delete multiple records matching condition", async () => {
+            await seedRecords(5);
+            const { success, deletedCount } = await service.deleteMany(
+                tableName,
+                { score: { operator: ">", value: 20 } }
+            );
+            expect(success).toBe(true);
+            expect(deletedCount).toBeGreaterThan(0);
+        });
+
+        it("should respect limit option", async () => {
+            await seedRecords(5);
+            const { deletedCount } = await service.deleteMany(tableName, undefined, { limit: 2 });
+            expect(deletedCount).toBe(2);
+        });
+
+        it("should handle no matches", async () => {
+            const { success, deletedCount } = await service.deleteMany(
+                tableName,
+                { id: { operator: "=", value: 9999 } }
+            );
+            expect(success).toBe(true);
+            expect(deletedCount).toBe(0);
+        });
+    });
+
+    // ── Query Operators ──────────────────────────────────────────────────────
+
+    describe("Query Operators", () => {
+        it("should support IN operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                id: { operator: "IN", value: [1, 3, 5] }
+            });
+            expect(result.items).toHaveLength(3);
+            const ids = result.items.map((item: any) => item.id).sort();
+            expect(ids).toEqual([1, 3, 5]);
+        });
+
+        it("should support NOT_IN operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                id: { operator: "NOT_IN", value: [1, 2] }
+            });
+            expect(result.items).toHaveLength(3);
+            result.items.forEach((item: any) => {
+                expect([1, 2]).not.toContain(item.id);
+            });
+        });
+
+        it("should support LIKE operator", async () => {
+            await service.createMany(tableName, [
+                { id: 1, name: "Alice" },
+                { id: 2, name: "Bob" },
+                { id: 3, name: "Albert" }
+            ]);
+            const result = await service.selectMany(tableName, {
+                name: { operator: "LIKE", value: "al" }
+            });
+            expect(result.items.length).toBeGreaterThanOrEqual(2);
+            result.items.forEach((item: any) => {
+                expect(item.name.toLowerCase()).toContain("al");
+            });
+        });
+
+        it("should support BEGINS_WITH operator", async () => {
+            await service.createMany(tableName, [
+                { id: 1, name: "Alpha" },
+                { id: 2, name: "Beta" },
+                { id: 3, name: "Alphabet" }
+            ]);
+            const result = await service.selectMany(tableName, {
+                name: { operator: "BEGINS_WITH", value: "Alpha" }
+            });
+            expect(result.items.length).toBeGreaterThanOrEqual(2);
+            result.items.forEach((item: any) => {
+                expect(item.name.toLowerCase()).toMatch(/^alpha/i);
+            });
+        });
+
+        it("should support BETWEEN operator", async () => {
+            await seedRecords(10);
+            const result = await service.selectMany(tableName, {
+                score: { operator: "BETWEEN", value: [30, 70] }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.score).toBeGreaterThanOrEqual(30);
+                expect(item.score).toBeLessThanOrEqual(70);
+            });
+        });
+
+        it("should support != operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                id: { operator: "!=", value: 3 }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.id).not.toBe(3);
+            });
+        });
+
+        it("should support >= operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                score: { operator: ">=", value: 30 }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.score).toBeGreaterThanOrEqual(30);
+            });
+        });
+
+        it("should support <= operator", async () => {
+            await seedRecords(5);
+            const result = await service.selectMany(tableName, {
+                score: { operator: "<=", value: 30 }
+            });
+            result.items.forEach((item: any) => {
+                expect(item.score).toBeLessThanOrEqual(30);
+            });
+        });
+    });
+
+    // ── Error Handling ───────────────────────────────────────────────────────
+
+    describe("Error Handling", () => {
+        it("should throw error on operation without connection", async () => {
+            const s = new MongoService();
+            s.setConfig({ uri: MONGO_URI, dbName: DB_NAME });
+            await expect(
+                s.selectOne(tableName, { id: { operator: "=", value: 1 } })
+            ).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should throw error on executeRaw", async () => {
+            await expect(
+                service.executeRaw("any query")
+            ).rejects.toThrow(DatabaseAdapterError);
+        });
+
+        it("should throw error on invalid table name", async () => {
+            await expect(
+                service.selectOne("", { id: { operator: "=", value: 1 } })
+            ).rejects.toThrow(DatabaseAdapterError);
+        });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "sourceMap": true,
+
+    "declaration": true,                  
+    "outDir": "dist",                     
+    "emitDecoratorMetadata": true,        
+    "experimentalDecorators": true,       
+
+    "baseUrl": "./src",
+    "paths": {
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}