@rebasepro/server-postgresql 0.5.0 → 0.6.0

package/test/property-ordering.test.ts

@@ -1,6 +1,6 @@
 import {
     computePropertyPriority, sortPropertiesOrder,
-    PropertyOrderingContext, PropertyOrderEntry,
+    PropertyOrderingContext, PropertyOrderEntry
 } from "../src/schema/introspect-db-logic";
 
 // ── Helpers ───────────────────────────────────────────────────────────
@@ -13,12 +13,13 @@ function mkCtx(overrides: Partial<PropertyOrderingContext> = {}): PropertyOrderi
         isStorage: false,
         pgDataType: "character varying",
         originalIndex: 0,
-        ...overrides,
+        ...overrides
     };
 }
 
 function mkEntry(key: string, overrides: Partial<PropertyOrderingContext> = {}): PropertyOrderEntry {
-    return { key, ctx: mkCtx(overrides) };
+    return { key,
+ctx: mkCtx(overrides) };
 }
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -52,7 +53,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(10);
                 expect(score).toBeLessThan(20);
-            },
+            }
         );
 
         it("ranks 'product_name' as partial match in tier 1b (17-19)", () => {
@@ -75,7 +76,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(20);
                 expect(score).toBeLessThan(30);
-            },
+            }
         );
 
         it("ranks first_name before last_name", () => {
@@ -92,7 +93,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(30);
                 expect(score).toBeLessThan(40);
-            },
+            }
         );
     });
 
@@ -110,7 +111,8 @@ describe("computePropertyPriority", () => {
         });
 
         it("ranks short string (varchar) in tier 4", () => {
-            const score = computePropertyPriority("color", mkCtx({ propType: "string", pgDataType: "character varying" }));
+            const score = computePropertyPriority("color", mkCtx({ propType: "string",
+pgDataType: "character varying" }));
             expect(score).toBeGreaterThanOrEqual(40);
             expect(score).toBeLessThan(50);
         });
@@ -145,7 +147,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(70);
                 expect(score).toBeLessThan(80);
-            },
+            }
         );
     });
 
@@ -156,7 +158,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(80);
                 expect(score).toBeLessThan(90);
-            },
+            }
         );
     });
 
@@ -173,7 +175,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx());
                 expect(score).toBeGreaterThanOrEqual(90);
                 expect(score).toBeLessThan(100);
