mongo-query-dsl 1.0.0

package/src/__tests__/executor.test.ts

@@ -0,0 +1,694 @@
+import { QueryExecutor } from "../executor";
+import { DatabaseProvider, JsonQuery } from "../types";
+
+// Mock database provider
+class MockDatabaseProvider implements DatabaseProvider {
+  private mockData: Map<string, Map<string, Record<string, any>[]>> = new Map();
+
+  constructor() {
+    // Initialize with sample data
+    this.addData("myDb", "users", [
+      {
+        _id: "user_123",
+        name: "John Doe",
+        email: "john@example.com",
+        role: "admin",
+      },
+      {
+        _id: "user_456",
+        name: "Jane Smith",
+        email: "jane@example.com",
+        role: "user",
+      },
+    ]);
+
+    this.addData("myDb", "documents", [
+      {
+        _id: "doc_123",
+        title: "Document 1",
+        userId: "user_123",
+        content: "Sample content",
+      },
+      {
+        _id: "doc_456",
+        title: "Document 2",
+        userId: "user_456",
+        content: "Another content",
+      },
+    ]);
+
+    this.addData("myDb", "metadata", [
+      {
+        _id: "meta_123",
+        ownerId: "user_123",
+        ownerType: "users",
+        ownerSource: "myDb",
+      },
+    ]);
+
+    this.addData("permissions", "admin", [
+      { _id: "user_123", permissions: ["read", "write", "delete"] },
+    ]);
+  }
+
+  addData(db: string, collection: string, documents: Record<string, any>[]) {
+    if (!this.mockData.has(db)) {
+      this.mockData.set(db, new Map());
+    }
+    const dbMap = this.mockData.get(db)!;
+    dbMap.set(collection, documents);
+  }
+
+  async findOne(
+    dbName: string,
+    collectionName: string,
+    query: Record<string, any>,
+  ): Promise<Record<string, any> | null> {
+    const db = this.mockData.get(dbName);
+    if (!db) return null;
+
+    const collection = db.get(collectionName);
+    if (!collection) return null;
+
+    // Simple query matching
+    const doc = collection.find((doc) => {
+      return Object.entries(query).every(([key, value]) => doc[key] === value);
+    });
+
+    return doc || null;
+  }
+
+  async close(): Promise<void> {
+    // Mock close
+  }
+}
+
+describe("QueryExecutor", () => {
+  let executor: QueryExecutor;
+  let mockProvider: MockDatabaseProvider;
+
+  beforeEach(() => {
+    mockProvider = new MockDatabaseProvider();
+    executor = new QueryExecutor(mockProvider);
+  });
+
+  describe("Basic query execution", () => {
+    it("should execute simple query with no steps", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        _id: "user_123",
+        name: "John Doe",
+        email: "john@example.com",
+        role: "admin",
+      });
+    });
+
+    it("should return error when document not found", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "nonexistent" },
+        },
+        steps: [],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("Document not found");
+    });
+  });
+
+  describe("GET step execution", () => {
+    it("should extract single field", async () => {
+      const query: JsonQuery = {
+        output: "value",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+    });
+
+    it("should extract multiple fields", async () => {
+      const query: JsonQuery = {
+        output: "value",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name", "email"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "John Doe",
+        email: "john@example.com",
+      });
+    });
+
+    it("should return undefined for missing fields", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name", "nonexistent"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "John Doe",
+        nonexistent: undefined,
+      });
+    });
+
+    it("should support aliases and default values in GET", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [
+          {
+            type: "get",
+            fields: [
+              "name as fullName",
+              "email",
+              "missingField as fallbackCandidate",
+            ],
+            default: { fallbackCandidate: "N/A", source: "default" },
+          },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        source: "default",
+        fullName: "John Doe",
+        email: "john@example.com",
+        fallbackCandidate: undefined,
+      });
+    });
+
+    it("should resolve :field references from previous documents in GET", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          { type: "get", fields: ["title", "userId"] },
+          { type: "lookup", collection: "users", db: "myDb", by: "userId" },
+          { type: "get", fields: ["name", ":title", ":userId"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "John Doe",
+        title: "Document 1",
+        userId: "user_123",
+      });
+    });
+
+    it("should return single value for getOne step", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "getOne", fields: "email" }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe("john@example.com");
+    });
+  });
+
+  describe("LOOKUP step execution", () => {
+    it("should execute simple lookup", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          { type: "lookup", collection: "users", db: "myDb", by: "userId" },
+          { type: "get", fields: ["name", "email"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "John Doe",
+        email: "john@example.com",
+      });
+    });
+
+    it("should execute lookup with WHERE conditions", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: "users",
+            db: "myDb",
+            by: "userId",
+            where: { role: "admin" },
+          },
+          { type: "get", fields: ["name"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+    });
+
+    it("should resolve dynamic values inside LOOKUP WHERE conditions", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          { type: "get", fields: ["userId"], default: { role: "admin" } },
+          {
+            type: "lookup",
+            collection: "users",
+            db: "myDb",
+            by: "userId",
+            where: { role: ":role" },
+          },
+          { type: "get", fields: ["name", "role"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe", role: "admin" });
+    });
+
+    it("should fail when lookup document not found", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: "users",
+            db: "myDb",
+            by: "userId",
+            where: { role: "superadmin" }, // No user with this role
+          },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Document not found");
+    });
+
+    it("should fail when lookup field not found in document", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: "users",
+            db: "myDb",
+            by: "nonexistentField",
+          },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not found in current document");
+    });
+  });
+
+  describe("Dynamic value resolution in LOOKUP", () => {
+    it("should resolve dynamic collection name", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "metadata",
+          db: "myDb",
+          where: { _id: "meta_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: ":ownerType",
+            db: "myDb",
+            by: "ownerId",
+          },
+          { type: "get", fields: ["name"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+    });
+
+    it("should resolve dynamic database name", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "metadata",
+          db: "myDb",
+          where: { _id: "meta_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: "users",
+            db: ":ownerSource",
+            by: "ownerId",
+          },
+          { type: "get", fields: ["email"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ email: "john@example.com" });
+    });
+
+    it("should resolve both dynamic collection and database names", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "metadata",
+          db: "myDb",
+          where: { _id: "meta_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: ":ownerType",
+            db: ":ownerSource",
+            by: "ownerId",
+          },
+          { type: "get", fields: ["name", "role"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe", role: "admin" });
+    });
+  });
+
+  describe("Output formats", () => {
+    it("should return value format by default", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+      expect(result.trace).toBeUndefined();
+    });
+
+    it("should return value format when explicitly set", async () => {
+      const query: JsonQuery = {
+        output: "value",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+      expect(result.trace).toBeUndefined();
+    });
+
+    it("should return document format", async () => {
+      const query: JsonQuery = {
+        output: "document",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+      expect(result.trace).toBeUndefined();
+    });
+
+    it("should return trace format with execution trace", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "John Doe" });
+      expect(result.trace).toBeDefined();
+      expect(result.trace).toHaveLength(2); // start + get step
+    });
+
+    it("should include start step in trace", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.trace).toBeDefined();
+      expect(result.trace![0]).toMatchObject({
+        stepNumber: 0,
+        stepType: "start",
+        collection: "users",
+        db: "myDb",
+        query: { _id: "user_123" },
+      });
+      expect(result.trace![0].documentFound).toBeDefined();
+    });
+
+    it("should include lookup step in trace", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          { type: "lookup", collection: "users", db: "myDb", by: "userId" },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.trace).toBeDefined();
+      expect(result.trace![1]).toMatchObject({
+        stepNumber: 1,
+        stepType: "lookup",
+        collection: "users",
+        db: "myDb",
+      });
+    });
+
+    it("should include get step in trace", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "get", fields: ["name", "email"] }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.trace).toBeDefined();
+      expect(result.trace![1]).toMatchObject({
+        stepNumber: 1,
+        stepType: "get",
+        fieldsExtracted: { name: "John Doe", email: "john@example.com" },
+      });
+    });
+
+    it("should include getOne step in trace", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "users",
+          db: "myDb",
+          where: { _id: "user_123" },
+        },
+        steps: [{ type: "getOne", fields: "email" }],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe("john@example.com");
+      expect(result.trace).toBeDefined();
+      expect(result.trace![1]).toMatchObject({
+        stepType: "getOne",
+        fieldsExtracted: { email: "john@example.com" },
+      });
+    });
+  });
+
+  describe("Complex queries", () => {
+    it("should execute multi-step query", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "documents",
+          db: "myDb",
+          where: { _id: "doc_123" },
+        },
+        steps: [
+          { type: "get", fields: ["title", "userId"] },
+          { type: "lookup", collection: "users", db: "myDb", by: "userId" },
+          { type: "get", fields: ["name", "email"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "John Doe",
+        email: "john@example.com",
+      });
+    });
+
+    it("should execute query with multiple lookups", async () => {
+      // Add proper test data for this scenario
+      mockProvider.addData("myDb", "roles", [
+        { _id: "admin", roleId: "role_admin", name: "Administrator" },
+      ]);
+      mockProvider.addData("permissions", "roles", [
+        { _id: "role_admin", permissions: ["read", "write", "delete"] },
+      ]);
+
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "metadata",
+          db: "myDb",
+          where: { _id: "meta_123" },
+        },
+        steps: [
+          {
+            type: "lookup",
+            collection: ":ownerType",
+            db: ":ownerSource",
+            by: "ownerId",
+          },
+          { type: "get", fields: ["role"] },
+          { type: "lookup", collection: "roles", db: "myDb", by: "role" },
+          { type: "get", fields: ["roleId"] },
+          {
+            type: "lookup",
+            collection: "roles",
+            db: "permissions",
+            by: "roleId",
+          },
+          { type: "get", fields: ["permissions"] },
+        ],
+      };
+
+      const result = await executor.execute(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        permissions: ["read", "write", "delete"],
+      });
+      expect(result.trace).toHaveLength(7); // start + 6 steps
+    });
+  });
+});