import { describe, expect, it, vi } from "vitest"; import { buildLegacyReadableRowsWhere, buildLegacyRowPropertyFiltersWhere, changeLegacyRowOrder, countLegacyRows, createLegacyEntityRowInclude, createLegacyRowDetailsInclude, createLegacyEntityRow, createRowWithValues, deleteLegacyEntityRow, deletedRowInclude, findLegacyRelationshipRowById, hardDeleteRowById, getAllLegacyEntityRows, getLegacyEntityRow, getLegacyRow, getLegacyRowById, getLegacyWorkflowRowForRead, legacyEntityRowInclude, legacyRowDetailsInclude, legacyWorkflowRowGetSelect, listLegacyRows, updateLegacyEntityRow, type LegacyEntityRowCollectionClient, type LegacyRelationshipRowReaderClient, type LegacyRowReadClient, type LegacyWorkflowRowGetClient, type RowMutationClient, updateRowWithValues, } from "./rows.server.js"; import type { LegacyEntityWithDetails, LegacyPropertyWithDetails } from "./entities.server.js"; describe("legacy row read boundary", () => { it("uses redacted API-key creator selects for all row read includes", () => { const serializedInclude = JSON.stringify(legacyEntityRowInclude); expect(legacyEntityRowInclude.createdByApiKey).toEqual({ select: { id: true, alias: true, tenantId: true, keyPrefix: true, keyLastFour: true, }, }); expect(serializedInclude).not.toContain('"key":true'); expect(serializedInclude).not.toContain("keyHash"); expect(serializedInclude).not.toContain("hashedAt"); }); it("counts rows with caller filters wrapped in the non-deleted guard", async () => { const client = createRowReadClient({ count: 7 }); const where = { tenantId: "tenant_1", entityId: "entity_1" }; await expect(countLegacyRows({ where }, client)).resolves.toBe(7); expect(client.row.count).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, where] } }); }); it("lists rows with pagination, ordering, caller filters, and tenant-scoped relationship include", async () => { const rows = [rowDetailsFixture("row_1")]; const client = createRowReadClient({ findMany: rows }); const where = { tenantId: "tenant_1", OR: [{ entityId: "entity_1" }, { entity: { name: "contacts" } }] }; const orderBy = [{ createdAt: "desc" as const }]; await expect(listLegacyRows({ where, take: 25, skip: 50, orderBy, tenantId: "tenant_1" }, client)).resolves.toBe(rows); expect(client.row.findMany).toHaveBeenCalledWith({ take: 25, skip: 50, where: { AND: [{ deletedAt: null }, where] }, include: createLegacyRowDetailsInclude("tenant_1"), orderBy, }); }); it("gets one entity row with caller access filters and tenant-scoped relationship include", async () => { const row = rowDetailsFixture("row_1"); const client = createRowReadClient({ findFirst: row }); const where = { tenantId: "tenant_1", permissions: { some: { userId: "user_1" } } }; await expect(getLegacyRow({ entityId: "entity_1", id: "row_1", where, tenantId: "tenant_1" }, client)).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, { ...where, entityId: "entity_1", id: "row_1" }] }, include: createLegacyRowDetailsInclude("tenant_1"), }); }); it("enforces tenant scope on single row reads when tenant id is provided separately", async () => { const row = rowDetailsFixture("row_1"); const client = createRowReadClient({ findFirst: row }); await expect(getLegacyRow({ entityId: "entity_1", id: "row_1", where: { permissions: { some: { userId: "user_1" } } }, tenantId: "tenant_1" }, client)).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, { permissions: { some: { userId: "user_1" } }, entityId: "entity_1", id: "row_1", tenantId: "tenant_1" }] }, include: createLegacyRowDetailsInclude("tenant_1"), }); }); it("filters nested related row includes by tenant and deletion state", () => { const include = createLegacyRowDetailsInclude("tenant_1"); expect(include.parentRows).toMatchObject({ where: { parent: { tenantId: "tenant_1", deletedAt: null } }, include: { parent: { include: { parentRows: { where: { parent: { tenantId: "tenant_1", deletedAt: null } } }, childRows: { where: { child: { tenantId: "tenant_1", deletedAt: null } } }, }, }, }, }); expect(include.childRows).toMatchObject({ where: { child: { tenantId: "tenant_1", deletedAt: null } }, include: { child: { include: { parentRows: { where: { parent: { tenantId: "tenant_1", deletedAt: null } } }, childRows: { where: { child: { tenantId: "tenant_1", deletedAt: null } } }, }, }, }, }); }); it("gets a row by id with the deleted guard and returns null when missing", async () => { const client = createRowReadClient({ findUnique: null }); await expect(getLegacyRowById("row_missing", client)).resolves.toBeNull(); expect(client.row.findUnique).toHaveBeenCalledWith({ where: { deletedAt: null, id: "row_missing" }, include: legacyRowDetailsInclude }); }); it("gets a row by id within explicit tenant scope", async () => { const row = rowDetailsFixture("row_1"); const client = createRowReadClient({ findFirst: row }); await expect(getLegacyRowById("row_1", client, "tenant_1")).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { id: "row_1", tenantId: "tenant_1", deletedAt: null }, include: createLegacyRowDetailsInclude("tenant_1"), }); expect(client.row.findUnique).not.toHaveBeenCalled(); }); it("builds dynamic property filters for exact matching with AND/OR semantics", () => { expect( buildLegacyRowPropertyFiltersWhere([ { property: { id: "prop_text", type: "TEXT" }, value: "alice", condition: "equals" }, { property: { id: "prop_number", type: "NUMBER" }, value: "42", condition: "equals", match: "or" }, { property: undefined, value: "ignored", condition: "equals" }, ]), ).toEqual({ AND: [{ values: { some: { propertyId: "prop_text", textValue: { equals: "alice" } } } }], OR: [{ values: { some: { propertyId: "prop_number", numberValue: { equals: 42 } } } }], }); }); it("changes row order through the package-owned row transaction boundary", async () => { const row = { ...rowDetailsFixture("row_1"), order: 3 }; const swapRow = { ...rowDetailsFixture("row_2"), order: 4 }; const client = createRowReadClient({ findFirst: [row, swapRow], findMany: [row] }); await expect(changeLegacyRowOrder({ id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, "up", client)).resolves.toBeUndefined(); expect(client.row.findFirst).toHaveBeenNthCalledWith(1, { where: { AND: [{ deletedAt: null }, { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }] }, include: legacyRowDetailsInclude, }); expect(client.row.findFirst).toHaveBeenNthCalledWith(2, { where: { AND: [{ deletedAt: null }, { entityId: row.entityId, tenantId: row.tenantId, order: 4 }] }, include: legacyRowDetailsInclude, }); expect(client.$transaction).toHaveBeenCalledWith([expect.any(Promise), expect.any(Promise)]); expect(client.row.update).toHaveBeenCalledWith({ where: { id: "row_1" }, data: { order: 4 } }); expect(client.row.update).toHaveBeenCalledWith({ where: { id: "row_2" }, data: { order: 3 } }); }); it("rejects row order changes outside the requested tenant and entity scope", async () => { const client = createRowReadClient({ findFirst: null }); await expect(changeLegacyRowOrder({ id: "foreign_row", entityId: "entity_1", tenantId: "tenant_1" }, "up", client)).rejects.toThrow("Row not found"); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, { id: "foreign_row", entityId: "entity_1", tenantId: "tenant_1" }] }, include: legacyRowDetailsInclude, }); expect(client.$transaction).not.toHaveBeenCalled(); }); }); describe("legacy relationship row reads", () => { it("fetches the minimal row shape needed by relationship API routes", async () => { const row = { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }; const client: LegacyRelationshipRowReaderClient = { row: { findFirst: vi.fn().mockResolvedValue(row), }, }; await expect(findLegacyRelationshipRowById({ id: "row_1", tenantId: "tenant_1" }, client)).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, { id: "row_1" }, { tenantId: "tenant_1" }], }, select: { id: true, entityId: true, tenantId: true, }, }); }); it("treats explicit null tenant as a scoped relationship row lookup", async () => { const row = { id: "row_1", entityId: "entity_1", tenantId: null }; const client: LegacyRelationshipRowReaderClient = { row: { findFirst: vi.fn().mockResolvedValue(row), }, }; await expect(findLegacyRelationshipRowById({ id: "row_1", tenantId: null }, client)).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [{ deletedAt: null }, { id: "row_1" }, { tenantId: null }], }, select: { id: true, entityId: true, tenantId: true, }, }); }); }); describe("legacy workflow rowGet reads", () => { it("uses the shared tenant and row-permission read boundary for worker-native rowGet", async () => { const row = workflowRowGetFixture("row_1"); const client = createWorkflowRowGetClient({ findFirst: row, userRoles: [{ roleId: "role_viewer" }], groups: [{ id: "group_ops" }] }); await expect(getLegacyWorkflowRowForRead({ entity: "contact", id: "row_1", tenantId: "tenant_1", userId: "user_1" }, client)).resolves.toBe(row); expect(client.userRole.findMany).toHaveBeenCalledWith({ where: { userId: "user_1", tenantId: "tenant_1" }, select: { roleId: true } }); expect(client.group.findMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", OR: [{ createdByUserId: "user_1" }, { users: { some: { userId: "user_1" } } }] }, select: { id: true }, }); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { AND: [ { deletedAt: null }, { id: "row_1", AND: [ { OR: [{ entityId: "contact" }, { entity: { name: "contact" } }] }, { OR: [{ tenantId: "tenant_1" }, { permissions: { some: { tenantId: "tenant_1" } } }] }, { OR: [ { permissions: { some: { tenantId: "tenant_1", access: { not: "none" } } } }, { createdByUserId: "user_1" }, { permissions: { some: { userId: "user_1", access: { not: "none" } } } }, { permissions: { some: { roleId: "role_viewer", access: { not: "none" } } } }, { permissions: { some: { groupId: "group_ops", access: { not: "none" } } } }, ], }, ], }, ], }, select: legacyWorkflowRowGetSelect, }); }); it("builds a closed readable-row predicate when the caller has no matching role or group grants", async () => { const client = createWorkflowRowGetClient({ findFirst: null, userRoles: [], groups: [] }); await expect(getLegacyWorkflowRowForRead({ entity: "contact", id: "row_blocked", tenantId: "tenant_1", userId: "user_1" }, client)).resolves.toBeNull(); expect(client.row.findFirst).toHaveBeenCalledWith( expect.objectContaining({ where: expect.objectContaining({ AND: [ { deletedAt: null }, expect.objectContaining({ id: "row_blocked", AND: expect.arrayContaining([ { OR: [ { permissions: { some: { tenantId: "tenant_1", access: { not: "none" } } } }, { createdByUserId: "user_1" }, { permissions: { some: { userId: "user_1", access: { not: "none" } } } }, ], }, ]), }), ], }), }) ); }); it("can build readable-row filters for public row reads without a user", async () => { const client = createWorkflowRowGetClient({ findFirst: null }); await expect(buildLegacyReadableRowsWhere({ tenantId: "tenant_1", includePublic: true }, client)).resolves.toEqual({ OR: [{ permissions: { some: { tenantId: "tenant_1", access: { not: "none" } } } }, { permissions: { some: { public: true } } }], }); expect(client.userRole.findMany).not.toHaveBeenCalled(); expect(client.group.findMany).not.toHaveBeenCalled(); }); }); describe("legacy entity row collections", () => { it("counts and reads a tenant-scoped non-deleted page ordered by newest rows", async () => { const items = [rowFixture("row_1")]; const client = createRowCollectionClient({ count: 24, findMany: items }); await expect( getAllLegacyEntityRows({ entityId: "entity_1", tenantId: "tenant_1", page: 2, pageSize: 10 }, client), ).resolves.toEqual({ page: 2, totalPages: 3, totalItems: 24, items }); expect(client.row.count).toHaveBeenCalledWith({ where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1" } }); expect(client.row.findMany).toHaveBeenCalledWith({ where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1" }, orderBy: { createdAt: "desc" }, skip: 10, take: 10, include: createLegacyEntityRowInclude("tenant_1"), }); }); it("maps visible JSON payload fields and computes next folio and order before reloading the row", async () => { const created = rowFixture("row_9"); const client = createRowCollectionClient({ folio: 7, order: 11, create: { id: "row_9" }, findUnique: created }); const entity = entityFixture([ propertyFixture("prop_text", "title"), propertyFixture("prop_number", "amount"), propertyFixture("prop_date", "dueDate"), propertyFixture("prop_boolean", "enabled"), propertyFixture("prop_multiple", "labels"), propertyFixture("prop_range", "budget"), propertyFixture("prop_media", "attachments"), propertyFixture("prop_hidden", "secret", true), ]); const dueDate = new Date("2026-02-03T00:00:00.000Z"); await expect( createLegacyEntityRow( { entity, tenantId: "tenant_1", createdByUserId: "user_1", createdByApiKeyId: "api_key_1", data: { title: "Acme", amount: 42, dueDate, enabled: true, labels: [{ order: 1, value: "vip" }], budget: { numberMin: 10, numberMax: 20 }, attachments: [{ name: "contract.pdf", title: "Contract", type: "application/pdf", file: "uploads/contract.pdf", publicUrl: null }], secret: "ignored", }, }, client, ), ).resolves.toBe(created); expect(client.row.aggregate).toHaveBeenNthCalledWith(1, { where: { tenantId: "tenant_1", entityId: "entity_1" }, _max: { folio: true } }); expect(client.row.aggregate).toHaveBeenNthCalledWith(2, { where: { tenantId: "tenant_1", entityId: "entity_1" }, _max: { order: true } }); expect(client.row.create).toHaveBeenCalledWith({ data: { entityId: "entity_1", tenantId: "tenant_1", createdByUserId: "user_1", createdByApiKeyId: "api_key_1", folio: 8, order: 12, values: { create: [ { propertyId: "prop_text", textValue: "Acme" }, { propertyId: "prop_number", numberValue: 42 }, { propertyId: "prop_date", dateValue: dueDate }, { propertyId: "prop_boolean", booleanValue: true }, { propertyId: "prop_multiple", multiple: { create: [{ order: 1, value: "vip" }] } }, { propertyId: "prop_range", range: { create: { numberMin: 10, numberMax: 20 } } }, { propertyId: "prop_media", media: { create: [{ name: "contract.pdf", title: "Contract", type: "application/pdf", file: "uploads/contract.pdf", publicUrl: null }] }, }, ], }, }, }); expect(client.row.findUnique).toHaveBeenCalledWith({ where: { id: "row_9", deletedAt: null }, include: legacyEntityRowInclude }); }); it("rejects create dynamic values for properties outside the scoped entity", async () => { const client = createRowMutationClient({ propertyCount: 0 }); await expect( createRowWithValues( { entityId: "entity_1", data: { tenantId: "tenant_1", dynamicProperties: [{ propertyId: "foreign_property", textValue: "Acme" }], }, }, client, ), ).rejects.toThrow("Invalid row property."); expect(client.property.count).toHaveBeenCalledWith({ where: { id: { in: ["foreign_property"] }, entityId: "entity_1", OR: [{ tenantId: null }, { tenantId: "tenant_1" }], }, }); expect(client.row.create).not.toHaveBeenCalled(); }); it("rejects invalid array, range, and media payloads before creating malformed values", async () => { const invalidPayloads = [ { labels: [{ order: "1", value: "vip" }] }, { budget: { numberMin: 1, unexpected: 2 } }, { attachments: [{ name: "contract.pdf", type: "application/pdf", file: "uploads/contract.pdf" }] }, ]; for (const data of invalidPayloads) { const client = createRowCollectionClient({ folio: 0, order: 0 }); await expect(createLegacyEntityRow({ entity: entityFixture([propertyFixture("prop", Object.keys(data)[0])]), tenantId: "tenant_1", data }, client)).rejects.toThrow( /Invalid value for property/, ); expect(client.row.create).not.toHaveBeenCalled(); } }); it("throws a stable error when the created row cannot be reloaded", async () => { const client = createRowCollectionClient({ folio: null, order: null, create: { id: "row_missing" }, findUnique: null }); await expect(createLegacyEntityRow({ entity: entityFixture([propertyFixture("prop_text", "title")]), tenantId: null, data: { title: "Acme" } }, client)).rejects.toThrow( "Created row row_missing could not be reloaded", ); expect(client.row.findUnique).toHaveBeenCalledWith({ where: { id: "row_missing", deletedAt: null }, include: legacyEntityRowInclude }); }); it("gets one tenant-scoped non-deleted row with the full legacy include", async () => { const row = rowFixture("row_1"); const client = createRowCollectionClient({ findFirst: row }); await expect(getLegacyEntityRow({ entityId: "entity_1", tenantId: "tenant_1", rowId: "row_1" }, client)).resolves.toBe(row); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1", id: "row_1" }, include: createLegacyEntityRowInclude("tenant_1"), }); }); it("updates only visible submitted values after verifying row scope", async () => { vi.useFakeTimers(); const now = new Date("2026-03-04T05:06:07.000Z"); vi.setSystemTime(now); const updated = rowFixture("row_1"); const client = createRowCollectionClient({ findFirst: [rowFixture("row_1"), updated] }); const entity = entityFixture([propertyFixture("prop_text", "title"), propertyFixture("prop_hidden", "secret", true)]); try { await expect(updateLegacyEntityRow({ entity, tenantId: "tenant_1", rowId: "row_1", data: { title: "Updated", secret: "ignored" } }, client)).resolves.toBe(updated); } finally { vi.useRealTimers(); } expect(client.row.findFirst).toHaveBeenNthCalledWith(1, { where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1", id: "row_1" }, include: createLegacyEntityRowInclude("tenant_1") }); expect(client.rowValue.deleteMany).toHaveBeenCalledWith({ where: { rowId: "row_1", propertyId: { in: ["prop_text"] }, row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null } }, }); expect(client.row.update).toHaveBeenCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, data: { updatedAt: now, values: { create: [{ propertyId: "prop_text", textValue: "Updated" }] } }, }); expect(client.row.findFirst).toHaveBeenNthCalledWith(2, { where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1", id: "row_1" }, include: createLegacyEntityRowInclude("tenant_1") }); }); it("rejects invalid update payloads before deleting or creating values", async () => { const client = createRowCollectionClient({ findFirst: rowFixture("row_1") }); await expect( updateLegacyEntityRow({ entity: entityFixture([propertyFixture("prop_media", "attachments")]), tenantId: "tenant_1", rowId: "row_1", data: { attachments: [{ name: "bad" }] } }, client), ).rejects.toThrow(/Invalid value for property/); expect(client.rowValue.deleteMany).not.toHaveBeenCalled(); expect(client.row.update).not.toHaveBeenCalled(); }); it("throws a stable error when updating a missing row", async () => { const client = createRowCollectionClient({ findFirst: null }); await expect(updateLegacyEntityRow({ entity: entityFixture([propertyFixture("prop_text", "title")]), tenantId: "tenant_1", rowId: "row_missing", data: { title: "Updated" } }, client)).rejects.toThrow( "Row row_missing not found", ); expect(client.rowValue.deleteMany).not.toHaveBeenCalled(); expect(client.row.update).not.toHaveBeenCalled(); }); it("soft-deletes a tenant-scoped non-deleted row", async () => { vi.useFakeTimers(); const now = new Date("2026-04-05T06:07:08.000Z"); vi.setSystemTime(now); const client = createRowCollectionClient({ findFirst: rowFixture("row_1") }); try { await expect(deleteLegacyEntityRow({ entityId: "entity_1", tenantId: "tenant_1", rowId: "row_1" }, client)).resolves.toBe("row_1"); } finally { vi.useRealTimers(); } expect(client.row.findFirst).toHaveBeenCalledWith({ where: { deletedAt: null, entityId: "entity_1", tenantId: "tenant_1", id: "row_1" }, include: createLegacyEntityRowInclude("tenant_1") }); expect(client.row.update).toHaveBeenCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, data: { deletedAt: now } }); }); it("throws a stable error when deleting a missing row", async () => { const client = createRowCollectionClient({ findFirst: null }); await expect(deleteLegacyEntityRow({ entityId: "entity_1", tenantId: "tenant_1", rowId: "row_missing" }, client)).rejects.toThrow("Row row_missing not found"); expect(client.row.update).not.toHaveBeenCalled(); }); }); describe("row mutation boundary", () => { it("creates rows with dynamic values, relationships, explicit row input, and computed folio/order", async () => { const client = createRowMutationClient({ folio: 4, order: 8, create: { id: "row_9" } }); const dueDate = new Date("2026-02-03T00:00:00.000Z"); await expect( createRowWithValues( { entityId: "entity_1", data: { tenantId: "tenant_1", createdByUserId: "user_1", createdByApiKeyId: "api_key_1", properties: { sampleCustomEntity: { create: { name: "custom" } } }, dynamicProperties: [ { propertyId: "prop_text", textValue: "Acme" }, { propertyId: "prop_number", numberValue: 42 }, { propertyId: "prop_date", dateValue: dueDate }, { propertyId: "prop_boolean", booleanValue: true }, { propertyId: "prop_media", media: [{ name: "contract.pdf", title: "Contract", type: "application/pdf", file: "uploads/contract.pdf", publicUrl: null }] }, { propertyId: "prop_multiple", multiple: [{ order: 1, value: "vip" }] }, { propertyId: "prop_range", range: { numberMin: 10, numberMax: 20 } }, ], parentRows: [{ relationshipId: "rel_parent", parentId: "parent_1" }], childRows: [{ relationshipId: "rel_child", childId: "child_1" }], rowCreateInput: { createdByUserId: "row_input_user" }, }, }, client, ), ).resolves.toEqual({ id: "row_9" }); expect(client.row.aggregate).toHaveBeenNthCalledWith(1, { where: { tenantId: "tenant_1", entityId: "entity_1" }, _max: { folio: true } }); expect(client.row.aggregate).toHaveBeenNthCalledWith(2, { where: { tenantId: "tenant_1", entityId: "entity_1" }, _max: { order: true } }); expect(client.property.count).toHaveBeenCalledWith({ where: { id: { in: ["prop_text", "prop_number", "prop_date", "prop_boolean", "prop_media", "prop_multiple", "prop_range"] }, entityId: "entity_1", OR: [{ tenantId: null }, { tenantId: "tenant_1" }], }, }); expect(client.row.create).toHaveBeenCalledWith({ data: { folio: 5, order: 9, entityId: "entity_1", tenantId: "tenant_1", createdByUserId: "row_input_user", createdByApiKeyId: "api_key_1", sampleCustomEntity: { create: { name: "custom" } }, values: { create: [ { propertyId: "prop_text", textValue: "Acme", numberValue: undefined, dateValue: undefined, booleanValue: undefined }, { propertyId: "prop_number", textValue: undefined, numberValue: 42, dateValue: undefined, booleanValue: undefined }, { propertyId: "prop_date", textValue: undefined, numberValue: undefined, dateValue: dueDate, booleanValue: undefined }, { propertyId: "prop_boolean", textValue: undefined, numberValue: undefined, dateValue: undefined, booleanValue: true }, { propertyId: "prop_media", textValue: undefined, numberValue: undefined, dateValue: undefined, booleanValue: undefined, media: { create: [{ name: "contract.pdf", title: "Contract", type: "application/pdf", file: "uploads/contract.pdf", publicUrl: null }] } }, { propertyId: "prop_multiple", textValue: undefined, numberValue: undefined, dateValue: undefined, booleanValue: undefined, multiple: { create: [{ order: 1, value: "vip" }] } }, { propertyId: "prop_range", textValue: undefined, numberValue: undefined, dateValue: undefined, booleanValue: undefined, range: { create: { numberMin: 10, numberMax: 20, dateMin: undefined, dateMax: undefined } } }, ], }, parentRows: { create: [{ relationshipId: "rel_parent", parentId: "parent_1" }] }, childRows: { create: [{ relationshipId: "rel_child", childId: "child_1" }] }, }, }); expect(client.entityRelationship.findMany).toHaveBeenCalledWith({ where: { id: { in: ["rel_parent", "rel_child"] } }, select: { id: true, parentId: true, childId: true }, }); expect(client.entityRelationship.findUnique).not.toHaveBeenCalled(); expect(client.row.findMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", deletedAt: null, OR: [ { id: "parent_1", entityId: "parent_entity" }, { id: "child_1", entityId: "child_entity" }, ], }, select: { id: true, entityId: true, tenantId: true }, }); }); it("rejects create relationships that point outside the current tenant or entity", async () => { const client = createRowMutationClient({ findFirst: null }); await expect( createRowWithValues( { entityId: "entity_1", data: { tenantId: "tenant_1", dynamicProperties: [], parentRows: [{ relationshipId: "rel_parent", parentId: "foreign_parent" }], }, }, client, ), ).rejects.toThrow("Related row not found."); expect(client.row.findMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", deletedAt: null, OR: [{ id: "foreign_parent", entityId: "parent_entity" }] }, select: { id: true, entityId: true, tenantId: true }, }); expect(client.row.create).not.toHaveBeenCalled(); }); it("rejects create relationships that do not belong to the current entity side", async () => { const client = createRowMutationClient({ entityRelationships: { rel_parent: { id: "rel_parent", parentId: "parent_entity", childId: "other_entity" }, }, }); await expect( createRowWithValues( { entityId: "entity_1", data: { tenantId: "tenant_1", dynamicProperties: [], parentRows: [{ relationshipId: "rel_parent", parentId: "parent_1" }], }, }, client, ), ).rejects.toThrow("Invalid row relationship."); expect(client.row.create).not.toHaveBeenCalled(); }); it("uses explicit folio and order without aggregate queries", async () => { const client = createRowMutationClient({ create: { id: "row_10" } }); await createRowWithValues({ entityId: "entity_1", nextFolio: 20, nextOrder: 30, data: { tenantId: null, dynamicProperties: [] } }, client); expect(client.row.aggregate).not.toHaveBeenCalled(); expect(client.row.create).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ folio: 20, order: 30 }) })); }); it("replaces update relationships and dynamic value children before reloading", async () => { const updated = rowDetailsFixture("row_1"); const client = createRowMutationClient({ findFirst: [rowFixture("row_1"), updated], }); await expect( updateRowWithValues( { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, { properties: { order: 12 }, dynamicProperties: [{ id: "value_1", propertyId: "prop_text", textValue: "Updated" }, { propertyId: "prop_new", numberValue: 10 }], parentRows: [{ relationshipId: "rel_parent", parentId: "parent_1" }], childRows: [{ relationshipId: "rel_child", childId: "child_1" }], rowUpdateInput: { folio: 44 }, }, client, ), ).resolves.toBe(updated); expect(client.rowRelationship.deleteMany).toHaveBeenNthCalledWith(1, { where: { childId: "row_1", child: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, parent: { tenantId: "tenant_1", deletedAt: null }, }, }); expect(client.rowRelationship.deleteMany).toHaveBeenNthCalledWith(2, { where: { parentId: "row_1", parent: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, child: { tenantId: "tenant_1", deletedAt: null }, }, }); expect(client.rowMedia.deleteMany).toHaveBeenCalledWith({ where: { rowValue: { rowId: "row_1", propertyId: { in: ["prop_text", "prop_new"] }, row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null } } } }); expect(client.rowValueMultiple.deleteMany).toHaveBeenCalledWith({ where: { rowValue: { rowId: "row_1", propertyId: { in: ["prop_text", "prop_new"] }, row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null } } } }); expect(client.rowValueRange.deleteMany).toHaveBeenCalledWith({ where: { rowValue: { rowId: "row_1", propertyId: { in: ["prop_text", "prop_new"] }, row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null } } } }); expect(client.rowValue.count).toHaveBeenCalledWith({ where: { id: { in: ["value_1"] }, rowId: "row_1", row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, }, }); expect(client.property.count).toHaveBeenCalledWith({ where: { id: { in: ["prop_text", "prop_new"] }, entityId: "entity_1", OR: [{ tenantId: null }, { tenantId: "tenant_1" }], }, }); expect(client.row.update).toHaveBeenCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, data: expect.objectContaining({ order: 12, folio: 44, parentRows: { create: [{ relationshipId: "rel_parent", parentId: "parent_1" }] }, childRows: { create: [{ relationshipId: "rel_child", childId: "child_1" }] }, }), }); expect(client.row.findFirst).toHaveBeenLastCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, include: createLegacyRowDetailsInclude("tenant_1"), }); }); it("rejects update dynamic values for properties outside the scoped entity", async () => { const client = createRowMutationClient({ findFirst: rowFixture("row_1"), propertyCount: 0 }); await expect( updateRowWithValues( { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, { dynamicProperties: [{ propertyId: "foreign_property", textValue: "Updated" }], }, client, ), ).rejects.toThrow("Invalid row property."); expect(client.property.count).toHaveBeenCalledWith({ where: { id: { in: ["foreign_property"] }, entityId: "entity_1", OR: [{ tenantId: null }, { tenantId: "tenant_1" }], }, }); expect(client.rowValue.count).not.toHaveBeenCalled(); expect(client.row.update).not.toHaveBeenCalled(); }); it("rejects update relationships before deleting existing links when related rows are out of scope", async () => { const client = createRowMutationClient({ findFirst: [rowFixture("row_1"), null] }); await expect( updateRowWithValues( { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, { dynamicProperties: [], childRows: [{ relationshipId: "rel_child", childId: "foreign_child" }], }, client, ), ).rejects.toThrow("Related row not found."); expect(client.row.findFirst).toHaveBeenNthCalledWith(1, { where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, select: { id: true, entityId: true, tenantId: true }, }); expect(client.row.findMany).toHaveBeenCalledWith({ where: { tenantId: "tenant_1", deletedAt: null, OR: [{ id: "foreign_child", entityId: "child_entity" }] }, select: { id: true, entityId: true, tenantId: true }, }); expect(client.rowRelationship.deleteMany).not.toHaveBeenCalled(); expect(client.row.update).not.toHaveBeenCalled(); }); it("rejects nested row value updates that are not owned by the scoped row", async () => { const client = createRowMutationClient({ findFirst: rowFixture("row_1"), rowValueCount: 0 }); await expect( updateRowWithValues( { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, { dynamicProperties: [{ id: "foreign_value", propertyId: "prop_text", textValue: "Updated" }], }, client, ), ).rejects.toThrow("Row value not found."); expect(client.rowValue.count).toHaveBeenCalledWith({ where: { id: { in: ["foreign_value"] }, rowId: "row_1", row: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, }, }); expect(client.rowMedia.deleteMany).not.toHaveBeenCalled(); expect(client.rowValueMultiple.deleteMany).not.toHaveBeenCalled(); expect(client.rowValueRange.deleteMany).not.toHaveBeenCalled(); expect(client.row.update).not.toHaveBeenCalled(); }); it("throws a stable error when an updated row cannot be reloaded", async () => { const client = createRowMutationClient({ findFirst: [rowFixture("row_missing"), null] }); await expect(updateRowWithValues({ id: "row_missing", entityId: "entity_1", tenantId: "tenant_1" }, { dynamicProperties: [] }, client)).rejects.toThrow("Updated row row_missing could not be reloaded"); }); it("runs relationship replacement and row updates inside one transaction", async () => { const updateError = new Error("write failed"); const client = createRowMutationClient({ findFirst: [rowFixture("row_1"), { ...rowFixture("child_1"), entityId: "child_entity" }], updateError }); await expect( updateRowWithValues( { id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, { dynamicProperties: [], childRows: [{ relationshipId: "rel_child", childId: "child_1" }], }, client, ), ).rejects.toThrow(updateError); expect(client.$transaction).toHaveBeenCalledTimes(1); expect(client.rowRelationship.deleteMany).toHaveBeenCalledWith({ where: { parentId: "row_1", parent: { entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, child: { tenantId: "tenant_1", deletedAt: null }, }, }); }); it("hard deletes rows with the legacy include shape", async () => { const deleted = { ...rowFixture("row_1"), logs: [], values: [] }; const client = createRowMutationClient({ findFirst: deleted }); await expect(hardDeleteRowById({ id: "row_1", entityId: "entity_1", tenantId: "tenant_1" }, client)).resolves.toBe(deleted); expect(client.row.findFirst).toHaveBeenCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null }, include: deletedRowInclude }); expect(client.row.deleteMany).toHaveBeenCalledWith({ where: { id: "row_1", entityId: "entity_1", tenantId: "tenant_1", deletedAt: null } }); }); }); function createRowReadClient({ count = 0, findMany = [], findFirst = null, findUnique = null, }: { count?: number; findMany?: unknown[]; findFirst?: unknown | unknown[]; findUnique?: unknown; } = {}): LegacyRowReadClient { const findFirstMock = vi.fn(); if (Array.isArray(findFirst)) { for (const value of findFirst) { findFirstMock.mockResolvedValueOnce(value); } } else { findFirstMock.mockResolvedValue(findFirst); } const client = { row: { count: vi.fn().mockResolvedValue(count), findMany: vi.fn().mockResolvedValue(findMany), findFirst: findFirstMock, findUnique: vi.fn().mockResolvedValue(findUnique), update: vi.fn((args: { where: { id: string } }) => Promise.resolve({ id: `updated_${args.where.id}` })), }, $transaction: vi.fn((queries: Promise[]) => Promise.all(queries)), } as unknown as LegacyRowReadClient; return client; } function createRowMutationClient({ folio = null, order = null, create = { id: "created_row" }, findFirst = rowFixture("row_1"), findUnique = null, deleteResult = { ...rowFixture("deleted_row"), logs: [], values: [] }, entityRelationships = { rel_parent: { id: "rel_parent", parentId: "parent_entity", childId: "entity_1" }, rel_child: { id: "rel_child", parentId: "entity_1", childId: "child_entity" }, }, propertyCount, rowValueCount, updateError, relatedRows, }: { folio?: number | null; order?: number | null; create?: { id: string }; findFirst?: unknown | unknown[]; findUnique?: unknown; deleteResult?: unknown; entityRelationships?: Record; propertyCount?: number; rowValueCount?: number; updateError?: Error; relatedRows?: Array<{ id: string; entityId: string; tenantId: string | null }> | null; } = {}): RowMutationClient { const findFirstMock = vi.fn(); if (Array.isArray(findFirst)) { for (const value of findFirst) { findFirstMock.mockResolvedValueOnce(value); } } else { findFirstMock.mockResolvedValue(findFirst); } const resolveRelatedRows = (where: { OR?: Array<{ id: string; entityId: string }>; tenantId?: string | null }) => { if (relatedRows !== undefined) { return relatedRows; } if (findFirst === null || (Array.isArray(findFirst) && findFirst.some((value) => value === null))) { return []; } return (where.OR ?? []).map(({ id, entityId }) => ({ id, entityId, tenantId: where.tenantId ?? null, })); }; const client = { row: { aggregate: vi.fn().mockResolvedValueOnce({ _max: { folio } }).mockResolvedValueOnce({ _max: { order } }), create: vi.fn().mockResolvedValue(create), findFirst: findFirstMock, findMany: vi.fn(({ where }: { where: { OR?: Array<{ id: string; entityId: string }>; tenantId?: string | null } }) => Promise.resolve(resolveRelatedRows(where))), findUnique: vi.fn().mockResolvedValue(findUnique), update: updateError ? vi.fn().mockRejectedValue(updateError) : vi.fn().mockResolvedValue({ id: "updated_row" }), deleteMany: vi.fn().mockResolvedValue({ count: 1 }), delete: vi.fn().mockResolvedValue(deleteResult), }, entityRelationship: { findMany: vi.fn(({ where }: { where: { id: { in: string[] } } }) => Promise.resolve(where.id.in.map((id) => entityRelationships[id]).filter(Boolean))), findUnique: vi.fn(({ where }: { where: { id: string } }) => Promise.resolve(entityRelationships[where.id] ?? null)), }, rowRelationship: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }), }, rowMedia: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }), }, rowValue: { count: vi.fn(({ where }: { where: { id?: { in?: unknown[] } } }) => Promise.resolve(rowValueCount ?? where.id?.in?.length ?? 0)), }, property: { count: vi.fn(({ where }: { where: { id?: { in?: unknown[] } } }) => Promise.resolve(propertyCount ?? where.id?.in?.length ?? 0)), }, rowValueMultiple: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }), }, rowValueRange: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }), }, $transaction: vi.fn((fn: (tx: RowMutationClient) => Promise) => fn(client as unknown as RowMutationClient)), } as unknown as RowMutationClient; return client; } function createRowCollectionClient({ count = 0, findMany = [], folio = null, order = null, create = { id: "created_row" }, findFirst = null, findUnique = null, }: { count?: number; findMany?: unknown[]; folio?: number | null; order?: number | null; create?: { id: string }; findFirst?: unknown | unknown[]; findUnique?: unknown; } = {}): LegacyEntityRowCollectionClient { const findFirstMock = vi.fn(); if (Array.isArray(findFirst)) { for (const value of findFirst) { findFirstMock.mockResolvedValueOnce(value); } } else { findFirstMock.mockResolvedValue(findFirst); } return { row: { count: vi.fn().mockResolvedValue(count), findMany: vi.fn().mockResolvedValue(findMany), aggregate: vi.fn().mockResolvedValueOnce({ _max: { folio } }).mockResolvedValueOnce({ _max: { order } }), create: vi.fn().mockResolvedValue(create), findFirst: findFirstMock, findUnique: vi.fn().mockResolvedValue(findUnique), update: vi.fn().mockResolvedValue({ id: "updated_row" }), }, rowValue: { deleteMany: vi.fn().mockResolvedValue({ count: 0 }), }, } as unknown as LegacyEntityRowCollectionClient; } function rowFixture(id: string) { const now = new Date("2026-01-01T00:00:00.000Z"); return { id, createdAt: now, updatedAt: now, deletedAt: null, entityId: "entity_1", tenantId: "tenant_1", folio: 1, createdByUserId: null, createdByApiKeyId: null, order: 1, createdByUser: null, createdByApiKey: null, values: [], parentRows: [], childRows: [], }; } function rowDetailsFixture(id: string) { return { ...rowFixture(id), tenant: null, tags: [], permissions: [], sampleCustomEntity: null, }; } function workflowRowGetFixture(id: string) { return { id, entityId: "entity_contact", tenantId: "tenant_1", folio: 1, order: 1, createdAt: new Date("2026-05-26T01:02:03.000Z"), updatedAt: new Date("2026-05-26T02:03:04.000Z"), values: [], }; } function createWorkflowRowGetClient({ findFirst, userRoles = [], groups = [], }: { findFirst: Awaited>; userRoles?: Array<{ roleId: string }>; groups?: Array<{ id: string }>; }): LegacyWorkflowRowGetClient { return { row: { findFirst: vi.fn().mockResolvedValue(findFirst), }, userRole: { findMany: vi.fn().mockResolvedValue(userRoles), }, group: { findMany: vi.fn().mockResolvedValue(groups), }, }; } function entityFixture(properties: LegacyPropertyWithDetails[]): LegacyEntityWithDetails { return { id: "entity_1", properties, } as LegacyEntityWithDetails; } function propertyFixture(id: string, name: string, isHidden = false): LegacyPropertyWithDetails { return { id, name, isHidden, attributes: [], options: [], formula: null, } as unknown as LegacyPropertyWithDetails; }