@rebasepro/server-core 0.0.1-canary.000dc36

package/test/backend-hooks-data.test.ts

@@ -0,0 +1,408 @@
+/**
+ * BackendHooks — Data (REST API) Integration Tests
+ *
+ * Verifies that DataHooks are correctly applied within RestApiGenerator
+ * for all collection CRUD operations.
+ */
+
+import { Hono } from "hono";
+import { RestApiGenerator } from "../src/api/rest/api-generator";
+import { errorHandler } from "../src/api/errors";
+import type { DataDriver } from "@rebasepro/types";
+import type { EntityCollection } from "@rebasepro/types";
+import type { DataHooks } from "@rebasepro/types";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function createMockDriver(): jest.Mocked<DataDriver> {
+    return {
+        key: "postgres",
+        initialised: true,
+        fetchCollection: jest.fn(),
+        listenCollection: jest.fn(),
+        fetchEntity: jest.fn(),
+        listenEntity: jest.fn(),
+        saveEntity: jest.fn(),
+        deleteEntity: jest.fn(),
+        checkUniqueField: jest.fn(),
+        countEntities: jest.fn(),
+        withAuth: jest.fn(),
+        admin: {} as any
+    } as unknown as jest.Mocked<DataDriver>;
+}
+
+const mockCollections: EntityCollection[] = [
+    { slug: "products", name: "Products", singularName: "Product", properties: {} } as any,
+    { slug: "orders", name: "Orders", singularName: "Order", properties: {} } as any
+];
+
+function createApp(mockDriver: jest.Mocked<DataDriver>, hooks?: DataHooks) {
+    const app = new Hono();
+    app.onError(errorHandler);
+    const generator = new RestApiGenerator(mockCollections, mockDriver, hooks);
+    app.route("/api", generator.generateRoutes());
+    return app;
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// TESTS
+// ═════════════════════════════════════════════════════════════════════════════
+
+describe("DataHooks — REST API", () => {
+    let mockDriver: jest.Mocked<DataDriver>;
+
+    beforeEach(() => {
+        mockDriver = createMockDriver();
+    });
+
+    // ── afterRead ─────────────────────────────────────────────────────
+    describe("data.afterRead", () => {
+        it("transforms entities in GET list response", async () => {
+            const hooks: DataHooks = {
+                afterRead(slug, entity) {
+                    // Mask price for non-premium entities
+                    if (slug === "products") {
+                        return { ...entity, price: "***" };
+                    }
+                    return entity;
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchCollection.mockResolvedValue([
+                { id: "p1", path: "products", values: { name: "Widget", price: 99 } } as any,
+                { id: "p2", path: "products", values: { name: "Gadget", price: 199 } } as any
+            ]);
+            mockDriver.countEntities!.mockResolvedValue(2);
+
+            const res = await app.request("/api/products");
+            expect(res.status).toBe(200);
+
+            const body = await res.json() as any;
+            expect(body.data).toHaveLength(2);
+            expect(body.data[0].price).toBe("***");
+            expect(body.data[1].price).toBe("***");
+            // Original field should still be there
+            expect(body.data[0].name).toBe("Widget");
+        });
+
+        it("filters out entities by returning null", async () => {
+            const hooks: DataHooks = {
+                afterRead(slug, entity) {
+                    // Hide draft products
+                    if (entity.status === "draft") return null;
+                    return entity;
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchCollection.mockResolvedValue([
+                { id: "p1", path: "products", values: { name: "Published", status: "active" } } as any,
+                { id: "p2", path: "products", values: { name: "Draft", status: "draft" } } as any,
+                { id: "p3", path: "products", values: { name: "Also Published", status: "active" } } as any
+            ]);
+            mockDriver.countEntities!.mockResolvedValue(3);
+
+            const res = await app.request("/api/products");
+            const body = await res.json() as any;
+            expect(body.data).toHaveLength(2);
+            expect(body.data.map((d: any) => d.name)).toEqual(["Published", "Also Published"]);
+        });
+
+        it("transforms single entity GET response", async () => {
+            const hooks: DataHooks = {
+                afterRead(slug, entity) {
+                    return { ...entity, _readAt: "2024-01-01" };
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue(
+                { id: "p1", path: "products", values: { name: "Widget" } } as any
+            );
+
+            const res = await app.request("/api/products/p1");
+            expect(res.status).toBe(200);
+
+            const body = await res.json() as any;
+            expect(body.name).toBe("Widget");
+            expect(body._readAt).toBe("2024-01-01");
+        });
+
+        it("returns 404 when afterRead filters a single entity", async () => {
+            const hooks: DataHooks = {
+                afterRead(slug, entity) {
+                    if (entity.id === "hidden") return null;
+                    return entity;
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue(
+                { id: "hidden", path: "products", values: { name: "Secret" } } as any
+            );
+
+            const res = await app.request("/api/products/hidden");
+            expect(res.status).toBe(404);
+        });
+
+        it("only affects targeted collection slug", async () => {
+            const hooks: DataHooks = {
+                afterRead(slug, entity) {
+                    if (slug === "products") {
+                        return { ...entity, hooked: true };
+                    }
+                    return entity;
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            // Products should be hooked
+            mockDriver.fetchEntity.mockResolvedValueOnce(
+                { id: "p1", path: "products", values: { name: "Widget" } } as any
+            );
+            const prodRes = await app.request("/api/products/p1");
+            const prodBody = await prodRes.json() as any;
+            expect(prodBody.hooked).toBe(true);
+
+            // Orders should NOT be hooked
+            mockDriver.fetchEntity.mockResolvedValueOnce(
+                { id: "o1", path: "orders", values: { total: 42 } } as any
+            );
+            const orderRes = await app.request("/api/orders/o1");
+            const orderBody = await orderRes.json() as any;
+            expect(orderBody.hooked).toBeUndefined();
+        });
+    });
+
+    // ── beforeSave ────────────────────────────────────────────────────
+    describe("data.beforeSave", () => {
+        it("transforms values before POST (create)", async () => {
+            const hooks: DataHooks = {
+                beforeSave(slug, values, entityId) {
+                    return { ...values, slug: values.name?.toString().toLowerCase().replace(/\s+/g, "-") };
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.saveEntity.mockResolvedValue(
+                { id: "new-1", path: "products", values: { name: "Cool Widget", slug: "cool-widget" } } as any
+            );
+
+            const res = await app.request("/api/products", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Cool Widget" })
+            });
+
+            expect(res.status).toBe(201);
+            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    values: expect.objectContaining({ slug: "cool-widget" })
+                })
+            );
+        });
+
+        it("transforms values before PUT (update)", async () => {
+            const hooks: DataHooks = {
+                beforeSave(slug, values, entityId) {
+                    // Add an updatedBy field
+                    return { ...values, updatedBy: "hook" };
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.saveEntity.mockResolvedValue(
+                { id: "p1", path: "products", values: { name: "Updated", updatedBy: "hook" } } as any
+            );
+
+            const res = await app.request("/api/products/p1", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Updated" })
+            });
+
+            expect(res.status).toBe(200);
+            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    values: expect.objectContaining({ updatedBy: "hook" })
+                })
+            );
+        });
+
+        it("receives entityId=undefined on POST, actual id on PUT", async () => {
+            const beforeSaveSpy = jest.fn((slug, values, entityId) => values);
+            const hooks: DataHooks = { beforeSave: beforeSaveSpy };
+            const app = createApp(mockDriver, hooks);
+
+            // POST
+            mockDriver.saveEntity.mockResolvedValueOnce(
+                { id: "new-1", path: "products", values: { name: "A" } } as any
+            );
+            await app.request("/api/products", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "A" })
+            });
+            expect(beforeSaveSpy.mock.calls[0][2]).toBeUndefined(); // entityId
+
+            // PUT
+            mockDriver.fetchEntity.mockResolvedValueOnce({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.saveEntity.mockResolvedValueOnce(
+                { id: "p1", path: "products", values: { name: "B" } } as any
+            );
+            await app.request("/api/products/p1", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "B" })
+            });
+            expect(beforeSaveSpy.mock.calls[1][2]).toBe("p1"); // entityId
+        });
+
+        it("aborts save when beforeSave throws", async () => {
+            const hooks: DataHooks = {
+                beforeSave(slug, values) {
+                    if (!values.name) throw new Error("Name is required");
+                    return values;
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            const res = await app.request("/api/products", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ price: 99 })
+            });
+
+            // Should get an error status
+            expect(res.status).toBeGreaterThanOrEqual(400);
+            expect(mockDriver.saveEntity).not.toHaveBeenCalled();
+        });
+    });
+
+    // ── afterSave ─────────────────────────────────────────────────────
+    describe("data.afterSave", () => {
+        it("fires afterSave after POST", async () => {
+            const afterSaveSpy = jest.fn();
+            const hooks: DataHooks = { afterSave: afterSaveSpy };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.saveEntity.mockResolvedValue(
+                { id: "new-1", path: "products", values: { name: "Widget" } } as any
+            );
+
+            const res = await app.request("/api/products", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Widget" })
+            });
+
+            expect(res.status).toBe(201);
+            await new Promise(r => setTimeout(r, 50));
+            expect(afterSaveSpy).toHaveBeenCalledTimes(1);
+            expect(afterSaveSpy).toHaveBeenCalledWith(
+                "products",
+                expect.objectContaining({ id: "new-1", name: "Widget" }),
+                expect.objectContaining({ method: "POST" })
+            );
+        });
+
+        it("fires afterSave after PUT", async () => {
+            const afterSaveSpy = jest.fn();
+            const hooks: DataHooks = { afterSave: afterSaveSpy };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.saveEntity.mockResolvedValue(
+                { id: "p1", path: "products", values: { name: "Updated" } } as any
+            );
+
+            await app.request("/api/products/p1", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Updated" })
+            });
+
+            await new Promise(r => setTimeout(r, 50));
+            expect(afterSaveSpy).toHaveBeenCalledWith(
+                "products",
+                expect.objectContaining({ id: "p1" }),
+                expect.objectContaining({ method: "PUT" })
+            );
+        });
+    });
+
+    // ── beforeDelete / afterDelete ───────────────────────────────────
+    describe("data.beforeDelete / afterDelete", () => {
+        it("aborts deletion when beforeDelete throws", async () => {
+            const hooks: DataHooks = {
+                beforeDelete(slug, entityId) {
+                    if (entityId === "protected") {
+                        throw new Error("Cannot delete protected entity");
+                    }
+                }
+            };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue(
+                { id: "protected", path: "products", values: {} } as any
+            );
+
+            const res = await app.request("/api/products/protected", { method: "DELETE" });
+            expect(res.status).toBe(500);
+            expect(mockDriver.deleteEntity).not.toHaveBeenCalled();
+        });
+
+        it("allows deletion when beforeDelete does not throw", async () => {
+            const beforeDeleteSpy = jest.fn();
+            const hooks: DataHooks = { beforeDelete: beforeDeleteSpy };
+            const app = createApp(mockDriver, hooks);
+
+            const existingEntity = { id: "p1", path: "products", values: {} } as any;
+            mockDriver.fetchEntity.mockResolvedValue(existingEntity);
+            mockDriver.deleteEntity.mockResolvedValue();
+
+            const res = await app.request("/api/products/p1", { method: "DELETE" });
+            expect(res.status).toBe(204);
+            expect(beforeDeleteSpy).toHaveBeenCalledWith(
+                "products", "p1", expect.objectContaining({ method: "DELETE" })
+            );
+            expect(mockDriver.deleteEntity).toHaveBeenCalled();
+        });
+
+        it("fires afterDelete after successful deletion", async () => {
+            const afterDeleteSpy = jest.fn();
+            const hooks: DataHooks = { afterDelete: afterDeleteSpy };
+            const app = createApp(mockDriver, hooks);
+
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.deleteEntity.mockResolvedValue();
+
+            await app.request("/api/products/p1", { method: "DELETE" });
+            await new Promise(r => setTimeout(r, 50));
+
+            expect(afterDeleteSpy).toHaveBeenCalledWith(
+                "products", "p1", expect.objectContaining({ method: "DELETE" })
+            );
+        });
+    });
+
+    // ── no hooks (passthrough) ──────────────────────────────────────
+    describe("no hooks configured", () => {
+        it("returns data unchanged when no hooks are provided", async () => {
+            const app = createApp(mockDriver); // no hooks
+            mockDriver.fetchCollection.mockResolvedValue([
+                { id: "p1", path: "products", values: { name: "Widget" } } as any
+            ]);
+            mockDriver.countEntities!.mockResolvedValue(1);
+
+            const res = await app.request("/api/products");
+            expect(res.status).toBe(200);
+
+            const body = await res.json() as any;
+            expect(body.data).toHaveLength(1);
+            expect(body.data[0].name).toBe("Widget");
+        });
+    });
+});

