@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/tools/__tests__/docstore.test.ts

@@ -143,9 +143,11 @@ describe("Handler Execution", () => {
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_create_collection")!;
 
-      await expect(
-        tool.handler({ name: "invalid-name" }, mockContext),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler({ name: "invalid-name" }, mockContext);
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should add validation when specified", async () => {
@@ -175,7 +177,9 @@ describe("Handler Execution", () => {
     });
 
     it("should support ifNotExists parameter", async () => {
-      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(createMockQueryResult([])) // checkCollectionExists → false
+        .mockResolvedValue(createMockQueryResult([])); // CREATE TABLE succeeds
 
       const tool = tools.find((t) => t.name === "mysql_doc_create_collection")!;
       await tool.handler(
@@ -183,8 +187,30 @@ describe("Handler Execution", () => {
         mockContext,
       );
 
-      const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-      expect(call).toContain("CREATE TABLE IF NOT EXISTS");
+      const calls = mockAdapter.executeQuery.mock.calls;
+      const createCall = calls[calls.length - 1][0] as string;
+      expect(createCall).toContain("CREATE TABLE IF NOT EXISTS");
+    });
+
+    it("should return skipped when collection already exists with ifNotExists", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([{ "1": 1 }]), // checkCollectionExists → true
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_doc_create_collection")!;
+      const result = await tool.handler(
+        { name: "my_collection", ifNotExists: true },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: true,
+        skipped: true,
+        collection: "my_collection",
+        reason: "Collection already exists",
+      });
+      // Should NOT have called CREATE TABLE
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
 
     it("should not use IF NOT EXISTS by default", async () => {
@@ -194,7 +220,8 @@ describe("Handler Execution", () => {
       await tool.handler({ name: "my_collection" }, mockContext);
 
       const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
-      expect(call).toContain("CREATE TABLE `my_collection`");
+      expect(call).toContain("CREATE TABLE");
+      expect(call).toContain("`my_collection`");
       expect(call).not.toContain("IF NOT EXISTS");
     });
 
@@ -207,14 +234,33 @@ describe("Handler Execution", () => {
       const result = (await tool.handler(
         { name: "my_collection" },
         mockContext,
-      )) as { success: boolean; reason: string };
+      )) as { success: boolean; error: string };
 
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty(
-        "reason",
+        "error",
         "Collection 'my_collection' already exists",
       );
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error(
+          "Query failed: Execute failed: Unknown database 'fake_schema'",
+        ),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_doc_create_collection")!;
+      const result = await tool.handler(
+        { name: "my_collection", schema: "fake_schema" },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        exists: false,
+        schema: "fake_schema",
+      });
+    });
   });
 
   describe("mysql_doc_drop_collection", () => {
@@ -260,9 +306,14 @@ describe("Handler Execution", () => {
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_drop_collection")!;
-      await expect(
-        tool.handler({ name: "bad;drop table users" }, mockContext),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        { name: "bad;drop table users" },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful error when collection does not exist", async () => {
@@ -274,20 +325,34 @@ describe("Handler Execution", () => {
       const result = (await tool.handler(
         { name: "nonexistent", ifExists: false },
         mockContext,
-      )) as { success: boolean; reason: string };
+      )) as { success: boolean; error: string };
 
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty(
-        "reason",
+        "error",
         "Collection 'nonexistent' does not exist",
       );
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_drop_collection")!;
+      const result = await tool.handler(
+        { name: "users", schema: "nonexistent_schema" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
   });
 
   describe("mysql_doc_find", () => {
-    it("should query documents with filters", async () => {
-      // First call: collection existence check
-      // Second call: actual document query
+    it("should query documents with valid filter", async () => {
       mockAdapter.executeQuery
         .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
         .mockResolvedValueOnce(
@@ -298,19 +363,86 @@ describe("Handler Execution", () => {
       const result = await tool.handler(
         {
           collection: "users",
-          filter: "$.age > 20",
+          filter: "$.age",
         },
         mockContext,
       );
 
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
       const call = mockAdapter.executeQuery.mock.calls[1][0] as string;
-      expect(call).toContain(
-        "WHERE JSON_EXTRACT(doc, '$.age > 20') IS NOT NULL",
-      );
+      expect(call).toContain("WHERE JSON_EXTRACT(doc, '$.age') IS NOT NULL");
       expect(result).toHaveProperty("documents");
     });
 
+    it("should reject SQL injection in filter", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([{ "1": 1 }]),
+      ); // collection exists
+
+      const tool = tools.find((t) => t.name === "mysql_doc_find")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          filter: "$') IS NOT NULL OR 1=1 -- ",
+        },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+      // Should NOT have executed the document query
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+    });
+
+    it("should reject invalid JSON path in filter", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([{ "1": 1 }]),
+      ); // collection exists
+
+      const tool = tools.find((t) => t.name === "mysql_doc_find")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          filter: "$.age > 20",
+        },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+    });
+
+    it("should use schema parameter for collection lookup", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ SCHEMA_NAME: "otherdb" }]),
+        ) // schema exists
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
+        .mockResolvedValueOnce(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_doc_find")!;
+      await tool.handler(
+        { collection: "my_coll", schema: "otherdb" },
+        mockContext,
+      );
+
+      // First call: schema existence check
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining("SCHEMATA"),
+        ["otherdb"],
+      );
+      // Second call: collection existence check with schema
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.any(String),
+        ["otherdb", "my_coll"],
+      );
+      // Query should use qualified table ref
+      const queryCall = mockAdapter.executeQuery.mock.calls[2][0] as string;
+      expect(queryCall).toContain("`otherdb`.`my_coll`");
+    });
+
     it("should return exists: false without error field for nonexistent collection", async () => {
       mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // collection does not exist
 
@@ -386,9 +518,14 @@ describe("Handler Execution", () => {
 
     it("should validate collection name", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_find")!;
-      await expect(
-        tool.handler({ collection: "invalid-name; --" }, mockContext),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        { collection: "invalid-name; --" },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful response when collection does not exist", async () => {
@@ -410,6 +547,22 @@ describe("Handler Execution", () => {
       expect(result).not.toHaveProperty("error");
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_find")!;
+      const result = await tool.handler(
+        { collection: "users", schema: "nonexistent_schema" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
   });
 
   describe("mysql_doc_add", () => {
@@ -454,15 +607,17 @@ describe("Handler Execution", () => {
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_add")!;
-      await expect(
-        tool.handler(
-          {
-            collection: "invalid-name",
-            documents: [{ name: "test" }],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        {
+          collection: "invalid-name",
+          documents: [{ name: "test" }],
+        },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful response when collection does not exist", async () => {
@@ -481,6 +636,61 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("collection", "nonexistent");
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_add")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          schema: "nonexistent_schema",
+          documents: [{ name: "test" }],
+        },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
+
+    it("should use schema parameter for collection lookup", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ SCHEMA_NAME: "otherdb" }]),
+        ) // schema exists
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
+        .mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_doc_add")!;
+      await tool.handler(
+        {
+          collection: "my_coll",
+          schema: "otherdb",
+          documents: [{ name: "test" }],
+        },
+        mockContext,
+      );
+
+      // First call: schema existence check
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining("SCHEMATA"),
+        ["otherdb"],
+      );
+      // Second call: collection existence check with schema
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.any(String),
+        ["otherdb", "my_coll"],
+      );
+      // Insert should use qualified table ref
+      const insertCall = mockAdapter.executeQuery.mock.calls[2][0] as string;
+      expect(insertCall).toContain("`otherdb`.`my_coll`");
+    });
   });
 
   describe("mysql_doc_modify", () => {
@@ -546,32 +756,36 @@ describe("Handler Execution", () => {
       expect(call).toContain("UPDATE `users` SET");
     });
 
-    it("should throw if no modifications specified", async () => {
+    it("should return error if no modifications specified", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_modify")!;
 
-      await expect(
-        tool.handler(
-          {
-            collection: "users",
-            filter: "$.active",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("No modifications specified");
+      const result = await tool.handler(
+        {
+          collection: "users",
+          filter: "$.active",
+        },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "No modifications specified",
+      });
     });
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_modify")!;
-      await expect(
-        tool.handler(
-          {
-            collection: "invalid-name",
-            filter: "$.id",
-            set: { a: 1 },
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        {
+          collection: "invalid-name",
+          filter: "$.id",
+          set: { a: 1 },
+        },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful response when collection does not exist", async () => {
@@ -591,6 +805,50 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("collection", "nonexistent");
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_modify")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          schema: "nonexistent_schema",
+          filter: "$.name",
+          set: { status: "active" },
+        },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
+
+    it("should use schema parameter for collection lookup", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ SCHEMA_NAME: "otherdb" }]),
+        ) // schema exists
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
+        .mockResolvedValueOnce(createMockQueryResult([], 2));
+
+      const tool = tools.find((t) => t.name === "mysql_doc_modify")!;
+      await tool.handler(
+        {
+          collection: "my_coll",
+          schema: "otherdb",
+          filter: "$.name",
+          set: { status: "active" },
+        },
+        mockContext,
+      );
+
+      const updateCall = mockAdapter.executeQuery.mock.calls[2][0] as string;
+      expect(updateCall).toContain("`otherdb`.`my_coll`");
+    });
   });
 
   describe("mysql_doc_remove", () => {
@@ -617,15 +875,17 @@ describe("Handler Execution", () => {
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_remove")!;
-      await expect(
-        tool.handler(
-          {
-            collection: "invalid-name",
-            filter: "$.id",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        {
+          collection: "invalid-name",
+          filter: "$.id",
+        },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful response when collection does not exist", async () => {
@@ -644,6 +904,48 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("collection", "nonexistent");
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_remove")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          schema: "nonexistent_schema",
+          filter: "$.id",
+        },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
+
+    it("should use schema parameter for collection lookup", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ SCHEMA_NAME: "otherdb" }]),
+        ) // schema exists
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
+        .mockResolvedValueOnce(createMockQueryResult([], 1));
+
+      const tool = tools.find((t) => t.name === "mysql_doc_remove")!;
+      await tool.handler(
+        {
+          collection: "my_coll",
+          schema: "otherdb",
+          filter: "$.name",
+        },
+        mockContext,
+      );
+
+      const deleteCall = mockAdapter.executeQuery.mock.calls[2][0] as string;
+      expect(deleteCall).toContain("`otherdb`.`my_coll`");
+    });
   });
 
   describe("mysql_doc_create_index", () => {
@@ -719,30 +1021,31 @@ describe("Handler Execution", () => {
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_create_index")!;
-      await expect(
-        tool.handler(
-          {
-            collection: "invalid-name",
-            name: "index",
-            fields: [{ path: "email", type: "TEXT" }],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        {
+          collection: "invalid-name",
+          name: "index",
+          fields: [{ path: "email", type: "TEXT" }],
+        },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should reject invalid index names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_create_index")!;
-      await expect(
-        tool.handler(
-          {
-            collection: "valid_coll",
-            name: "invalid-index",
-            fields: [{ path: "email", type: "TEXT" }],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid index name");
+      const result = await tool.handler(
+        {
+          collection: "valid_coll",
+          name: "invalid-index",
+          fields: [{ path: "email", type: "TEXT" }],
+        },
+        mockContext,
+      );
+      expect(result).toEqual({ success: false, error: "Invalid index name" });
     });
 
     it("should return graceful response when collection does not exist", async () => {
@@ -763,6 +1066,53 @@ describe("Handler Execution", () => {
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
 
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_create_index")!;
+      const result = await tool.handler(
+        {
+          collection: "users",
+          schema: "nonexistent_schema",
+          name: "idx_test",
+          fields: [{ path: "email", type: "TEXT" }],
+        },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
+
+    it("should use schema parameter for collection lookup", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ SCHEMA_NAME: "otherdb" }]),
+        ) // schema exists
+        .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
+        .mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_doc_create_index")!;
+      await tool.handler(
+        {
+          collection: "my_coll",
+          schema: "otherdb",
+          name: "idx_name",
+          fields: [{ path: "name", type: "TEXT" }],
+        },
+        mockContext,
+      );
+
+      // ALTER TABLE and CREATE INDEX should use qualified table ref
+      const alterCall = mockAdapter.executeQuery.mock.calls[2][0] as string;
+      expect(alterCall).toContain("`otherdb`.`my_coll`");
+      const indexCall = mockAdapter.executeQuery.mock.calls[3][0] as string;
+      expect(indexCall).toContain("`otherdb`.`my_coll`");
+    });
+
     it("should return graceful error on duplicate column", async () => {
       mockAdapter.executeQuery
         .mockResolvedValueOnce(createMockQueryResult([{ "1": 1 }])) // collection exists
@@ -776,10 +1126,10 @@ describe("Handler Execution", () => {
           fields: [{ path: "email", type: "TEXT" }],
         },
         mockContext,
-      )) as { success: boolean; reason: string };
+      )) as { success: boolean; error: string };
 
       expect(result).toHaveProperty("success", false);
-      expect(result.reason).toContain("already exist");
+      expect(result.error).toContain("already exist");
     });
   });
 
@@ -806,13 +1156,18 @@ describe("Handler Execution", () => {
 
     it("should reject invalid collection names", async () => {
       const tool = tools.find((t) => t.name === "mysql_doc_collection_info")!;
-      await expect(
-        tool.handler({ collection: "invalid-nam$" }, mockContext),
-      ).rejects.toThrow("Invalid collection name");
+      const result = await tool.handler(
+        { collection: "invalid-nam$" },
+        mockContext,
+      );
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid collection name",
+      });
     });
 
     it("should return graceful response when collection does not exist", async () => {
-      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // collection does not exist
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // collection does not exist (no schema → skip schema check)
 
       const tool = tools.find((t) => t.name === "mysql_doc_collection_info")!;
       const result = (await tool.handler(
@@ -824,5 +1179,21 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("collection", "nonexistent");
       expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
     });
+
+    it("should return exists: false for nonexistent schema", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // schema does not exist
+
+      const tool = tools.find((t) => t.name === "mysql_doc_collection_info")!;
+      const result = await tool.handler(
+        { collection: "users", schema: "nonexistent_schema" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({
+        exists: false,
+        schema: "nonexistent_schema",
+      });
+    });
   });
 });