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

package/test/entityService.subcollection-search.test.ts

@@ -1,5 +1,6 @@
 import { EntityService } from "../src/services/entityService";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { SQL } from "drizzle-orm";
 import { EntityCollection } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 const collectionRegistry = new PostgresCollectionRegistry();
@@ -7,7 +8,7 @@ import { DrizzleConditionBuilder } from "../src/utils/drizzle-conditions";
 
 describe("EntityService - Subcollection Search Tests", () => {
     let entityService: EntityService;
-    let db: jest.Mocked<NodePgDatabase<any>>;
+    let db: jest.Mocked<NodePgDatabase<Record<string, unknown>>>;
 
     // Mock tables for subcollection search scenarios
     const mockTagsTable = {
@@ -57,7 +58,8 @@ describe("EntityService - Subcollection Search Tests", () => {
             id: { type: "number" },
             name: { type: "string" },
             description: { type: "string" },
-            posts: { type: "relation", relationName: "posts" }
+            posts: { type: "relation",
+relationName: "posts" }
         },
         relations: [
             {
@@ -79,9 +81,12 @@ describe("EntityService - Subcollection Search Tests", () => {
             id: { type: "number" },
             title: { type: "string" },
             content: { type: "string" },
-            tag: { type: "relation", relationName: "tag" },
-            author: { type: "relation", relationName: "author" },
-            comments: { type: "relation", relationName: "comments" }
+            tag: { type: "relation",
+relationName: "tag" },
+            author: { type: "relation",
+relationName: "author" },
+            comments: { type: "relation",
+relationName: "comments" }
         },
         relations: [
             {
@@ -118,7 +123,8 @@ describe("EntityService - Subcollection Search Tests", () => {
             name: { type: "string" },
             email: { type: "string" },
             bio: { type: "string" },
-            posts: { type: "relation", relationName: "posts" }
+            posts: { type: "relation",
+relationName: "posts" }
         },
         relations: [
             {
@@ -140,7 +146,8 @@ describe("EntityService - Subcollection Search Tests", () => {
             id: { type: "number" },
             content: { type: "string" },
             author_name: { type: "string" },
-            post: { type: "relation", relationName: "post" }
+            post: { type: "relation",
+relationName: "post" }
         },
         relations: [
             {
@@ -155,7 +162,7 @@ describe("EntityService - Subcollection Search Tests", () => {
     };
 
     // Helper function to create a proper mock query builder
-    function createMockQueryBuilder(mockResults: any[]) {
+    function createMockQueryBuilder(mockResults: Record<string, unknown>[]) {
         const mockQueryBuilder = {
             from: jest.fn().mockReturnThis(),
             where: jest.fn().mockReturnThis(),
@@ -179,37 +186,37 @@ describe("EntityService - Subcollection Search Tests", () => {
             insert: jest.fn(),
             update: jest.fn(),
             transaction: jest.fn()
-        } as any;
+        } as unknown as jest.Mocked<NodePgDatabase<Record<string, unknown>>>;
 
         entityService = new EntityService(db, collectionRegistry);
 
         // Mock collection registry
-        jest.spyOn(collectionRegistry, 'getCollectionByPath').mockImplementation((path: string) => {
+        jest.spyOn(collectionRegistry, "getCollectionByPath").mockImplementation((path: string) => {
             switch (path) {
-                case 'tags':
+                case "tags":
                     return tagsCollection;
-                case 'posts':
+                case "posts":
                     return postsCollection;
-                case 'authors':
+                case "authors":
                     return authorsCollection;
-                case 'comments':
+                case "comments":
                     return commentsCollection;
                 default:
                     throw new Error(`Collection not found: ${path}`);
             }
         });
 
-        jest.spyOn(collectionRegistry, 'getTable').mockImplementation((tableName: string) => {
+        jest.spyOn(collectionRegistry, "getTable").mockImplementation((tableName: string) => {
             switch (tableName) {
-                case 'tags':
+                case "tags":
                     return mockTagsTable;
-                case 'posts':
+                case "posts":
                     return mockPostsTable;
-                case 'authors':
+                case "authors":
                     return mockAuthorsTable;
-                case 'comments':
+                case "comments":
                     return mockCommentsTable;
-                case 'posts_tags':
+                case "posts_tags":
                     return mockPostsTagsTable;
                 default:
                     return null;
@@ -217,15 +224,19 @@ describe("EntityService - Subcollection Search Tests", () => {
         });
 
         // Mock DrizzleConditionBuilder with more realistic behavior
-        jest.spyOn(DrizzleConditionBuilder, 'buildSearchConditions').mockReturnValue([
-            { operator: 'ilike', column: 'title', value: '%searchterm%' },
-            { operator: 'ilike', column: 'content', value: '%searchterm%' }
-        ] as any);
-
-        jest.spyOn(DrizzleConditionBuilder, 'combineConditionsWithOr').mockReturnValue({ combined: 'search_conditions' } as any);
-        jest.spyOn(DrizzleConditionBuilder, 'combineConditionsWithAnd').mockReturnValue({ combined: 'all_conditions' } as any);
-        jest.spyOn(DrizzleConditionBuilder, 'buildRelationQuery').mockImplementation((query) => query);
-        jest.spyOn(DrizzleConditionBuilder, 'buildFilterConditions').mockReturnValue([]);
+        jest.spyOn(DrizzleConditionBuilder, "buildSearchConditions").mockReturnValue([
+            { operator: "ilike",
+column: "title",
+value: "%searchterm%" },
+            { operator: "ilike",
+column: "content",
+value: "%searchterm%" }
+        ] as unknown as SQL[]);
+
+        jest.spyOn(DrizzleConditionBuilder, "combineConditionsWithOr").mockReturnValue({ combined: "search_conditions" } as unknown as SQL);
+        jest.spyOn(DrizzleConditionBuilder, "combineConditionsWithAnd").mockReturnValue({ combined: "all_conditions" } as unknown as SQL);
+        jest.spyOn(DrizzleConditionBuilder, "buildRelationQuery").mockImplementation((query) => query);
+        jest.spyOn(DrizzleConditionBuilder, "buildFilterConditions").mockReturnValue([]);
     });
 
     afterEach(() => {
@@ -236,12 +247,18 @@ describe("EntityService - Subcollection Search Tests", () => {
         it("should handle search in one-to-many inverse relation subcollection", async () => {
             // Scenario: Search posts under a specific tag (tags/19/posts)
             const mockResults = [
-                { id: 1, title: "Mental Health Tips", content: "Content about mental health", tag_id: 19 },
-                { id: 2, title: "Mental Wellness", content: "More mental health content", tag_id: 19 }
+                { id: 1,
+title: "Mental Health Tips",
+content: "Content about mental health",
+tag_id: 19 },
+                { id: 2,
+title: "Mental Wellness",
+content: "More mental health content",
+tag_id: 19 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("tags/19/posts", {
                 searchString: "mental",
@@ -265,12 +282,18 @@ describe("EntityService - Subcollection Search Tests", () => {
         it("should handle search in many-to-one owning relation subcollection", async () => {
             // Scenario: Search posts under a specific author (authors/5/posts)
             const mockResults = [
-                { id: 10, title: "Mental Strategies", content: "Author's take on mental health", author_id: 5 },
-                { id: 11, title: "Mindfulness Guide", content: "Mental wellness guide", author_id: 5 }
+                { id: 10,
+title: "Mental Strategies",
+content: "Author's take on mental health",
+author_id: 5 },
+                { id: 11,
+title: "Mindfulness Guide",
+content: "Mental wellness guide",
+author_id: 5 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("authors/5/posts", {
                 searchString: "mental",
@@ -290,12 +313,18 @@ describe("EntityService - Subcollection Search Tests", () => {
         it("should handle search in nested subcollection (posts/123/comments)", async () => {
             // Scenario: Search comments under a specific post (posts/123/comments)
             const mockResults = [
-                { id: 1, content: "Great mental health advice!", author_name: "John", post_id: 123 },
-                { id: 2, content: "Mental wellness is important", author_name: "Jane", post_id: 123 }
+                { id: 1,
+content: "Great mental health advice!",
+author_name: "John",
+post_id: 123 },
+                { id: 2,
+content: "Mental wellness is important",
+author_name: "Jane",
+post_id: 123 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("posts/123/comments", {
                 searchString: "mental",
@@ -313,15 +342,20 @@ describe("EntityService - Subcollection Search Tests", () => {
         it("should combine search conditions with existing filters", async () => {
             // Scenario: Search with both searchString and filter
             const mockResults = [
-                { id: 1, title: "Mental Health", content: "Published content", tag_id: 19 }
+                { id: 1,
+title: "Mental Health",
+content: "Published content",
+tag_id: 19 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             // Mock buildFilterConditions to return some filter conditions to ensure AND combination
-            const mockFilterConditions = [{ operator: 'eq', column: 'title', value: 'Mental Health' }] as any;
-            jest.spyOn(DrizzleConditionBuilder, 'buildFilterConditions').mockReturnValue(mockFilterConditions);
+            const mockFilterConditions = [{ operator: "eq",
+column: "title",
+value: "Mental Health" }] as unknown as SQL[];
+            jest.spyOn(DrizzleConditionBuilder, "buildFilterConditions").mockReturnValue(mockFilterConditions);
 
             const result = await entityService.fetchCollection("tags/19/posts", {
                 searchString: "mental",
@@ -342,11 +376,11 @@ describe("EntityService - Subcollection Search Tests", () => {
 
         it("should handle empty search results gracefully", async () => {
             // When buildSearchConditions returns empty array, the query still runs without search conditions
-            jest.spyOn(DrizzleConditionBuilder, 'buildSearchConditions').mockReturnValue([]);
+            jest.spyOn(DrizzleConditionBuilder, "buildSearchConditions").mockReturnValue([]);
 
             // Still need to mock db.select to return a query builder that returns empty results
             const mockQueryBuilder = createMockQueryBuilder([]);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("tags/19/posts", {
                 searchString: "nonexistent",
@@ -361,19 +395,26 @@ describe("EntityService - Subcollection Search Tests", () => {
 
         it("should handle search with ordering and pagination", async () => {
             const mockResults = [
-                { id: 3, title: "Mental Health Z", content: "Content Z", tag_id: 19 },
-                { id: 1, title: "Mental Health A", content: "Content A", tag_id: 19 }
+                { id: 3,
+title: "Mental Health Z",
+content: "Content Z",
+tag_id: 19 },
+                { id: 1,
+title: "Mental Health A",
+content: "Content A",
+tag_id: 19 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("tags/19/posts", {
                 searchString: "mental",
                 orderBy: "title",
                 order: "asc",
                 limit: 10,
-                startAfter: { id: 5, title: "Mental Health B" }
+                startAfter: { id: 5,
+title: "Mental Health B" }
             });
 
             // Verify search was processed
@@ -388,11 +429,14 @@ describe("EntityService - Subcollection Search Tests", () => {
     describe("searchEntities with subcollection paths", () => {
         it("should handle direct search on subcollection using searchEntities method", async () => {
             const mockResults = [
-                { id: 1, title: "Mental Health Guide", content: "Comprehensive guide", tag_id: 19 }
+                { id: 1,
+title: "Mental Health Guide",
+content: "Comprehensive guide",
+tag_id: 19 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             // searchEntities calls fetchEntitiesWithConditions which doesn't handle subcollection paths
             // It would need to be called with just the base collection path
@@ -412,11 +456,14 @@ describe("EntityService - Subcollection Search Tests", () => {
     describe("fetchRelatedEntities with search", () => {
         it("should pass search parameters correctly to fetchEntitiesUsingJoins", async () => {
             const mockResults = [
-                { id: 1, title: "Mental Health Post", content: "Content", tag_id: 19 }
+                { id: 1,
+title: "Mental Health Post",
+content: "Content",
+tag_id: 19 }
             ];
 
             const mockQueryBuilder = createMockQueryBuilder(mockResults);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             // Test fetchRelatedEntities directly with search
             const result = await entityService.fetchRelatedEntities("tags", 19, "posts", {
@@ -445,7 +492,7 @@ describe("EntityService - Subcollection Search Tests", () => {
             const mockCollection = { ...tagsCollection };
             mockCollection.relations = [];
 
-            jest.spyOn(collectionRegistry, 'getCollectionByPath').mockReturnValue(mockCollection);
+            jest.spyOn(collectionRegistry, "getCollectionByPath").mockReturnValue(mockCollection);
 
             await expect(entityService.fetchCollection("tags/19/nonexistent", {
                 searchString: "test"
@@ -454,11 +501,11 @@ describe("EntityService - Subcollection Search Tests", () => {
 
         it("should handle search in collection with no searchable properties", async () => {
             // Mock buildSearchConditions to return empty array
-            jest.spyOn(DrizzleConditionBuilder, 'buildSearchConditions').mockReturnValue([]);
+            jest.spyOn(DrizzleConditionBuilder, "buildSearchConditions").mockReturnValue([]);
 
             // Still need to mock db.select even though it might not be called, to avoid errors
             const mockQueryBuilder = createMockQueryBuilder([]);
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             const result = await entityService.fetchCollection("tags/19/posts", {
                 searchString: "mental"
@@ -477,7 +524,10 @@ describe("EntityService - Subcollection Search Tests", () => {
     describe("Performance and optimization", () => {
         it("should use proper limit when searching (default 50 for search)", async () => {
             const mockResults = [
-                { id: 1, title: "Mental Health", content: "Content", tag_id: 19 }
+                { id: 1,
+title: "Mental Health",
+content: "Content",
+tag_id: 19 }
             ];
 
             const mockLimit = jest.fn().mockReturnThis();
@@ -491,7 +541,7 @@ describe("EntityService - Subcollection Search Tests", () => {
                 then: jest.fn((resolve) => resolve(mockResults))
             };
 
-            db.select.mockReturnValue(mockQueryBuilder as any);
+            db.select.mockReturnValue(mockQueryBuilder as unknown as ReturnType<typeof db.select>);
 
             // Test without explicit limit - the system uses different behavior for subcollections
             await entityService.fetchCollection("tags/19/posts", {