-            },
+            }
         );
 
         it("ranks URL-suffix fields in tier 9", () => {
@@ -212,7 +214,7 @@ describe("computePropertyPriority", () => {
                 const score = computePropertyPriority(col, mkCtx({ propType: "date" }));
                 expect(score).toBeGreaterThanOrEqual(120);
                 expect(score).toBeLessThan(130);
-            },
+            }
         );
 
         it("ranks created_at before updated_at", () => {
@@ -249,10 +251,12 @@ describe("computePropertyPriority", () => {
 describe("sortPropertiesOrder", () => {
     it("places 'id' before 'name' before generic fields", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("created_at", { propType: "date", originalIndex: 3 }),
+            mkEntry("created_at", { propType: "date",
+originalIndex: 3 }),
             mkEntry("name", { originalIndex: 1 }),
-            mkEntry("id", { isPk: true, originalIndex: 0 }),
-            mkEntry("status", { originalIndex: 2 }),
+            mkEntry("id", { isPk: true,
+originalIndex: 0 }),
+            mkEntry("status", { originalIndex: 2 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result).toEqual(["id", "name", "status", "created_at"]);
@@ -260,95 +264,132 @@ describe("sortPropertiesOrder", () => {
 
     it("sorts a realistic user table correctly", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("id", { isPk: true, propType: "string", pgDataType: "uuid", originalIndex: 0 }),
-            mkEntry("created_at", { propType: "date", originalIndex: 1 }),
-            mkEntry("updated_at", { propType: "date", originalIndex: 2 }),
+            mkEntry("id", { isPk: true,
+propType: "string",
+pgDataType: "uuid",
+originalIndex: 0 }),
+            mkEntry("created_at", { propType: "date",
+originalIndex: 1 }),
+            mkEntry("updated_at", { propType: "date",
+originalIndex: 2 }),
             mkEntry("email", { originalIndex: 3 }),
             mkEntry("first_name", { originalIndex: 4 }),
             mkEntry("last_name", { originalIndex: 5 }),
-            mkEntry("avatar", { isStorage: true, originalIndex: 6 }),
-            mkEntry("role", { isEnum: true, originalIndex: 7 }),
-            mkEntry("active", { propType: "boolean", originalIndex: 8 }),
-            mkEntry("bio", { pgDataType: "text", originalIndex: 9 }),
-            mkEntry("metadata", { propType: "map", pgDataType: "jsonb", originalIndex: 10 }),
+            mkEntry("avatar", { isStorage: true,
+originalIndex: 6 }),
+            mkEntry("role", { isEnum: true,
+originalIndex: 7 }),
+            mkEntry("active", { propType: "boolean",
+originalIndex: 8 }),
+            mkEntry("bio", { pgDataType: "text",
+originalIndex: 9 }),
+            mkEntry("metadata", { propType: "map",
+pgDataType: "jsonb",
+originalIndex: 10 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result).toEqual([
-            "id",           // tier 0: PK
-            "first_name",   // tier 2: human identity
-            "last_name",    // tier 2: human identity
-            "email",        // tier 2: human identity
-            "role",         // tier 4: enum
-            "active",       // tier 4: boolean
-            "bio",          // tier 7: long text
-            "avatar",       // tier 9: storage
-            "metadata",     // tier 10: map
-            "created_at",   // tier 12: system timestamp
-            "updated_at",   // tier 12: system timestamp
+            "id", // tier 0: PK
+            "first_name", // tier 2: human identity
+            "last_name", // tier 2: human identity
+            "email", // tier 2: human identity
+            "role", // tier 4: enum
+            "active", // tier 4: boolean
+            "bio", // tier 7: long text
+            "avatar", // tier 9: storage
+            "metadata", // tier 10: map
+            "created_at", // tier 12: system timestamp
+            "updated_at" // tier 12: system timestamp
         ]);
     });
 
     it("sorts a realistic product table correctly", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("id", { isPk: true, propType: "number", pgDataType: "integer", originalIndex: 0 }),
-            mkEntry("created_at", { propType: "date", originalIndex: 1 }),
+            mkEntry("id", { isPk: true,
+propType: "number",
+pgDataType: "integer",
+originalIndex: 0 }),
+            mkEntry("created_at", { propType: "date",
+originalIndex: 1 }),
             mkEntry("sku", { originalIndex: 2 }),
             mkEntry("name", { originalIndex: 3 }),
-            mkEntry("description", { pgDataType: "text", originalIndex: 4 }),
-            mkEntry("price", { propType: "number", originalIndex: 5 }),
-            mkEntry("category", { propType: "relation", originalIndex: 6 }),
-            mkEntry("cover_image", { isStorage: true, originalIndex: 7 }),
-            mkEntry("active", { propType: "boolean", originalIndex: 8 }),
+            mkEntry("description", { pgDataType: "text",
+originalIndex: 4 }),
+            mkEntry("price", { propType: "number",
+originalIndex: 5 }),
+            mkEntry("category", { propType: "relation",
+originalIndex: 6 }),
+            mkEntry("cover_image", { isStorage: true,
+originalIndex: 7 }),
+            mkEntry("active", { propType: "boolean",
+originalIndex: 8 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result).toEqual([
-            "id",             // tier 0: PK
-            "name",           // tier 1: title/name
-            "sku",            // tier 3: descriptor
-            "category",       // tier 3: descriptor (name match overrides relation tier)
-            "active",         // tier 4: boolean
-            "price",          // tier 5: number
-            "description",    // tier 7: long text
-            "cover_image",    // tier 9: storage
-            "created_at",     // tier 12: system timestamp
+            "id", // tier 0: PK
+            "name", // tier 1: title/name
+            "sku", // tier 3: descriptor
+            "category", // tier 3: descriptor (name match overrides relation tier)
+            "active", // tier 4: boolean
+            "price", // tier 5: number
+            "description", // tier 7: long text
+            "cover_image", // tier 9: storage
+            "created_at" // tier 12: system timestamp
         ]);
     });
 
     it("sorts a blog post table correctly", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("id", { isPk: true, propType: "string", pgDataType: "uuid", originalIndex: 0 }),
-            mkEntry("updated_at", { propType: "date", originalIndex: 1 }),
-            mkEntry("created_at", { propType: "date", originalIndex: 2 }),
-            mkEntry("content", { pgDataType: "text", originalIndex: 3 }),
+            mkEntry("id", { isPk: true,
+propType: "string",
+pgDataType: "uuid",
+originalIndex: 0 }),
+            mkEntry("updated_at", { propType: "date",
+originalIndex: 1 }),
+            mkEntry("created_at", { propType: "date",
+originalIndex: 2 }),
+            mkEntry("content", { pgDataType: "text",
+originalIndex: 3 }),
             mkEntry("title", { originalIndex: 4 }),
             mkEntry("slug", { originalIndex: 5 }),
-            mkEntry("status", { isEnum: true, originalIndex: 6 }),
-            mkEntry("author", { propType: "relation", originalIndex: 7 }),
-            mkEntry("published_at", { propType: "date", originalIndex: 8 }),
-            mkEntry("cover_image", { isStorage: true, originalIndex: 9 }),
-            mkEntry("excerpt", { pgDataType: "text", originalIndex: 10 }),
+            mkEntry("status", { isEnum: true,
+originalIndex: 6 }),
+            mkEntry("author", { propType: "relation",
+originalIndex: 7 }),
+            mkEntry("published_at", { propType: "date",
+originalIndex: 8 }),
+            mkEntry("cover_image", { isStorage: true,
+originalIndex: 9 }),
+            mkEntry("excerpt", { pgDataType: "text",
+originalIndex: 10 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result).toEqual([
-            "id",             // tier 0: PK
-            "title",          // tier 1: title
-            "slug",           // tier 3: descriptor
-            "status",         // tier 4: enum
-            "published_at",   // tier 5: user-facing date
-            "author",         // tier 6: relation
-            "excerpt",        // tier 7: long text
-            "content",        // tier 8: rich content
-            "cover_image",    // tier 9: storage
-            "created_at",     // tier 12: system timestamp
-            "updated_at",     // tier 12: system timestamp
+            "id", // tier 0: PK
+            "title", // tier 1: title
+            "slug", // tier 3: descriptor
+            "status", // tier 4: enum
+            "published_at", // tier 5: user-facing date
+            "author", // tier 6: relation
+            "excerpt", // tier 7: long text
+            "content", // tier 8: rich content
+            "cover_image", // tier 9: storage
+            "created_at", // tier 12: system timestamp
+            "updated_at" // tier 12: system timestamp
         ]);
     });
 
     it("preserves original order for properties in the same tier", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("color", { propType: "string", pgDataType: "character varying", originalIndex: 0 }),
-            mkEntry("size", { propType: "string", pgDataType: "character varying", originalIndex: 1 }),
-            mkEntry("weight", { propType: "string", pgDataType: "character varying", originalIndex: 2 }),
+            mkEntry("color", { propType: "string",
+pgDataType: "character varying",
+originalIndex: 0 }),
+            mkEntry("size", { propType: "string",
+pgDataType: "character varying",
+originalIndex: 1 }),
+            mkEntry("weight", { propType: "string",
+pgDataType: "character varying",
+originalIndex: 2 })
         ];
         const result = sortPropertiesOrder(entries);
         // All three are tier 4 (short strings), should preserve original order
@@ -357,9 +398,12 @@ describe("sortPropertiesOrder", () => {
 
     it("handles tables with only system columns", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("id", { isPk: true, originalIndex: 0 }),
-            mkEntry("created_at", { propType: "date", originalIndex: 1 }),
-            mkEntry("updated_at", { propType: "date", originalIndex: 2 }),
+            mkEntry("id", { isPk: true,
+originalIndex: 0 }),
+            mkEntry("created_at", { propType: "date",
+originalIndex: 1 }),
+            mkEntry("updated_at", { propType: "date",
+originalIndex: 2 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result).toEqual(["id", "created_at", "updated_at"]);
@@ -367,10 +411,12 @@ describe("sortPropertiesOrder", () => {
 
     it("handles partial name matches (product_name, page_title)", () => {
         const entries: PropertyOrderEntry[] = [
-            mkEntry("id", { isPk: true, originalIndex: 0 }),
+            mkEntry("id", { isPk: true,
+originalIndex: 0 }),
             mkEntry("product_name", { originalIndex: 1 }),
             mkEntry("category", { originalIndex: 2 }),
-            mkEntry("price", { propType: "number", originalIndex: 3 }),
+            mkEntry("price", { propType: "number",
+originalIndex: 3 })
         ];
         const result = sortPropertiesOrder(entries);
         // product_name should come after id but before category and price
@@ -382,8 +428,9 @@ describe("sortPropertiesOrder", () => {
         const entries: PropertyOrderEntry[] = [
             mkEntry("name", { originalIndex: 0 }),
             mkEntry("website_url", { originalIndex: 1 }),
-            mkEntry("avatar", { isStorage: true, originalIndex: 2 }),
-            mkEntry("thumbnail", { originalIndex: 3 }),
+            mkEntry("avatar", { isStorage: true,
+originalIndex: 2 }),
+            mkEntry("thumbnail", { originalIndex: 3 })
         ];
         const result = sortPropertiesOrder(entries);
         expect(result[0]).toBe("name");

package/test/realtimeService.test.ts

@@ -3,8 +3,12 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 import { EntityCollection } from "@rebasepro/types";
 
-const mockFetchCollection = jest.fn().mockResolvedValue([{ id: 1, path: "posts", values: { title: "Refetched Title" } }]);
-const mockFetchEntity = jest.fn().mockResolvedValue({ id: 1, path: "posts", values: { title: "Refetched Entity Title" } });
+const mockFetchCollection = jest.fn().mockResolvedValue([{ id: 1,
+path: "posts",
+values: { title: "Refetched Title" } }]);
+const mockFetchEntity = jest.fn().mockResolvedValue({ id: 1,
+path: "posts",
+values: { title: "Refetched Entity Title" } });
 
 jest.mock("../src/services/entityService", () => ({
     EntityService: jest.fn().mockImplementation(() => ({

package/test/relation-pipeline-gaps.test.ts

@@ -25,26 +25,32 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 
 // ─── Mock Tables ──────────────────────────────────────────────────────
 const mockPostsTable = {
-    id: { name: "id", dataType: "number" },
+    id: { name: "id",
+dataType: "number" },
     title: { name: "title" },
-    author_id: { name: "author_id", dataType: "number" },
+    author_id: { name: "author_id",
+dataType: "number" },
     _def: { tableName: "posts" }
 };
 
 const mockTagsTable = {
-    id: { name: "id", dataType: "number" },
+    id: { name: "id",
+dataType: "number" },
     name: { name: "name" },
     _def: { tableName: "tags" }
 };
 
 const mockPostsTagsTable = {
-    post_id: { name: "post_id", dataType: "number" },
-    tag_id: { name: "tag_id", dataType: "number" },
+    post_id: { name: "post_id",
+dataType: "number" },
+    tag_id: { name: "tag_id",
+dataType: "number" },
     _def: { tableName: "posts_tags" }
 };
 
 const mockAuthorsTable = {
-    id: { name: "id", dataType: "number" },
+    id: { name: "id",
+dataType: "number" },
     name: { name: "name" },
     _def: { tableName: "authors" }
 };
@@ -69,7 +75,8 @@ const postsCollection: EntityCollection = {
     properties: {
         id: { type: "number" },
         title: { type: "string" },
-        tags: { type: "relation", relationName: "tags" }
+        tags: { type: "relation",
+relationName: "tags" }
     },
     relations: [
         {
@@ -94,7 +101,8 @@ const authorsCollection: EntityCollection = {
     properties: {
         id: { type: "number" },
         name: { type: "string" },
-        posts: { type: "relation", relationName: "posts" }
+        posts: { type: "relation",
+relationName: "posts" }
     },
     relations: [
         {
@@ -116,7 +124,8 @@ const tagsWithInversePosts: EntityCollection = {
     properties: {
         id: { type: "number" },
         name: { type: "string" },
-        posts: { type: "relation", relationName: "posts" }
+        posts: { type: "relation",
+relationName: "posts" }
     },
     relations: [
         {
@@ -142,7 +151,7 @@ function createMockDb(resolveResults: () => unknown[]) {
         innerJoinCount: 0,
         fromTable: undefined as string | undefined,
         deleteCalls: [] as unknown[],
-        insertCalls: [] as unknown[],
+        insertCalls: [] as unknown[]
     };
 
     function makeChainable(): Record<string, unknown> {
@@ -184,7 +193,7 @@ function createMockDb(resolveResults: () => unknown[]) {
 
     return {
         db: makeChainable() as unknown as jest.Mocked<NodePgDatabase>,
-        recorder,
+        recorder
     };
 }
 
@@ -226,8 +235,12 @@ describe("batchFetchRelatedEntities: ID type coercion (single cardinality)", ()
     it("should match results when Drizzle returns string IDs but parsedParentIds are numbers (FK inverse)", async () => {
         // Simulate Drizzle returning author_id as a string even though it's a numeric column
         const resultRows = [
-            { id: 10, title: "Post A", author_id: "1" },
-            { id: 20, title: "Post B", author_id: "2" },
+            { id: 10,
+title: "Post A",
+author_id: "1" },
+            { id: 20,
+title: "Post B",
+author_id: "2" }
         ];
 
         const { db } = createMockDb(() => resultRows);
@@ -250,7 +263,9 @@ describe("batchFetchRelatedEntities: ID type coercion (single cardinality)", ()
     it("should match results when Drizzle returns number IDs but parsedParentIds contain strings", async () => {
         // Simulate the reverse: Drizzle returns numbers, but parsed IDs might be strings
         const resultRows = [
-            { id: 10, title: "Post A", author_id: 1 },
+            { id: 10,
+title: "Post A",
+author_id: 1 }
         ];
 
         const { db } = createMockDb(() => resultRows);
@@ -267,8 +282,12 @@ describe("batchFetchRelatedEntities: ID type coercion (single cardinality)", ()
 
     it("should handle mixed string and number IDs across result rows", async () => {
         const resultRows = [
-            { id: 10, title: "Post A", author_id: 1 },       // number
-            { id: 20, title: "Post B", author_id: "2" },      // string
+            { id: 10,
+title: "Post A",
+author_id: 1 }, // number
+            { id: 20,
+title: "Post B",
+author_id: "2" } // string
         ];
 
         const { db } = createMockDb(() => resultRows);
@@ -285,7 +304,9 @@ describe("batchFetchRelatedEntities: ID type coercion (single cardinality)", ()
 
     it("should not match results for IDs not in the parent set", async () => {
         const resultRows = [
-            { id: 10, title: "Post A", author_id: "999" },
+            { id: 10,
+title: "Post A",
+author_id: "999" }
         ];
 
         const { db } = createMockDb(() => resultRows);
@@ -340,7 +361,9 @@ describe("batchFetchRelatedEntities: ID type coercion (single cardinality)", ()
 
         // Drizzle returns author_id as string
         const resultRows = [
-            { id: 10, title: "Post A", author_id: "1" },
+            { id: 10,
+title: "Post A",
+author_id: "1" }
         ];
 
         const { db } = createMockDb(() => resultRows);
@@ -624,8 +647,12 @@ describe("sanitizeRelation: auto-inferred junction table naming", () => {
             cardinality: "many",
             direction: "owning",
             joinPath: [
-                { table: "user_roles", on: { from: "id", to: "user_id" } },
-                { table: "permissions", on: { from: "permission_id", to: "id" } }
+                { table: "user_roles",
+on: { from: "id",
+to: "user_id" } },
+                { table: "permissions",
+on: { from: "permission_id",
+to: "id" } }
             ]
         };
 
@@ -645,15 +672,18 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
 
     // Mock collections simulating tasks → clients owning relation
     const mockClientsTable = {
-        id: { name: "id", dataType: "string" },
+        id: { name: "id",
+dataType: "string" },
         name: { name: "name" },
         email: { name: "email" },
         _def: { tableName: "clients" }
     };
 
     const mockTasksTable = {
-        id: { name: "id", dataType: "string" },
-        clientId: { name: "client_id", dataType: "string" },
+        id: { name: "id",
+dataType: "string" },
+        clientId: { name: "client_id",
+dataType: "string" },
         title: { name: "title" },
         _def: { tableName: "tasks" }
     };
@@ -663,7 +693,8 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
         name: "Clients",
         table: "clients",
         properties: {
-            id: { type: "string", isId: "uuid" },
+            id: { type: "string",
+isId: "uuid" },
             name: { type: "string" },
             email: { type: "string" }
         }
@@ -674,8 +705,10 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
         name: "Tasks",
         table: "tasks",
         properties: {
-            id: { type: "string", isId: "uuid" },
-            clientId: { type: "string", columnName: "client_id" },
+            id: { type: "string",
+isId: "uuid" },
+            clientId: { type: "string",
+columnName: "client_id" },
             title: { type: "string" },
             client: {
                 type: "relation",
@@ -748,9 +781,12 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
 
         const db = createSequencedMockDb([
             // Query 1: FK lookup from tasks table
-            () => [{ parentId: taskUuid, fkValue: clientUuid }],
+            () => [{ parentId: taskUuid,
+fkValue: clientUuid }],
             // Query 2: Target entity from clients table
-            () => [{ id: clientUuid, name: "Francesco", email: "f@test.com" }]
+            () => [{ id: clientUuid,
+name: "Francesco",
+email: "f@test.com" }]
         ]);
 
         const service = new RelationService(db, registry);
@@ -779,11 +815,15 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
         const db = createSequencedMockDb([
             // Both tasks have the same clientId
             () => [
-                { parentId: task1, fkValue: clientUuid },
-                { parentId: task2, fkValue: clientUuid }
+                { parentId: task1,
+fkValue: clientUuid },
+                { parentId: task2,
+fkValue: clientUuid }
             ],
             // Only one client row
-            () => [{ id: clientUuid, name: "Francesco", email: "f@test.com" }]
+            () => [{ id: clientUuid,
+name: "Francesco",
+email: "f@test.com" }]
         ]);
 
         const service = new RelationService(db, registry);
@@ -803,7 +843,8 @@ describe("batchFetchRelatedEntities: owning direction (FK-based)", () => {
 
         const db = createSequencedMockDb([
             // FK is null
-            () => [{ parentId: task1, fkValue: null }],
+            () => [{ parentId: task1,
+fkValue: null }]
         ]);
 
         const service = new RelationService(db, registry);
@@ -897,7 +938,9 @@ describe("Relation data JSON round-trip", () => {
     });
 
     it("should handle entity with no relation data (stub)", () => {
-        const stubRef = { id: "client-uuid", path: "clients", __type: "relation" as const };
+        const stubRef = { id: "client-uuid",
+path: "clients",
+__type: "relation" as const };
 
         const json = JSON.stringify({ values: { client: stubRef } });
         const parsed = JSON.parse(json, rebaseReviver);
@@ -914,7 +957,8 @@ describe("Relation data JSON round-trip", () => {
         const clientEntity = {
             id: "client-uuid",
             path: "clients",
-            values: { name: "Acme Corp", email: "acme@corp.com" }
+            values: { name: "Acme Corp",
+email: "acme@corp.com" }
         };
 
         const ref = createRelationRefWithData(clientEntity.id, clientEntity.path, clientEntity as any);
@@ -927,12 +971,16 @@ describe("Relation data JSON round-trip", () => {
                 {
                     id: "task-1",
                     path: "tasks",
-                    values: { title: "Task A", client: ref, status: "pending" }
+                    values: { title: "Task A",
+client: ref,
+status: "pending" }
                 },
                 {
                     id: "task-2",
                     path: "tasks",
-                    values: { title: "Task B", client: ref, status: "completed" }
+                    values: { title: "Task B",
+client: ref,
+status: "completed" }
                 }
             ]
         };