@jskit-ai/workspaces-core 0.1.163 → 0.1.165

package/test/workspaceMembershipsRepository.test.js

@@ -3,18 +3,6 @@ import test from "node:test";
 import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
 
-function createKnexStub() {
-  const knex = Object.assign(() => {
-    throw new Error("query execution not expected");
-  }, {
-    async transaction(work) {
-      return work({ trxId: "trx-1" });
-    }
-  });
-
-  return knex;
-}
-
 function asCollectionDocument(rows = []) {
   return {
     data: Array.isArray(rows) ? rows : []
@@ -55,7 +43,8 @@ function createWorkspaceMembershipsApiStub({
   const api = {
     resources: {
       workspaceMemberships: {
-        async query({ queryParams }) {
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
           state.queryCalls.push(queryParams || {});
           const filters = queryParams?.filters || {};
           const includeUser = Array.isArray(queryParams?.include) && queryParams.include.includes("user");
@@ -100,14 +89,18 @@ function createWorkspaceMembershipsApiStub({
           return asCollectionDocument([]);
         },
         async post(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          state.postPayload = inputRecord;
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.postPayload = payload;
           const row = rowById.get("1") || {
             id: "1",
-            workspace: { id: String(inputRecord.relationships?.workspace?.data?.id || "") },
-            user: { id: String(inputRecord.relationships?.user?.data?.id || "") },
-            roleSid: String(inputRecord.attributes?.roleSid || ""),
-            status: String(inputRecord.attributes?.status || ""),
+            workspace: { id: String(data.workspace || "") },
+            user: { id: String(data.user || "") },
+            roleSid: String(data.roleSid || ""),
+            status: String(data.status || ""),
             createdAt: "2026-03-09 00:26:35.710",
             updatedAt: "2026-03-09 00:26:35.710"
           };
@@ -116,13 +109,17 @@ function createWorkspaceMembershipsApiStub({
           return toWorkspaceMembershipRow(row);
         },
         async patch(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          state.patchPayload = inputRecord;
-          const existing = rowById.get(String(inputRecord.id));
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.patchPayload = payload;
+          const existing = rowById.get(String(payload.id));
           const updated = {
             ...(existing || {}),
-            ...(inputRecord.attributes || {}),
-            id: String(inputRecord.id),
+            ...data,
+            id: String(payload.id),
             workspace: existing?.workspace || { id: "" },
             user: existing?.user || { id: "" }
           };
@@ -150,7 +147,7 @@ test("workspaceMembershipsRepository.findByWorkspaceIdAndUserId normalizes canon
   const { api } = createWorkspaceMembershipsApiStub({
     rowByComposite: new Map([["7:9", membershipRow]])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const membership = await repository.findByWorkspaceIdAndUserId("7", "9");
 
@@ -185,13 +182,13 @@ test("workspaceMembershipsRepository.ensureOwnerMembership upgrades an existing
     rowById: new Map([["11", refreshedRow]]),
     rowByComposite: new Map([["7:9", existingRow]])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const membership = await repository.ensureOwnerMembership("7", "9");
 
-  assert.equal(state.patchPayload.attributes?.roleSid, "owner");
-  assert.equal(state.patchPayload.attributes?.status, "active");
-  assert.equal(typeof state.patchPayload.attributes?.updatedAt, "string");
+  assert.equal(state.patchPayload.data.roleSid, "owner");
+  assert.equal(state.patchPayload.data.status, "active");
+  assert.equal(typeof state.patchPayload.data.updatedAt, "string");
   assert.deepEqual(membership, {
     id: "11",
     workspaceId: "7",
@@ -199,7 +196,7 @@ test("workspaceMembershipsRepository.ensureOwnerMembership upgrades an existing
     roleSid: "owner",
     status: "active",
     createdAt: toIsoString("2026-03-09 00:26:35.710"),
-    updatedAt: toIsoString(state.patchPayload.attributes.updatedAt)
+    updatedAt: toIsoString(state.patchPayload.data.updatedAt)
   });
 });
 
@@ -217,17 +214,17 @@ test("workspaceMembershipsRepository.upsertMembership creates normalized members
     rowById: new Map([["1", createdRow]]),
     rowByComposite: new Map()
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   await repository.upsertMembership("7", "9", {
     roleSid: "ADMIN",
     status: "ACTIVE"
   });
 
-  assert.equal(state.postPayload.relationships?.workspace?.data?.id, "7");
-  assert.equal(state.postPayload.relationships?.user?.data?.id, "9");
-  assert.equal(state.postPayload.attributes?.roleSid, "admin");
-  assert.equal(state.postPayload.attributes?.status, "active");
+  assert.equal(state.postPayload.data.workspace, "7");
+  assert.equal(state.postPayload.data.user, "9");
+  assert.equal(state.postPayload.data.roleSid, "admin");
+  assert.equal(state.postPayload.data.status, "active");
 });
 
 test("workspaceMembershipsRepository.listActiveByWorkspaceId keeps summary rows separate from the canonical membership resource", async () => {
@@ -244,7 +241,7 @@ test("workspaceMembershipsRepository.listActiveByWorkspaceId keeps summary rows
       }
     ]
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const members = await repository.listActiveByWorkspaceId("7");
 
@@ -272,7 +269,7 @@ test("workspaceMembershipsRepository.listActiveWorkspaceIdsByUserId returns norm
   const { api, state } = createWorkspaceMembershipsApiStub({
     rowByComposite: new Map([["7:9", membershipRow]])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const workspaceIds = await repository.listActiveWorkspaceIdsByUserId("9");
 

package/test/workspaceSettingsRepository.test.js

@@ -4,18 +4,6 @@ import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
 import { createRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
 
-function createKnexStub() {
-  const knex = Object.assign(() => {
-    throw new Error("query execution not expected");
-  }, {
-    async transaction(work) {
-      return work({ trxId: "trx-1" });
-    }
-  });
-
-  return knex;
-}
-
 function normalizeWorkspaceColor(value) {
   return typeof value === "string" ? value.toUpperCase() : value;
 }
@@ -54,7 +42,8 @@ function createWorkspaceSettingsApiStub(rowOverrides = {}) {
   const api = {
     resources: {
       workspaceSettings: {
-        async query({ queryParams }) {
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
           const id = String(queryParams?.filters?.id || "");
           if (!state.row || (id && String(state.row.id) !== id)) {
             return asCollectionDocument([]);
@@ -66,20 +55,23 @@ function createWorkspaceSettingsApiStub(rowOverrides = {}) {
           }]);
         },
         async post(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          const attributes = inputRecord.attributes || {};
-          state.postPayload = inputRecord;
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.postPayload = payload;
           state.row = {
-            id: String(inputRecord.id),
-            lightPrimaryColor: normalizeWorkspaceColor(attributes.lightPrimaryColor ?? DEFAULT_WORKSPACE_THEME.light.color),
-            lightSecondaryColor: normalizeWorkspaceColor(attributes.lightSecondaryColor ?? DEFAULT_WORKSPACE_THEME.light.secondaryColor),
-            lightSurfaceColor: normalizeWorkspaceColor(attributes.lightSurfaceColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceColor),
-            lightSurfaceVariantColor: normalizeWorkspaceColor(attributes.lightSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor),
-            darkPrimaryColor: normalizeWorkspaceColor(attributes.darkPrimaryColor ?? DEFAULT_WORKSPACE_THEME.dark.color),
-            darkSecondaryColor: normalizeWorkspaceColor(attributes.darkSecondaryColor ?? DEFAULT_WORKSPACE_THEME.dark.secondaryColor),
-            darkSurfaceColor: normalizeWorkspaceColor(attributes.darkSurfaceColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceColor),
-            darkSurfaceVariantColor: normalizeWorkspaceColor(attributes.darkSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor),
-            invitesEnabled: attributes.invitesEnabled ?? true,
+            id: String(data.id),
+            lightPrimaryColor: normalizeWorkspaceColor(data.lightPrimaryColor ?? DEFAULT_WORKSPACE_THEME.light.color),
+            lightSecondaryColor: normalizeWorkspaceColor(data.lightSecondaryColor ?? DEFAULT_WORKSPACE_THEME.light.secondaryColor),
+            lightSurfaceColor: normalizeWorkspaceColor(data.lightSurfaceColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceColor),
+            lightSurfaceVariantColor: normalizeWorkspaceColor(data.lightSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor),
+            darkPrimaryColor: normalizeWorkspaceColor(data.darkPrimaryColor ?? DEFAULT_WORKSPACE_THEME.dark.color),
+            darkSecondaryColor: normalizeWorkspaceColor(data.darkSecondaryColor ?? DEFAULT_WORKSPACE_THEME.dark.secondaryColor),
+            darkSurfaceColor: normalizeWorkspaceColor(data.darkSurfaceColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceColor),
+            darkSurfaceVariantColor: normalizeWorkspaceColor(data.darkSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor),
+            invitesEnabled: data.invitesEnabled ?? true,
             createdAt: toIsoString("2026-03-10 00:00:00.000"),
             updatedAt: toIsoString("2026-03-10 00:00:00.000")
           };
@@ -89,21 +81,24 @@ function createWorkspaceSettingsApiStub(rowOverrides = {}) {
           };
         },
         async patch(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          const attributes = inputRecord.attributes || {};
-          state.patchPayload = inputRecord;
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.patchPayload = payload;
           state.row = {
             ...state.row,
-            ...attributes,
-            ...(Object.hasOwn(attributes, "lightPrimaryColor") ? { lightPrimaryColor: normalizeWorkspaceColor(attributes.lightPrimaryColor) } : {}),
-            ...(Object.hasOwn(attributes, "lightSecondaryColor") ? { lightSecondaryColor: normalizeWorkspaceColor(attributes.lightSecondaryColor) } : {}),
-            ...(Object.hasOwn(attributes, "lightSurfaceColor") ? { lightSurfaceColor: normalizeWorkspaceColor(attributes.lightSurfaceColor) } : {}),
-            ...(Object.hasOwn(attributes, "lightSurfaceVariantColor") ? { lightSurfaceVariantColor: normalizeWorkspaceColor(attributes.lightSurfaceVariantColor) } : {}),
-            ...(Object.hasOwn(attributes, "darkPrimaryColor") ? { darkPrimaryColor: normalizeWorkspaceColor(attributes.darkPrimaryColor) } : {}),
-            ...(Object.hasOwn(attributes, "darkSecondaryColor") ? { darkSecondaryColor: normalizeWorkspaceColor(attributes.darkSecondaryColor) } : {}),
-            ...(Object.hasOwn(attributes, "darkSurfaceColor") ? { darkSurfaceColor: normalizeWorkspaceColor(attributes.darkSurfaceColor) } : {}),
-            ...(Object.hasOwn(attributes, "darkSurfaceVariantColor") ? { darkSurfaceVariantColor: normalizeWorkspaceColor(attributes.darkSurfaceVariantColor) } : {}),
-            id: String(inputRecord.id || state.row?.id || "")
+            ...data,
+            ...(Object.hasOwn(data, "lightPrimaryColor") ? { lightPrimaryColor: normalizeWorkspaceColor(data.lightPrimaryColor) } : {}),
+            ...(Object.hasOwn(data, "lightSecondaryColor") ? { lightSecondaryColor: normalizeWorkspaceColor(data.lightSecondaryColor) } : {}),
+            ...(Object.hasOwn(data, "lightSurfaceColor") ? { lightSurfaceColor: normalizeWorkspaceColor(data.lightSurfaceColor) } : {}),
+            ...(Object.hasOwn(data, "lightSurfaceVariantColor") ? { lightSurfaceVariantColor: normalizeWorkspaceColor(data.lightSurfaceVariantColor) } : {}),
+            ...(Object.hasOwn(data, "darkPrimaryColor") ? { darkPrimaryColor: normalizeWorkspaceColor(data.darkPrimaryColor) } : {}),
+            ...(Object.hasOwn(data, "darkSecondaryColor") ? { darkSecondaryColor: normalizeWorkspaceColor(data.darkSecondaryColor) } : {}),
+            ...(Object.hasOwn(data, "darkSurfaceColor") ? { darkSurfaceColor: normalizeWorkspaceColor(data.darkSurfaceColor) } : {}),
+            ...(Object.hasOwn(data, "darkSurfaceVariantColor") ? { darkSurfaceVariantColor: normalizeWorkspaceColor(data.darkSurfaceVariantColor) } : {}),
+            id: String(payload.id || state.row?.id || "")
           };
           return {
             ...state.row,
@@ -120,8 +115,7 @@ function createWorkspaceSettingsApiStub(rowOverrides = {}) {
 test("workspaceSettingsRepository.findByWorkspaceId returns the canonical workspace-settings row", async () => {
   const { api, DEFAULT_WORKSPACE_THEME, STUB_CREATED_AT } = createWorkspaceSettingsApiStub();
   const repository = createRepository({
-    api,
-    knex: createKnexStub()
+    api
   });
 
   const record = await repository.findByWorkspaceId("1");
@@ -145,15 +139,14 @@ test("workspaceSettingsRepository.findByWorkspaceId returns the canonical worksp
 test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates invitesEnabled only", async () => {
   const { api, state } = createWorkspaceSettingsApiStub();
   const repository = createRepository({
-    api,
-    knex: createKnexStub()
+    api
   });
 
   const updated = await repository.updateSettingsByWorkspaceId("1", {
     invitesEnabled: false
   });
 
-  assert.equal(state.patchPayload.attributes?.invitesEnabled, false);
+  assert.equal(state.patchPayload.data.invitesEnabled, false);
   assert.equal(updated.invitesEnabled, false);
 });
 
@@ -161,22 +154,21 @@ test("workspaceSettingsRepository.ensureForWorkspaceId delegates defaults to the
   const { api, state, DEFAULT_WORKSPACE_THEME } = createWorkspaceSettingsApiStub();
   state.row = null;
   const repository = createRepository({
-    api,
-    knex: createKnexStub()
+    api
   });
 
   const record = await repository.ensureForWorkspaceId("5");
 
-  assert.equal(state.postPayload.id, "5");
-  assert.equal(state.postPayload.attributes?.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
-  assert.equal(state.postPayload.attributes?.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
-  assert.equal(state.postPayload.attributes?.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
-  assert.equal(state.postPayload.attributes?.lightSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor);
-  assert.equal(state.postPayload.attributes?.darkPrimaryColor, DEFAULT_WORKSPACE_THEME.dark.color);
-  assert.equal(state.postPayload.attributes?.darkSecondaryColor, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
-  assert.equal(state.postPayload.attributes?.darkSurfaceColor, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
-  assert.equal(state.postPayload.attributes?.darkSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor);
-  assert.equal(state.postPayload.attributes?.invitesEnabled, true);
+  assert.equal(state.postPayload.data.id, "5");
+  assert.equal(state.postPayload.data.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(state.postPayload.data.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(state.postPayload.data.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(state.postPayload.data.lightSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor);
+  assert.equal(state.postPayload.data.darkPrimaryColor, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(state.postPayload.data.darkSecondaryColor, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(state.postPayload.data.darkSurfaceColor, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(state.postPayload.data.darkSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor);
+  assert.equal(state.postPayload.data.invitesEnabled, true);
   assert.equal(record.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
   assert.equal(record.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
   assert.equal(record.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
@@ -192,15 +184,14 @@ test("workspaceSettingsRepository.ensureForWorkspaceId delegates defaults to the
 test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates workspace settings fields", async () => {
   const { api, state } = createWorkspaceSettingsApiStub();
   const repository = createRepository({
-    api,
-    knex: createKnexStub()
+    api
   });
 
   const updated = await repository.updateSettingsByWorkspaceId("1", {
     lightPrimaryColor: "#123abc"
   });
 
-  assert.equal(state.patchPayload.attributes?.lightPrimaryColor, "#123abc");
+  assert.equal(state.patchPayload.data.lightPrimaryColor, "#123abc");
   assert.equal(updated.lightPrimaryColor, "#123ABC");
 });
 
@@ -208,8 +199,7 @@ test("workspaceSettingsRepository can be constructed without validating app conf
   const { api } = createWorkspaceSettingsApiStub();
 
   const repository = createRepository({
-    api,
-    knex: createKnexStub()
+    api
   });
 
   assert.ok(repository);

package/test/workspacesRepository.test.js

@@ -3,16 +3,6 @@ import test from "node:test";
 import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspacesRepository.js";
 
-function createKnexStub() {
-  return Object.assign(() => {
-    throw new Error("query execution not expected");
-  }, {
-    async transaction(work) {
-      return work({ trxId: "trx-1" });
-    }
-  });
-}
-
 function asCollectionDocument(rows = []) {
   return {
     data: Array.isArray(rows) ? rows : []
@@ -24,7 +14,7 @@ function toWorkspaceRow(row = {}) {
     id: String(row.id || ""),
     slug: row.slug,
     name: row.name,
-    ownerUserId: row.ownerUserId == null ? null : String(row.ownerUserId),
+    owner: row.ownerUserId == null ? null : { id: String(row.ownerUserId) },
     isPersonal: row.isPersonal,
     avatarUrl: row.avatarUrl,
     createdAt: row.createdAt,
@@ -60,7 +50,8 @@ function createWorkspacesApiStub({
   const api = {
     resources: {
       workspaces: {
-        async query({ queryParams }) {
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
           const filters = queryParams?.filters || {};
 
           if (Object.hasOwn(filters, "id")) {
@@ -81,21 +72,25 @@ function createWorkspacesApiStub({
           return asCollectionDocument([]);
         },
         async post(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          state.postPayload = inputRecord;
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.postPayload = payload;
           if (insertError) {
             throw insertError;
           }
 
           const row = {
             id: "1",
-            slug: String(inputRecord.attributes?.slug || ""),
-            name: String(inputRecord.attributes?.name || ""),
-            ownerUserId: String(inputRecord.relationships?.owner?.data?.id || ""),
-            isPersonal: Boolean(inputRecord.attributes?.isPersonal),
-            avatarUrl: String(inputRecord.attributes?.avatarUrl || ""),
-            createdAt: inputRecord.attributes?.createdAt,
-            updatedAt: inputRecord.attributes?.updatedAt,
+            slug: String(data.slug || ""),
+            name: String(data.name || ""),
+            ownerUserId: String(data.owner || ""),
+            isPersonal: Boolean(data.isPersonal),
+            avatarUrl: String(data.avatarUrl || ""),
+            createdAt: data.createdAt,
+            updatedAt: data.updatedAt,
             deletedAt: null
           };
           rowsById.set(row.id, row);
@@ -105,18 +100,22 @@ function createWorkspacesApiStub({
           return toWorkspaceRow(row);
         },
         async patch(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          state.patchPayload = inputRecord;
-          const existing = rowsById.get(String(inputRecord.id)) || {
-            id: String(inputRecord.id)
+          const data = payload?.data || {};
+          assert.equal(payload.format, "plain");
+          assert.equal(payload.returning, "full");
+          assert.equal(payload.inputRecord, undefined);
+          assert.equal(payload.document, undefined);
+          state.patchPayload = payload;
+          const existing = rowsById.get(String(payload.id)) || {
+            id: String(payload.id)
           };
           const updated = {
             ...existing,
-            ...(inputRecord.attributes || {}),
-            ...(inputRecord.relationships?.owner?.data?.id
-              ? { ownerUserId: String(inputRecord.relationships.owner.data.id) }
+            ...data,
+            ...(data.owner
+              ? { ownerUserId: String(data.owner) }
               : {}),
-            id: String(inputRecord.id)
+            id: String(payload.id)
           };
           rowsById.set(updated.id, updated);
           if (updated.slug) {
@@ -126,7 +125,8 @@ function createWorkspacesApiStub({
         }
       },
       workspaceMemberships: {
-        async query({ queryParams }) {
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
           const filters = queryParams?.filters || {};
           if (Object.hasOwn(filters, "user") && Object.hasOwn(filters, "status")) {
             const rows = membershipRows.filter((row) => (
@@ -161,7 +161,7 @@ test("workspacesRepository.findById reads a canonical workspace row through json
       }]
     ])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const workspace = await repository.findById("7");
 
@@ -207,7 +207,7 @@ test("workspacesRepository.findPersonalByOwnerUserId returns the first personal
       ]]
     ])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const workspace = await repository.findPersonalByOwnerUserId("9");
 
@@ -217,7 +217,7 @@ test("workspacesRepository.findPersonalByOwnerUserId returns the first personal
 
 test("workspacesRepository.insert writes canonical fields through json-rest-api", async () => {
   const { api, state } = createWorkspacesApiStub();
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const inserted = await repository.insert({
     slug: "TonyMobily3",
@@ -227,13 +227,13 @@ test("workspacesRepository.insert writes canonical fields through json-rest-api"
     isPersonal: false
   });
 
-  assert.equal(state.postPayload.relationships?.owner?.data?.id, "9");
-  assert.equal(state.postPayload.attributes?.slug, "TonyMobily3");
-  assert.equal(state.postPayload.attributes?.name, "TonyMobily3");
-  assert.equal(state.postPayload.attributes?.isPersonal, false);
-  assert.equal(state.postPayload.attributes?.avatarUrl, "");
-  assert.equal(typeof state.postPayload.attributes?.createdAt, "string");
-  assert.equal(state.postPayload.attributes?.updatedAt, state.postPayload.attributes?.createdAt);
+  assert.equal(state.postPayload.data.owner, "9");
+  assert.equal(state.postPayload.data.slug, "TonyMobily3");
+  assert.equal(state.postPayload.data.name, "TonyMobily3");
+  assert.equal(state.postPayload.data.isPersonal, false);
+  assert.equal(state.postPayload.data.avatarUrl, "");
+  assert.equal(typeof state.postPayload.data.createdAt, "string");
+  assert.equal(state.postPayload.data.updatedAt, state.postPayload.data.createdAt);
   assert.equal(inserted.id, "1");
   assert.equal(inserted.ownerUserId, "9");
 });
@@ -252,9 +252,9 @@ test("workspacesRepository.insert falls back to slug lookup on duplicate slug",
   };
   const { api } = createWorkspacesApiStub({
     rowsBySlug: new Map([["shared-workspace", existingRow]]),
-    insertError: { code: "ER_DUP_ENTRY" }
+    insertError: { code: "REST_API_WRITE", transactionOutcome: "rolledBack", cause: { code: "ER_DUP_ENTRY" } }
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const inserted = await repository.insert({
     slug: "shared-workspace",
@@ -282,15 +282,15 @@ test("workspacesRepository.updateById patches canonical fields and updatedAt", a
       }]
     ])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   await repository.updateById("7", {
     name: "TonyMobily 4"
   });
 
   assert.equal(state.patchPayload.id, "7");
-  assert.equal(state.patchPayload.attributes?.name, "TonyMobily 4");
-  assert.equal(typeof state.patchPayload.attributes?.updatedAt, "string");
+  assert.equal(state.patchPayload.data.name, "TonyMobily 4");
+  assert.equal(typeof state.patchPayload.data.updatedAt, "string");
 });
 
 test("workspacesRepository.listForUserId keeps membership fields outside the canonical workspace row", async () => {
@@ -346,7 +346,7 @@ test("workspacesRepository.listForUserId keeps membership fields outside the can
       }
     ]
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const workspaces = await repository.listForUserId("9");