mongo-query-dsl 1.0.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,392 @@
+import { NoQL } from "../index";
+import { ParseError } from "../errors";
+import { DatabaseProvider, JsonQuery } from "../types";
+
+// Mock database provider for testing NoQL integration
+class MockNoQLDatabaseProvider implements DatabaseProvider {
+  private mockData: Map<string, Map<string, Record<string, any>[]>> = new Map();
+
+  constructor() {
+    // Initialize with sample data
+    this.addData("testDb", "users", [
+      { _id: "user_1", name: "Alice", email: "alice@test.com", role: "admin" },
+      { _id: "user_2", name: "Bob", email: "bob@test.com", role: "user" },
+    ]);
+
+    this.addData("testDb", "posts", [
+      { _id: "post_1", title: "First Post", authorId: "user_1" },
+      { _id: "post_2", title: "Second Post", authorId: "user_2" },
+    ]);
+  }
+
+  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;
+
+    const doc = collection.find((doc) => {
+      return Object.entries(query).every(([key, value]) => doc[key] === value);
+    });
+
+    return doc || null;
+  }
+
+  async close(): Promise<void> {
+    // Mock close
+  }
+}
+
+// Helper to create NoQL with mock provider
+function createMockNoQL(): NoQL {
+  const mockProvider = new MockNoQLDatabaseProvider();
+  // Use private constructor trick via type casting
+  const noql = Object.create(NoQL.prototype);
+  noql["dbProvider"] = mockProvider;
+  noql["parser"] = new (require("../parser").DSLParser)();
+  return noql;
+}
+
+describe("NoQL Integration Tests", () => {
+  let noql: NoQL;
+
+  beforeEach(() => {
+    noql = createMockNoQL();
+  });
+
+  afterEach(async () => {
+    await noql.close();
+  });
+
+  describe("parseDSL", () => {
+    it("should parse simple DSL query", () => {
+      const dsl = 'FROM users IN testDb WHERE _id = "user_1"';
+      const result = noql.parseDSL(dsl);
+
+      expect(result).toMatchObject({
+        start: {
+          collection: "users",
+          db: "testDb",
+          where: { _id: "user_1" },
+        },
+        steps: [],
+      });
+    });
+
+    it("should parse DSL query with WITH clause", () => {
+      const dsl = `
+WITH output: "trace"
+FROM users IN testDb WHERE _id = "user_1"
+      `.trim();
+
+      const result = noql.parseDSL(dsl);
+
+      expect(result.output).toBe("trace");
+    });
+
+    it("should parse DSL query with steps", () => {
+      const dsl = `
+FROM posts IN testDb WHERE _id = "post_1"
+-> LOOKUP users IN testDb BY authorId
+-> GET name, email
+      `.trim();
+
+      const result = noql.parseDSL(dsl);
+
+      expect(result.steps).toHaveLength(2);
+      expect(result.steps[0].type).toBe("lookup");
+      expect(result.steps[1].type).toBe("get");
+    });
+
+    it("should throw ParseError for invalid DSL", () => {
+      const dsl = "INVALID SYNTAX";
+      expect(() => noql.parseDSL(dsl)).toThrow(ParseError);
+    });
+  });
+
+  describe("executeJson", () => {
+    it("should execute simple JSON query", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "testDb",
+          where: { _id: "user_1" },
+        },
+        steps: [],
+      };
+
+      const result = await noql.executeJson(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toMatchObject({
+        _id: "user_1",
+        name: "Alice",
+      });
+    });
+
+    it("should execute JSON query with GET step", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "testDb",
+          where: { _id: "user_1" },
+        },
+        steps: [{ type: "get", fields: ["name", "email"] }],
+      };
+
+      const result = await noql.executeJson(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "Alice",
+        email: "alice@test.com",
+      });
+    });
+
+    it("should execute JSON query with LOOKUP step", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "posts",
+          db: "testDb",
+          where: { _id: "post_1" },
+        },
+        steps: [
+          { type: "lookup", collection: "users", db: "testDb", by: "authorId" },
+          { type: "get", fields: ["name"] },
+        ],
+      };
+
+      const result = await noql.executeJson(query);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "Alice" });
+    });
+
+    it("should return error for document not found", async () => {
+      const query: JsonQuery = {
+        start: {
+          collection: "users",
+          db: "testDb",
+          where: { _id: "nonexistent" },
+        },
+        steps: [],
+      };
+
+      const result = await noql.executeJson(query);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("Document not found");
+    });
+
+    it("should execute query with trace output", async () => {
+      const query: JsonQuery = {
+        output: "trace",
+        start: {
+          collection: "users",
+          db: "testDb",
+          where: { _id: "user_1" },
+        },
+        steps: [{ type: "get", fields: ["name"] }],
+      };
+
+      const result = await noql.executeJson(query);
+
+      expect(result.success).toBe(true);
+      expect(result.trace).toBeDefined();
+      expect(result.trace).toHaveLength(2);
+    });
+  });
+
+  describe("executeDSL", () => {
+    it("should execute simple DSL query", async () => {
+      const dsl = 'FROM users IN testDb WHERE _id = "user_1"';
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toMatchObject({
+        _id: "user_1",
+        name: "Alice",
+      });
+    });
+
+    it("should execute DSL query with GET step", async () => {
+      const dsl = `
+FROM users IN testDb WHERE _id = "user_1"
+-> GET name, email
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "Alice",
+        email: "alice@test.com",
+      });
+    });
+
+    it("should execute DSL query with LOOKUP step", async () => {
+      const dsl = `
+FROM posts IN testDb WHERE _id = "post_1"
+-> LOOKUP users IN testDb BY authorId
+-> GET name, email
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "Alice",
+        email: "alice@test.com",
+      });
+    });
+
+    it("should execute DSL query with output format", async () => {
+      const dsl = `
+WITH output: "trace"
+FROM users IN testDb WHERE _id = "user_1"
+-> GET name
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.trace).toBeDefined();
+    });
+
+    it("should return error for invalid DSL syntax", async () => {
+      const dsl = "INVALID SYNTAX";
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("should return error for document not found", async () => {
+      const dsl = 'FROM users IN testDb WHERE _id = "nonexistent"';
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Document not found");
+    });
+
+    it("should execute complex multi-step DSL query", async () => {
+      const dsl = `
+FROM posts IN testDb WHERE _id = "post_2"
+-> LOOKUP users IN testDb BY authorId
+-> GET name, role
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "Bob",
+        role: "user",
+      });
+    });
+
+    it("should handle WHERE conditions with different value types", async () => {
+      const dsl = `
+FROM users IN testDb WHERE role = "admin"
+-> GET name
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toMatchObject({
+        name: "Alice",
+      });
+    });
+  });
+
+  describe("End-to-end DSL to execution flow", () => {
+    it("should parse and execute in one flow", async () => {
+      const dsl = `
+WITH output: "value"
+FROM posts IN testDb WHERE _id = "post_1"
+-> LOOKUP users IN testDb BY authorId
+-> GET name, email
+      `.trim();
+
+      // First parse to verify structure
+      const parsed = noql.parseDSL(dsl);
+      expect(parsed.output).toBe("value");
+      expect(parsed.steps).toHaveLength(2);
+
+      // Then execute
+      const result = await noql.executeDSL(dsl);
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({
+        name: "Alice",
+        email: "alice@test.com",
+      });
+    });
+
+    it("should handle document format output", async () => {
+      const dsl = `
+WITH output: "document"
+FROM users IN testDb WHERE _id = "user_2"
+-> GET name
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.result).toEqual({ name: "Bob" });
+    });
+
+    it("should provide detailed trace for debugging", async () => {
+      const dsl = `
+WITH output: "trace"
+FROM posts IN testDb WHERE _id = "post_1"
+-> LOOKUP users IN testDb BY authorId
+-> GET name
+      `.trim();
+
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(true);
+      expect(result.trace).toBeDefined();
+      expect(result.trace!.length).toBeGreaterThan(0);
+
+      // Verify trace structure
+      const startStep = result.trace![0];
+      expect(startStep.stepType).toBe("start");
+      expect(startStep.collection).toBe("posts");
+      expect(startStep.documentFound).toBeDefined();
+    });
+  });
+
+  describe("Error handling", () => {
+    it("should handle parse errors gracefully in executeDSL", async () => {
+      const dsl = "FROM users";
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("should handle execution errors gracefully", async () => {
+      const dsl = 'FROM nonexistent IN testDb WHERE _id = "test"';
+      const result = await noql.executeDSL(dsl);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});