package/test/driver-registry.test.ts

@@ -0,0 +1,282 @@
+import {
+    DriverRegistry,
+    DefaultDriverRegistry,
+    DEFAULT_DRIVER_ID
+} from "../src/services/driver-registry";
+import { DataDriver } from "@rebasepro/types";
+
+/**
+ * Mock DataDriver for testing
+ */
+function createMockDataDriverDelegate(key: string): DataDriver {
+    return {
+        key,
+        initialised: true,
+        fetchCollection: jest.fn().mockResolvedValue([]),
+        fetchEntity: jest.fn().mockResolvedValue(undefined),
+        saveEntity: jest.fn().mockResolvedValue({ id: "test-id",
+path: "test",
+values: {} }),
+        deleteEntity: jest.fn().mockResolvedValue(undefined),
+        checkUniqueField: jest.fn().mockResolvedValue(true)
+    };
+}
+
+describe("DriverRegistry", () => {
+    describe("DEFAULT_DRIVER_ID", () => {
+        it("should be '(default)'", () => {
+            expect(DEFAULT_DRIVER_ID).toBe("(default)");
+        });
+    });
+
+    describe("DefaultDriverRegistry", () => {
+        describe("constructor and basic operations", () => {
+            it("should create an empty registry", () => {
+                const registry = new DefaultDriverRegistry();
+                expect(registry.size()).toBe(0);
+                expect(registry.list()).toEqual([]);
+            });
+
+            it("should register a driver", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register("test-db", mockDelegate);
+
+                expect(registry.has("test-db")).toBe(true);
+                expect(registry.size()).toBe(1);
+                expect(registry.list()).toContain("test-db");
+            });
+
+            it("should get a registered driver", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register("my-db", mockDelegate);
+
+                const retrieved = registry.get("my-db");
+                expect(retrieved).toBe(mockDelegate);
+            });
+
+            it("should return undefined for non-existent driver", () => {
+                const registry = new DefaultDriverRegistry();
+                expect(registry.get("non-existent")).toBeUndefined();
+            });
+        });
+
+        describe("default driver handling", () => {
+            it("should get default driver with get(undefined)", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
+
+                expect(registry.get(undefined)).toBe(mockDelegate);
+                expect(registry.get(null)).toBe(mockDelegate);
+            });
+
+            it("should get default driver with getDefault()", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
+
+                expect(registry.getDefault()).toBe(mockDelegate);
+            });
+
+            it("should throw error when no default driver exists", () => {
+                const registry = new DefaultDriverRegistry();
+
+                expect(() => registry.getDefault()).toThrow(
+                    "[DriverRegistry] No default driver registered."
+                );
+            });
+        });
+
+        describe("getOrDefault", () => {
+            let registry: DefaultDriverRegistry;
+            let defaultDelegate: DataDriver;
+            let analyticsDelegate: DataDriver;
+
+            beforeEach(() => {
+                registry = new DefaultDriverRegistry();
+                defaultDelegate = createMockDataDriverDelegate("default-postgres");
+                analyticsDelegate = createMockDataDriverDelegate("analytics-postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, defaultDelegate);
+                registry.register("analytics", analyticsDelegate);
+            });
+
+            it("should return specific driver when found", () => {
+                expect(registry.getOrDefault("analytics")).toBe(analyticsDelegate);
+            });
+
+            it("should return default when id is undefined", () => {
+                expect(registry.getOrDefault(undefined)).toBe(defaultDelegate);
+            });
+
+            it("should return default when id is null", () => {
+                expect(registry.getOrDefault(null)).toBe(defaultDelegate);
+            });
+
+            it("should fallback to default when id not found", () => {
+                // This should log a warning and return the default
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                expect(registry.getOrDefault("non-existent")).toBe(defaultDelegate);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Driver "non-existent" not found')
+                );
+
+                consoleSpy.mockRestore();
+            });
+
+            it("should throw when fallback fails (no default)", () => {
+                const emptyRegistry = new DefaultDriverRegistry();
+
+                expect(() => emptyRegistry.getOrDefault("anything")).toThrow();
+            });
+        });
+
+        describe("overwriting drivers", () => {
+            it("should overwrite existing driver with same id", () => {
+                const registry = new DefaultDriverRegistry();
+                const original = createMockDataDriverDelegate("original");
+                const replacement = createMockDataDriverDelegate("replacement");
+
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                registry.register("my-db", original);
+                registry.register("my-db", replacement);
+
+                expect(registry.get("my-db")).toBe(replacement);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Overwriting driver with id "my-db"')
+                );
+
+                consoleSpy.mockRestore();
+            });
+        });
+
+        describe("list and size", () => {
+            it("should list all registered drivers", () => {
+                const registry = new DefaultDriverRegistry();
+
+                registry.register("db-1", createMockDataDriverDelegate("pg1"));
+                registry.register("db-2", createMockDataDriverDelegate("pg2"));
+                registry.register(DEFAULT_DRIVER_ID, createMockDataDriverDelegate("default"));
+
+                const list = registry.list();
+                expect(list).toHaveLength(3);
+                expect(list).toContain("db-1");
+                expect(list).toContain("db-2");
+                expect(list).toContain(DEFAULT_DRIVER_ID);
+            });
+
+            it("should return correct size", () => {
+                const registry = new DefaultDriverRegistry();
+
+                expect(registry.size()).toBe(0);
+
+                registry.register("db-1", createMockDataDriverDelegate("pg1"));
+                expect(registry.size()).toBe(1);
+
+                registry.register("db-2", createMockDataDriverDelegate("pg2"));
+                expect(registry.size()).toBe(2);
+            });
+        });
+    });
+
+    describe("DefaultDriverRegistry.create() factory", () => {
+        describe("with single DataDriver", () => {
+            it('should register single delegate as "(default)"', () => {
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                const registry = DefaultDriverRegistry.create(mockDelegate);
+
+                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+                expect(registry.getDefault()).toBe(mockDelegate);
+                expect(registry.size()).toBe(1);
+            });
+        });
+
+        describe("with map of DataDriverDelegates", () => {
+            it("should register all delegates from map", () => {
+                const defaultDelegate = createMockDataDriverDelegate("default-pg");
+                const analyticsDelegate = createMockDataDriverDelegate("analytics-pg");
+
+                const registry = DefaultDriverRegistry.create({
+                    [DEFAULT_DRIVER_ID]: defaultDelegate,
+                    "analytics": analyticsDelegate
+                });
+
+                expect(registry.size()).toBe(2);
+                expect(registry.getDefault()).toBe(defaultDelegate);
+                expect(registry.get("analytics")).toBe(analyticsDelegate);
+            });
+
+            it("should use first entry as default if no explicit default provided", () => {
+                const db1 = createMockDataDriverDelegate("db1");
+                const db2 = createMockDataDriverDelegate("db2");
+
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                const registry = DefaultDriverRegistry.create({
+                    "primary": db1,
+                    "secondary": db2
+                });
+
+                // Should have registered both + created default pointing to first
+                expect(registry.size()).toBe(3); // primary, secondary, (default)
+                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('No "(default)" driver provided')
+                );
+
+                consoleSpy.mockRestore();
+            });
+
+            it("should handle empty map gracefully", () => {
+                const registry = DefaultDriverRegistry.create({});
+
+                expect(registry.size()).toBe(0);
+                expect(() => registry.getDefault()).toThrow();
+            });
+        });
+    });
+
+    describe("type detection (isDataDriverDelegate)", () => {
+        it("should correctly identify a DataDriver", () => {
+            const mockDelegate = createMockDataDriverDelegate("postgres");
+
+            // The factory should recognize it as a single delegate
+            const registry = DefaultDriverRegistry.create(mockDelegate);
+            expect(registry.size()).toBe(1);
+            expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+        });
+
+        it("should correctly identify a map of DataDriverDelegates", () => {
+            const delegates = {
+                [DEFAULT_DRIVER_ID]: createMockDataDriverDelegate("pg1"),
+                "other": createMockDataDriverDelegate("pg2")
+            };
+
+            // The factory should recognize it as a map
+            const registry = DefaultDriverRegistry.create(delegates);
+            expect(registry.size()).toBe(2);
+        });
+
+        it("should not mistakenly identify a map as a single delegate", () => {
+            // A map doesn't have the required DataDriver methods
+            const map = {
+                key: "not-a-delegate", // This looks like the key property but...
+                db1: createMockDataDriverDelegate("pg1")
+            };
+
+            // This should be treated as a map (and show a warning because 'key' isn't a valid delegate)
+            const registry = DefaultDriverRegistry.create(map as any);
+            // 'key' entry will be ignored since it's not a valid delegate
+            expect(registry.has("db1")).toBe(true);
+        });
+    });
+});