@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/test/historyService.test.ts

@@ -1,12 +1,15 @@
 import { HistoryService, findChangedFields } from "../src/history/HistoryService";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { DrizzleClient } from "../src/interfaces";
+import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 
 describe("HistoryService - changedFields and history insertion logic", () => {
     describe("findChangedFields", () => {
         it("should return null when identical flat objects are compared", () => {
-            const oldValues = { title: "Hello", description: "World" };
-            const newValues = { title: "Hello", description: "World" };
+            const oldValues = { title: "Hello",
+description: "World" };
+            const newValues = { title: "Hello",
+description: "World" };
             const result = findChangedFields(oldValues, newValues);
             expect(result).toBeNull();
         });
@@ -19,19 +22,25 @@ describe("HistoryService - changedFields and history insertion logic", () => {
         });
 
         it("should skip properties starting with double underscore", () => {
-            const oldValues = { title: "Hello", __internal: 123 };
-            const newValues = { title: "Hello", __internal: 456 };
+            const oldValues = { title: "Hello",
+__internal: 123 };
+            const newValues = { title: "Hello",
+__internal: 456 };
             const result = findChangedFields(oldValues, newValues);
             expect(result).toBeNull();
         });
 
         it("should return null for deeply identical relations", () => {
             const oldValues = {
-                author: { id: "1", path: "authors", __type: "relation" },
+                author: { id: "1",
+path: "authors",
+__type: "relation" },
                 tags: [{ id: "1" }, { id: "2" }]
             };
             const newValues = {
-                author: { id: "1", path: "authors", __type: "relation" },
+                author: { id: "1",
+path: "authors",
+__type: "relation" },
                 tags: [{ id: "1" }, { id: "2" }]
             };
             const result = findChangedFields(oldValues as Record<string, unknown>, newValues as Record<string, unknown>);
@@ -40,15 +49,19 @@ describe("HistoryService - changedFields and history insertion logic", () => {
 
         it("should detect changes in relation properties when IDs differ", () => {
             const oldValues = {
-                author: { id: "1", path: "authors", __type: "relation" }
+                author: { id: "1",
+path: "authors",
+__type: "relation" }
             };
             const newValues = {
-                author: { id: "2", path: "authors", __type: "relation" }
+                author: { id: "2",
+path: "authors",
+__type: "relation" }
             };
             const result = findChangedFields(oldValues as Record<string, unknown>, newValues as Record<string, unknown>);
             expect(result).toEqual(["author"]);
         });
-        
+
         it("should detect differences in relation arrays", () => {
             const oldValues = {
                 tags: [{ id: "1" }]
@@ -69,8 +82,8 @@ describe("HistoryService - changedFields and history insertion logic", () => {
             db = {
                 execute: jest.fn().mockResolvedValue({})
             } as unknown as jest.Mocked<NodePgDatabase>;
-            historyService = new HistoryService(db as unknown as DrizzleClient, {} as any);
-            jest.spyOn(console, 'error').mockImplementation(() => {});
+            historyService = new HistoryService(db as unknown as DrizzleClient, {} as unknown as PostgresCollectionRegistry);
+            jest.spyOn(console, "error").mockImplementation(() => {});
         });
 
         afterEach(() => {
@@ -83,7 +96,7 @@ describe("HistoryService - changedFields and history insertion logic", () => {
                 entityId: "1",
                 action: "update",
                 previousValues: { title: "same" },
-                values: { title: "same" },
+                values: { title: "same" }
             });
 
             // db.execute should not be called since there is no data to log
@@ -95,15 +108,17 @@ describe("HistoryService - changedFields and history insertion logic", () => {
                 tableName: "posts",
                 entityId: "1",
                 action: "update",
-                previousValues: { title: "old", tags: [{ id: 1 }] },
-                values: { title: "new", tags: [{ id: 2 }] }
+                previousValues: { title: "old",
+tags: [{ id: 1 }] },
+                values: { title: "new",
+tags: [{ id: 2 }] }
             });
 
             // Since it's a difference, db.execute should be called. (plus 2 prune calls)
             expect(db.execute.mock.calls.length).toBeGreaterThanOrEqual(1);
-            
+
             const executedSql = db.execute.mock.calls[0][0] as unknown as { query: string; sql?: string; strings?: string[]; values?: unknown[] };
-            
+
             // Drizzle wraps SQL in its own SQL type which contains sql strings and params.
             const serializedSql = JSON.stringify(executedSql);
             // The syntax we added is ARRAY[?]::text[] or similar

package/test/n-plus-one-regression.test.ts

@@ -0,0 +1,314 @@
+/**
+ * N+1 Query Regression Test
+ *
+ * Validates that batch-loading of owning relations (e.g. posts → author)
+ * uses O(1) SQL queries instead of one query per entity.
+ *
+ * Root cause of the original bug:
+ *   `batchFetchRelatedEntities` for owning relations was passing parent
+ *   entity IDs (post IDs) to the query instead of the FK values (author IDs).
+ *   This meant `WHERE authors.id IN (1,2,3,...50)` used post IDs — completely
+ *   wrong. The fix reads FK values from the parent table first, then queries
+ *   the target table with correct FK values.
+ */
+import { RelationService } from "../src/services/RelationService";
+import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
+import type { EntityCollection, Relation } from "@rebasepro/types";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+// ─── Mock Tables ──────────────────────────────────────────────────
+const mockAuthorsTable = {
+    id: { name: "id",
+dataType: "number" },
+    name: { name: "name" },
+    _def: { tableName: "authors" }
+};
+
+const mockPostsTable = {
+    id: { name: "id",
+dataType: "number" },
+    title: { name: "title" },
+    author_id: { name: "author_id",
+dataType: "number" },
+    _def: { tableName: "posts" }
+};
+
+// ─── Mock Collections ─────────────────────────────────────────────
+let authorsCollection: EntityCollection;
+
+const postsCollection: EntityCollection = {
+    slug: "posts",
+    name: "Posts",
+    table: "posts",
+    properties: {
+        id: { type: "number" },
+        title: { type: "string" },
+        author: {
+            type: "relation",
+            relationName: "author"
+        }
+    },
+    relations: [
+        {
+            relationName: "author",
+            target: () => authorsCollection,
+            cardinality: "one",
+            direction: "owning",
+            localKey: "author_id"
+        }
+    ],
+    idField: "id"
+};
+
+authorsCollection = {
+    slug: "authors",
+    name: "Authors",
+    table: "authors",
+    properties: {
+        id: { type: "number" },
+        name: { type: "string" }
+    },
+    idField: "id"
+};
+
+// ─── Data generators ─────────────────────────────────────────────
+const NUM_POSTS = 50;
+const NUM_AUTHORS = 5;
+
+function generateMockPosts(count: number): Array<{ id: number; title: string; author_id: number }> {
+    return Array.from({ length: count }, (_, i) => ({
+        id: i + 1,
+        title: `Post ${i + 1}`,
+        author_id: (i % NUM_AUTHORS) + 1
+    }));
+}
+
+function generateMockAuthors(count: number): Array<{ id: number; name: string }> {
+    return Array.from({ length: count }, (_, i) => ({
+        id: i + 1,
+        name: `Author ${i + 1}`
+    }));
+}
+
+// ─── Tests ────────────────────────────────────────────────────────
+describe("N+1 Query Regression: batchFetchRelatedEntities (owning relations)", () => {
+    let registry: PostgresCollectionRegistry;
+    let selectCallCount: number;
+
+    /**
+     * Creates a mock Drizzle database that counts `select()` calls.
+     * Routes responses based on the table being queried.
+     */
+    function createSpiedDb(
+        mockPosts: ReturnType<typeof generateMockPosts>,
+        mockAuthors: ReturnType<typeof generateMockAuthors>
+    ) {
+        selectCallCount = 0;
+        let currentFromTable: string | undefined;
+        let currentSelectColumns: Record<string, unknown> | undefined;
+
+        function resolveResults(): unknown[] {
+            if (currentFromTable === "posts") {
+                // If selecting specific columns (parentId, fkValue shape from the FK lookup)
+                if (currentSelectColumns && Object.keys(currentSelectColumns).some(k => k === "parentId" || k === "fkValue")) {
+                    return mockPosts.map(p => ({
+                        parentId: p.id,
+                        fkValue: p.author_id
+                    }));
+                }
+                return mockPosts;
+            }
+            if (currentFromTable === "authors") {
+                return mockAuthors;
+            }
+            return [];
+        }
+
+        function makeChainable(): Record<string, unknown> {
+            const chain: Record<string, unknown> = {
+                select: jest.fn((columns?: Record<string, unknown>) => {
+                    selectCallCount++;
+                    currentSelectColumns = columns;
+                    return chain;
+                }),
+                from: jest.fn((table: Record<string, unknown>) => {
+                    const tableDef = table._def as { tableName: string } | undefined;
+                    currentFromTable = tableDef?.tableName ?? "unknown";
+                    return chain;
+                }),
+                where: jest.fn(() => chain),
+                $dynamic: jest.fn(() => chain),
+                limit: jest.fn(() => chain),
+                offset: jest.fn(() => chain),
+                orderBy: jest.fn(() => chain),
+                innerJoin: jest.fn(() => chain),
+                // Make it thenable so `await query` resolves to results
+                then: (resolve: (val: unknown[]) => void) => {
+                    resolve(resolveResults());
+                }
+            };
+            return chain;
+        }
+
+        return makeChainable() as unknown as jest.Mocked<NodePgDatabase>;
+    }
+
+    beforeEach(() => {
+        registry = new PostgresCollectionRegistry();
+
+        jest.spyOn(registry, "getCollectionByPath").mockImplementation(path => {
+            if (path?.startsWith("posts")) return postsCollection;
+            if (path?.startsWith("authors")) return authorsCollection;
+            return undefined;
+        });
+
+        jest.spyOn(registry, "getTable").mockImplementation(tableName => {
+            if (tableName === "posts") return mockPostsTable as unknown as ReturnType<typeof registry.getTable>;
+            if (tableName === "authors") return mockAuthorsTable as unknown as ReturnType<typeof registry.getTable>;
+            return undefined;
+        });
+
+        jest.spyOn(registry, "getCollections").mockReturnValue([postsCollection, authorsCollection]);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("should use exactly 2 SQL queries for owning relation batch fetch (not N+1)", async () => {
+        const mockPosts = generateMockPosts(NUM_POSTS);
+        const mockAuthors = generateMockAuthors(NUM_AUTHORS);
+        const db = createSpiedDb(mockPosts, mockAuthors);
+
+        const relationService = new RelationService(db, registry);
+        selectCallCount = 0;
+
+        const postIds = mockPosts.map(p => p.id);
+        const authorRelation = postsCollection.relations![0] as Relation;
+
+        const results = await relationService.batchFetchRelatedEntities(
+            "posts",
+            postIds,
+            "author",
+            authorRelation
+        );
+
+        // Exactly 2 queries:
+        //   1. SELECT id, author_id FROM posts WHERE id IN (...)  — FK lookup
+        //   2. SELECT * FROM authors WHERE id IN (...)             — target fetch
+        //
+        // The old broken code would have done either:
+        //   - 1 wrong query (WHERE authors.id IN (post_ids) — wrong IDs)
+        //   - Or N queries (one per entity)
+        expect(selectCallCount).toBe(2);
+
+        console.log(`[N+1 Regression] ${NUM_POSTS} posts: batchFetchRelatedEntities used ${selectCallCount} queries`);
+    });
+
+    it("should correctly map each post to its author via FK values", async () => {
+        const mockPosts = generateMockPosts(NUM_POSTS);
+        const mockAuthors = generateMockAuthors(NUM_AUTHORS);
+        const db = createSpiedDb(mockPosts, mockAuthors);
+
+        const relationService = new RelationService(db, registry);
+
+        const postIds = mockPosts.map(p => p.id);
+        const authorRelation = postsCollection.relations![0] as Relation;
+
+        const results = await relationService.batchFetchRelatedEntities(
+            "posts",
+            postIds,
+            "author",
+            authorRelation
+        );
+
+        // Every post should have a resolved author
+        for (const post of mockPosts) {
+            const authorEntity = results.get(String(post.id));
+            expect(authorEntity).toBeDefined();
+            expect(authorEntity!.path).toBe("authors");
+            // The author ID should match the FK value, not the post ID
+            expect(authorEntity!.id).toBe(String(post.author_id));
+        }
+    });
+
+    it("should handle null FK values gracefully (only 1 query for FK lookup)", async () => {
+        const nullFkPosts = Array.from({ length: 5 }, (_, i) => ({
+            id: i + 1,
+            title: `Orphan Post ${i + 1}`,
+            author_id: null as unknown as number
+        }));
+
+        const db = createSpiedDb(nullFkPosts as ReturnType<typeof generateMockPosts>, []);
+        const relationService = new RelationService(db, registry);
+        selectCallCount = 0;
+
+        const postIds = nullFkPosts.map(p => p.id);
+        const authorRelation = postsCollection.relations![0] as Relation;
+
+        const results = await relationService.batchFetchRelatedEntities(
+            "posts",
+            postIds,
+            "author",
+            authorRelation
+        );
+
+        // Only 1 query (FK lookup) then early-return since all FKs are null
+        expect(selectCallCount).toBe(1);
+        expect(results.size).toBe(0);
+    });
+
+    it("should deduplicate FK values when multiple entities share the same relation target", async () => {
+        // All 50 posts point to author 1
+        const sameAuthorPosts = Array.from({ length: NUM_POSTS }, (_, i) => ({
+            id: i + 1,
+            title: `Post ${i + 1}`,
+            author_id: 1
+        }));
+        const singleAuthor = [{ id: 1,
+name: "Shared Author" }];
+
+        const db = createSpiedDb(sameAuthorPosts, singleAuthor);
+        const relationService = new RelationService(db, registry);
+        selectCallCount = 0;
+
+        const postIds = sameAuthorPosts.map(p => p.id);
+        const authorRelation = postsCollection.relations![0] as Relation;
+
+        const results = await relationService.batchFetchRelatedEntities(
+            "posts",
+            postIds,
+            "author",
+            authorRelation
+        );
+
+        // Still exactly 2 queries
+        expect(selectCallCount).toBe(2);
+
+        // All 50 posts should resolve to the same author
+        for (const post of sameAuthorPosts) {
+            const authorEntity = results.get(String(post.id));
+            expect(authorEntity).toBeDefined();
+            expect(authorEntity!.id).toBe("1");
+            expect(authorEntity!.path).toBe("authors");
+        }
+    });
+
+    it("should handle empty parent IDs array without any queries", async () => {
+        const db = createSpiedDb([], []);
+        const relationService = new RelationService(db, registry);
+        selectCallCount = 0;
+
+        const authorRelation = postsCollection.relations![0] as Relation;
+
+        const results = await relationService.batchFetchRelatedEntities(
+            "posts",
+            [],
+            "author",
+            authorRelation
+        );
+
+        expect(selectCallCount).toBe(0);
+        expect(results.size).toBe(0);
+    });
+});