@jskit-ai/workspaces-core 0.1.163 → 0.1.164

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -1,16 +1,13 @@
 import {
   normalizeRecordId,
-  isDuplicateEntryError,
-  createWithTransaction
+  isDuplicateEntryError
 } from "../common/repositories/repositoryUtils.js";
 import {
-  createJsonApiInputRecord,
   createJsonRestContext,
   extractJsonRestCollectionRows
 } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { resolveWorkspaceThemePalettes } from "../../shared/settings.js";
 
-const RESOURCE_TYPE = "workspaceSettings";
 const WORKSPACE_SETTINGS_PATCH_FIELDS = Object.freeze([
   "lightPrimaryColor",
   "lightSecondaryColor",
@@ -52,14 +49,11 @@ function createDefaultWorkspaceSettingsCreatePayload(workspaceId, defaultInvites
   };
 }
 
-function createRepository({ api, knex, defaultInvitesEnabled = true } = {}) {
+function createRepository({ api, defaultInvitesEnabled = true } = {}) {
   if (!api?.resources?.workspaceSettings) {
     throw new TypeError("workspaceSettingsRepository requires json-rest-api workspaceSettings resource.");
   }
-  if (typeof knex !== "function") {
-    throw new TypeError("workspaceSettingsRepository requires knex.");
-  }
-  const withTransaction = createWithTransaction(knex);
+  const withTransaction = (work) => api.transaction(work);
 
   async function queryFirst(filters = {}, options = {}) {
     const rows = extractJsonRestCollectionRows(
@@ -69,7 +63,7 @@ function createRepository({ api, knex, defaultInvitesEnabled = true } = {}) {
             filters
           },
           transaction: options?.trx || null,
-          simplified: true
+          format: "plain"
         },
         createJsonRestContext(options?.context || null)
       )
@@ -101,19 +95,15 @@ function createRepository({ api, knex, defaultInvitesEnabled = true } = {}) {
     try {
       await api.resources.workspaceSettings.post(
         {
-          inputRecord: createJsonApiInputRecord(
-            RESOURCE_TYPE,
-            createDefaultWorkspaceSettingsCreatePayload(normalizedWorkspaceId, defaultInvitesEnabled === true),
-            {
-              id: normalizedWorkspaceId
-            }
-          ),
+          data: createDefaultWorkspaceSettingsCreatePayload(normalizedWorkspaceId, defaultInvitesEnabled === true),
+          format: "plain",
+          returning: "full",
           transaction: options?.trx || null
         },
         createJsonRestContext(options?.context || null)
       );
     } catch (error) {
-      if (!isDuplicateEntryError(error)) {
+      if (options?.trx || error?.transactionOutcome !== "rolledBack" || !isDuplicateEntryError(error)) {
         throw error;
       }
     }
@@ -137,16 +127,13 @@ function createRepository({ api, knex, defaultInvitesEnabled = true } = {}) {
 
     await api.resources.workspaceSettings.patch(
       {
-        inputRecord: createJsonApiInputRecord(
-          RESOURCE_TYPE,
-          {
-            ...updatePayload,
-            updatedAt: new Date().toISOString()
-          },
-          {
-            id: normalizedWorkspaceId
-          }
-        ),
+        id: normalizedWorkspaceId,
+        data: {
+          ...updatePayload,
+          updatedAt: new Date().toISOString()
+        },
+        format: "plain",
+        returning: "full",
         transaction: options?.trx || null
       },
       createJsonRestContext(options?.context || null)

package/test/featureRuntime.test.js

@@ -73,7 +73,6 @@ test("WorkspacesFeature assembles workspace behavior and explicit integrations",
       "auth.extensions": authExtensions,
       "runtime.bootstrap": bootstrap,
       "runtime.config": runtimeConfig(),
-      "runtime.database": { knex() {} },
       "runtime.env": {},
       "runtime.http": {
         router: {

package/test/repositories.integration.test.js

@@ -0,0 +1,323 @@
+import assert from "node:assert/strict";
+import { before, beforeEach, after, describe, test } from "node:test";
+import knexLib from "knex";
+import { createAuthExtensions } from "@jskit-ai/auth-core/server/authExtensions";
+import { findDuplicateEntryError } from "@jskit-ai/database-runtime/shared";
+import { createJsonRestApiHost } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { UsersIdentityProvider } from "@jskit-ai/users-core/server/UsersIdentityProvider";
+import { createUsersExtensions } from "@jskit-ai/users-core/server/usersExtensions";
+import usersInitial from "../../users-core/migrations/users_core_generic_initial.cjs";
+import usersUsername from "../../users-core/migrations/users_core_profile_username.cjs";
+import usersUpdatedAt from "../../users-core/migrations/users_core_profile_updated_at.cjs";
+import workspacesInitial from "../migrations/workspaces_core_initial.cjs";
+import workspaceSettingsMigration from "../migrations/workspaces_core_workspace_settings_single_name_source.cjs";
+import workspaceColorMigration from "../migrations/workspaces_core_workspaces_drop_color.cjs";
+import { installWorkspaceResources } from "../src/server/WorkspacesFeature.js";
+import { createRepository as createWorkspacesRepository } from "../src/server/common/repositories/workspacesRepository.js";
+import { createRepository as createMembershipsRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
+import { createRepository as createInvitesRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
+import { createRepository as createSettingsRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
+
+const TABLES = [
+  "workspace_invites", "workspace_settings", "workspace_memberships", "workspaces", "user_settings", "users"
+];
+const databaseUrl = process.env.JSKIT_REPOSITORY_TEST_DATABASE_URL;
+
+function databaseConfig() {
+  if (!databaseUrl) {
+    return {
+      client: "better-sqlite3",
+      connection: { filename: ":memory:" },
+      useNullAsDefault: true,
+      pool: { min: 1, max: 1 }
+    };
+  }
+  const url = new URL(databaseUrl);
+  assert.match(url.protocol, /^(?:mysql2?|postgres(?:ql)?):$/u);
+  assert.match(url.pathname, /^\/jskit_repository_test_[a-z0-9_]+$/u);
+  if (url.protocol.startsWith("postgres")) {
+    return {
+      client: "pg",
+      connection: {
+        host: url.searchParams.get("host") || url.hostname,
+        port: Number(url.port || 5432),
+        user: decodeURIComponent(url.username),
+        password: decodeURIComponent(url.password),
+        database: url.pathname.slice(1)
+      },
+      pool: { min: 1, max: 2 }
+    };
+  }
+  return {
+    client: "mysql2",
+    connection: {
+      host: url.hostname,
+      port: Number(url.port || 3306),
+      user: decodeURIComponent(url.username),
+      password: decodeURIComponent(url.password),
+      database: url.pathname.slice(1),
+      ...(url.searchParams.has("socketPath") ? { socketPath: url.searchParams.get("socketPath") } : {}),
+      timezone: "Z",
+      supportBigNumbers: true,
+      bigNumberStrings: true
+    },
+    pool: { min: 1, max: 2 }
+  };
+}
+
+const configuration = databaseConfig();
+const databaseLabel = { pg: "PostgreSQL", mysql2: "MySQL", "better-sqlite3": "SQLite" }[configuration.client];
+
+describe(`users and workspaces repositories on migrated ${databaseLabel}`, () => {
+  let knex;
+  let api;
+  let profiles;
+  let userSettings;
+  let workspaces;
+  let memberships;
+  let invites;
+  let settings;
+  let ownsTables = false;
+
+  before(async () => {
+    knex = knexLib(configuration);
+    if (databaseUrl) {
+      const tables = configuration.client === "pg"
+        ? await knex("information_schema.tables").where({ table_schema: "public" }).select("table_name")
+        : (await knex.raw("SHOW TABLES"))[0];
+      assert.equal(tables.length, 0, "Native repository tests require an empty disposable database");
+    } else {
+      await knex.raw("PRAGMA foreign_keys = ON");
+    }
+    ownsTables = true;
+    for (const migration of [
+      usersInitial, usersUsername, usersUpdatedAt, workspacesInitial, workspaceSettingsMigration, workspaceColorMigration
+    ]) {
+      await migration.up(knex);
+    }
+    api = await createJsonRestApiHost({ knex, logger: { error() {}, warn() {}, info() {}, debug() {} } });
+    const { identity } = await UsersIdentityProvider.setup({
+      authExtensions: createAuthExtensions(),
+      extensions: createUsersExtensions(),
+      jsonRestApi: api
+    });
+    ({ userProfiles: profiles, userSettings } = identity.repositories);
+    await installWorkspaceResources(api);
+    workspaces = createWorkspacesRepository({ api });
+    memberships = createMembershipsRepository({ api });
+    invites = createInvitesRepository({ api });
+    settings = createSettingsRepository({ api });
+  });
+
+  beforeEach(async () => {
+    for (const table of TABLES) await knex(table).delete();
+  });
+
+  after(async () => {
+    if (!knex) return;
+    try {
+      if (ownsTables) {
+        for (const table of TABLES) await knex.schema.dropTableIfExists(table);
+      }
+    } finally {
+      await knex.destroy();
+    }
+  });
+
+  const createProfile = (name, options) => profiles.upsert({
+    authProvider: "local",
+    authProviderUserSid: `identity-${name}`,
+    email: `${name}@example.com`,
+    displayName: name
+  }, options);
+
+  test("profile and mapped user settings writes persist normalized values and UTC timestamps", async () => {
+    const profile = await profiles.upsert({
+      provider: " LOCAL ", providerUserId: " ada-identity ",
+      email: " ADA@EXAMPLE.COM ", username: " Ada Lovelace ", displayName: " Ada Lovelace "
+    });
+    assert.equal(typeof profile.id, "string");
+    assert.equal(profile.authProvider, "local");
+    assert.equal(profile.authProviderUserSid, "ada-identity");
+    assert.equal(profile.email, "ada@example.com");
+    assert.equal(profile.username, "ada-lovelace");
+    assert.equal(profile.displayName, "Ada Lovelace");
+    assert.match(profile.createdAt, /Z$/u);
+    assert.match(profile.updatedAt, /Z$/u);
+    assert.equal((await profiles.findByEmail(" ADA@EXAMPLE.COM ")).id, profile.id);
+
+    const updated = await profiles.upsert({
+      provider: "local", providerUserId: "ada-identity", email: " ADA.NEW@EXAMPLE.COM ",
+      username: "ignored-new-name", displayName: " Ada Updated "
+    });
+    assert.equal(updated.id, profile.id);
+    assert.equal(updated.username, "ada-lovelace");
+    assert.equal(updated.displayName, "Ada Updated");
+    await profiles.updateAvatarById(profile.id, {
+      avatarStorageKey: " avatars/ada.png ", avatarVersion: "v1",
+      avatarUpdatedAt: new Date("2026-09-12T10:30:00.000Z")
+    });
+    const avatarProfile = await profiles.findById(profile.id);
+    assert.equal(avatarProfile.avatarStorageKey, "avatars/ada.png");
+    assert.equal(avatarProfile.avatarUpdatedAt, "2026-09-12T10:30:00.000Z");
+    await profiles.clearAvatarById(profile.id);
+    assert.equal((await profiles.findById(profile.id)).avatarUpdatedAt, null);
+
+    const defaults = await userSettings.ensureForUserId(profile.id);
+    assert.equal(defaults.id, profile.id);
+    assert.equal(defaults.passwordSignInEnabled, true);
+    const preferences = await userSettings.updatePreferences(profile.id, {
+      locale: " EN-AU ", currencyCode: "aud", timeZone: " Australia/Perth ",
+      avatarSize: 96, theme: " dark ", ignoredField: "must not reach storage"
+    });
+    assert.equal(preferences.locale, "en-au");
+    assert.equal(preferences.currencyCode, "AUD");
+    assert.equal(preferences.timeZone, "Australia/Perth");
+    assert.equal(preferences.avatarSize, 96);
+    assert.equal(preferences.theme, "dark");
+    await userSettings.updateNotifications(profile.id, { productUpdates: false, securityAlerts: true });
+    const disabled = await userSettings.updatePasswordSignInEnabled(profile.id, false, { passwordSetupRequired: true });
+    assert.equal(disabled.passwordSignInEnabled, false);
+    assert.equal(disabled.passwordSetupRequired, true);
+    assert.equal(disabled.productUpdates, false);
+    const stored = await knex("user_settings").where({ user_id: profile.id }).first();
+    assert.equal(stored.currency_code, "AUD");
+    assert.equal(Number(stored.notify_product_updates), 0);
+    assert.equal((await knex("users").where({ id: profile.id }).first()).email, "ada.new@example.com");
+  });
+
+  test("workspace and membership repositories read mapped relationships through includes", async () => {
+    const owner = await createProfile("Ada");
+    const member = await createProfile("Grace");
+    const workspace = await workspaces.insert({
+      slug: " TEAM-ONE ", name: " Team One ", ownerUserId: owner.id, isPersonal: true
+    });
+    assert.equal(workspace.slug, "team-one");
+    assert.equal(workspace.name, "Team One");
+    assert.equal(workspace.ownerUserId, owner.id);
+    assert.equal(workspace.isPersonal, true);
+    assert.equal((await workspaces.findPersonalByOwnerUserId(owner.id)).id, workspace.id);
+
+    const ownerMembership = await memberships.ensureOwnerMembership(workspace.id, owner.id);
+    assert.equal(ownerMembership.workspaceId, workspace.id);
+    assert.equal(ownerMembership.userId, owner.id);
+    assert.equal(ownerMembership.roleSid, "owner");
+    await memberships.upsertMembership(workspace.id, member.id, { roleSid: " MEMBER ", status: " ACTIVE " });
+    const listed = await memberships.listActiveByWorkspaceId(workspace.id);
+    assert.deepEqual(listed.map(({ displayName, email }) => ({ displayName, email })), [
+      { displayName: "Ada", email: "ada@example.com" },
+      { displayName: "Grace", email: "grace@example.com" }
+    ]);
+    const visible = await workspaces.listForUserId(member.id);
+    assert.equal(visible.length, 1);
+    assert.equal(visible[0].ownerUserId, owner.id);
+    assert.equal(visible[0].roleSid, "member");
+    assert.deepEqual(await memberships.listActiveWorkspaceIdsByUserId(member.id), [workspace.id]);
+    const changed = await workspaces.updateById(workspace.id, { ownerUserId: member.id, name: " Renamed " });
+    assert.equal(changed.ownerUserId, member.id);
+    assert.equal((await knex("workspaces").where({ id: workspace.id }).first()).name, "Renamed");
+    await memberships.upsertMembership(workspace.id, member.id, { status: "inactive" });
+    assert.deepEqual(await workspaces.listForUserId(member.id), []);
+  });
+
+  test("workspace settings and invitation lifecycle preserve logical IDs and included workspaces", async () => {
+    const owner = await createProfile("Ada");
+    const workspace = await workspaces.insert({ slug: "invitations", name: "Invitations", ownerUserId: owner.id });
+    const initial = await settings.ensureForWorkspaceId(workspace.id);
+    assert.equal(initial.id, workspace.id);
+    const changed = await settings.updateSettingsByWorkspaceId(workspace.id, {
+      lightPrimaryColor: "#abcdef", invitesEnabled: false, name: "Ignored legacy name"
+    });
+    assert.equal(changed.lightPrimaryColor, "#ABCDEF");
+    assert.equal(changed.invitesEnabled, false);
+    assert.equal((await workspaces.findById(workspace.id)).name, "Invitations");
+    assert.equal((await knex("workspace_settings").where({ workspace_id: workspace.id }).first()).light_primary_color, "#ABCDEF");
+    const invite = await invites.insert({
+      workspaceId: workspace.id, email: " GRACE@EXAMPLE.COM ", roleSid: " MEMBER ",
+      tokenHash: " token-one ", invitedByUserId: owner.id,
+      expiresAt: new Date("2026-09-14T10:00:00.000Z")
+    });
+    assert.equal(invite.workspaceId, workspace.id);
+    assert.equal(invite.invitedByUserId, owner.id);
+    assert.equal(invite.email, "grace@example.com");
+    assert.equal(invite.expiresAt, "2026-09-14T10:00:00.000Z");
+    const pending = await invites.listPendingByEmail(" GRACE@EXAMPLE.COM ");
+    assert.equal(pending.length, 1);
+    assert.equal(pending[0].workspaceSlug, "invitations");
+    assert.equal(pending[0].workspaceName, "Invitations");
+    assert.equal((await invites.findPendingByIdForWorkspace(invite.id, workspace.id)).id, invite.id);
+    await invites.markAcceptedById(invite.id);
+    assert.equal(await invites.findPendingByTokenHash("token-one"), null);
+    const accepted = await invites.findByTokenHashWithWorkspace("token-one");
+    assert.equal(accepted.status, "accepted");
+    assert.match(accepted.acceptedAt, /Z$/u);
+    assert.equal(accepted.workspaceId, workspace.id);
+  });
+
+  test("one managed transaction rolls back onboarding across all six repositories", async () => {
+    await assert.rejects(profiles.withTransaction(async (trx) => {
+      const options = { trx };
+      const owner = await createProfile("Rollback", options);
+      await userSettings.ensureForUserId(owner.id, options);
+      const workspace = await workspaces.insert({ slug: "rollback", name: "Rollback", ownerUserId: owner.id }, options);
+      await memberships.ensureOwnerMembership(workspace.id, owner.id, options);
+      await settings.ensureForWorkspaceId(workspace.id, options);
+      await invites.insert({ workspaceId: workspace.id, email: "invite@example.com", tokenHash: "rollback-token" }, options);
+      assert.equal((await workspaces.listForUserId(owner.id, options))[0].id, workspace.id);
+      throw new Error("Abort onboarding");
+    }), /Abort onboarding/u);
+    for (const table of TABLES) {
+      assert.equal(Number((await knex(table).count({ count: "*" }).first()).count), 0, `${table} must roll back`);
+    }
+  });
+
+  test("a standalone duplicate workspace recovers after rollback without overwriting the existing row", {
+    skip: !databaseUrl && "Application duplicate recovery supports native MySQL/Postgres drivers"
+  }, async () => {
+    const owner = await createProfile("Ada");
+    const original = await workspaces.insert({ slug: "duplicate", name: "Original", ownerUserId: owner.id });
+    const duplicate = await workspaces.insert({ slug: "duplicate", name: "Replacement", ownerUserId: owner.id });
+    assert.equal(duplicate.id, original.id);
+    assert.equal(duplicate.name, "Original");
+    assert.equal(Number((await knex("workspaces").count({ count: "*" }).first()).count), 1);
+  });
+
+  test("a duplicate participant poisons its managed transaction even when its caller catches the failure", async () => {
+    const owner = await createProfile("Ada");
+    await workspaces.insert({ slug: "duplicate", name: "Original", ownerUserId: owner.id });
+    let participantFailure;
+    await assert.rejects(userSettings.withTransaction(async (trx) => {
+      await profiles.updateDisplayNameById(owner.id, "Must roll back", { trx });
+      try {
+        await workspaces.insert({ slug: "duplicate", name: "Replacement", ownerUserId: owner.id }, { trx });
+      } catch (error) {
+        participantFailure = error;
+      }
+    }), (error) => {
+      assert.equal(error.transactionOutcome, "rolledBack");
+      return true;
+    });
+    assert.equal(participantFailure?.transactionOutcome, "pending");
+    if (databaseUrl) assert.ok(findDuplicateEntryError(participantFailure));
+    else assert.equal(participantFailure.cause.code, "SQLITE_CONSTRAINT_UNIQUE");
+    assert.equal((await profiles.findById(owner.id)).displayName, "Ada");
+    assert.equal(Number((await knex("workspaces").count({ count: "*" }).first()).count), 1);
+  });
+
+  test("profile email conflicts retain the real database cause after the standalone transaction rolls back", {
+    skip: !databaseUrl && "Application duplicate recovery supports native MySQL/Postgres drivers"
+  }, async () => {
+    const owner = await createProfile("Ada");
+    await assert.rejects(profiles.upsert({
+      authProvider: "local", authProviderUserSid: "different-identity",
+      email: owner.email, displayName: "Different person"
+    }), (error) => {
+      assert.equal(error.code, "USER_PROFILE_EMAIL_CONFLICT");
+      assert.equal(error.transactionOutcome, "rolledBack");
+      assert.ok(findDuplicateEntryError(error));
+      return true;
+    });
+    assert.equal(Number((await knex("users").count({ count: "*" }).first()).count), 1);
+    assert.equal((await profiles.findByEmail(owner.email)).id, owner.id);
+  });
+});

package/test/repositoryContracts.test.js

@@ -5,20 +5,11 @@ import { createRepository as createWorkspaceMembershipsRepository } from "../src
 import { createRepository as createWorkspacesRepository } from "../src/server/common/repositories/workspacesRepository.js";
 import { createRepository as createWorkspaceSettingsRepository } 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 createApiStub() {
   return {
+    async transaction(work) {
+      return work({ trxId: "managed-1" });
+    },
     resources: {
       workspaceInvites: {},
       workspaceMemberships: {},
@@ -28,19 +19,52 @@ function createApiStub() {
   };
 }
 
-test("workspaces-core repositories expose withTransaction", async () => {
-  const knex = createKnexStub();
+test("workspaces-core repositories delegate transaction ownership and failures to the API", async () => {
   const api = createApiStub();
   const repositories = [
-    createWorkspaceInvitesRepository({ api, knex }),
-    createWorkspaceMembershipsRepository({ api, knex }),
-    createWorkspacesRepository({ api, knex }),
-    createWorkspaceSettingsRepository({ api, knex })
+    createWorkspaceInvitesRepository({ api }),
+    createWorkspaceMembershipsRepository({ api }),
+    createWorkspacesRepository({ api }),
+    createWorkspaceSettingsRepository({ api })
   ];
 
   for (const repository of repositories) {
     assert.equal(typeof repository.withTransaction, "function");
     const result = await repository.withTransaction(async (trx) => ({ id: trx.trxId }));
-    assert.deepEqual(result, { id: "trx-1" });
+    assert.deepEqual(result, { id: "managed-1" });
+    const failure = new Error("Participant failed");
+    await assert.rejects(repository.withTransaction(async () => { throw failure; }), error => error === failure);
   }
 });
+
+const duplicateRecoveryCases = [
+  ["settings", createWorkspaceSettingsRepository, "workspaceSettings", repository => repository.ensureForWorkspaceId("7")],
+  ["owner membership", createWorkspaceMembershipsRepository, "workspaceMemberships", repository => repository.ensureOwnerMembership("7", "9")],
+  ["membership", createWorkspaceMembershipsRepository, "workspaceMemberships", repository => repository.upsertMembership("7", "9")],
+  ["invite", createWorkspaceInvitesRepository, "workspaceInvites", repository => repository.insert({ workspaceId: "7", email: "ada@example.com" })],
+  ["workspace", createWorkspacesRepository, "workspaces", repository => repository.insert({ ownerUserId: "9", slug: "shared" })]
+];
+
+for (const [name, createRepository, resourceName, write] of duplicateRecoveryCases) {
+  for (const outcome of ["pending", "committed", "unknown"]) {
+    test(`${name} preserves a ${outcome} duplicate failure without a fallback query`, async () => {
+      let reads = 0;
+      let writeStarted = false;
+      const failure = Object.assign(new Error("Write failed"), {
+        transactionOutcome: outcome, cause: { code: "ER_DUP_ENTRY" }
+      });
+      const api = createApiStub();
+      api.resources[resourceName] = {
+        async query() {
+          assert.equal(writeStarted, false, "A failed transaction cannot support duplicate recovery");
+          reads += 1;
+          return { data: [] };
+        },
+        async post() { writeStarted = true; throw failure; }
+      };
+      const repository = createRepository({ api });
+      await assert.rejects(write(repository), error => error === failure);
+      assert.equal(reads, ["invite", "workspace"].includes(name) ? 0 : 1);
+    });
+  }
+}

package/test/workspaceInvitesRepository.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/workspaceInvitesRepository.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 : []
@@ -58,7 +46,8 @@ function createWorkspaceInvitesApiStub({
   const api = {
     resources: {
       workspaceInvites: {
-        async query({ queryParams }) {
+        async query({ queryParams, format }) {
+          assert.equal(format, "plain");
           const filters = queryParams?.filters || {};
           const matching = rows.filter((row) => {
             if (Object.hasOwn(filters, "id") && String(row.id) !== String(filters.id)) {
@@ -82,21 +71,25 @@ function createWorkspaceInvitesApiStub({
           return asCollectionDocument(matching.map((row) => toWorkspaceInviteRow(row)));
         },
         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 = {
             id: "1",
-            workspace: { id: String(inputRecord.relationships?.workspace?.data?.id || "") },
-            email: inputRecord.attributes?.email,
-            roleSid: inputRecord.attributes?.roleSid,
-            status: inputRecord.attributes?.status,
-            tokenHash: inputRecord.attributes?.tokenHash,
-            invitedByUser: inputRecord.relationships?.invitedByUser?.data
-              ? { id: String(inputRecord.relationships.invitedByUser.data.id) }
+            workspace: { id: String(data.workspace || "") },
+            email: data.email,
+            roleSid: data.roleSid,
+            status: data.status,
+            tokenHash: data.tokenHash,
+            invitedByUser: data.invitedByUser
+              ? { id: String(data.invitedByUser) }
               : null,
-            expiresAt: inputRecord.attributes?.expiresAt,
-            acceptedAt: inputRecord.attributes?.acceptedAt,
-            revokedAt: inputRecord.attributes?.revokedAt,
+            expiresAt: data.expiresAt,
+            acceptedAt: data.acceptedAt,
+            revokedAt: data.revokedAt,
             createdAt: "2026-03-09 00:26:35.710",
             updatedAt: "2026-03-09 00:26:35.710"
           };
@@ -105,17 +98,21 @@ function createWorkspaceInvitesApiStub({
           return toWorkspaceInviteRow(row);
         },
         async patch(payload) {
-          const inputRecord = payload?.inputRecord?.data || {};
-          state.patchPayloads.push(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.patchPayloads.push(payload);
+          const existing = rowById.get(String(payload.id));
           if (existing) {
             const updated = {
               ...existing,
-              ...(inputRecord.attributes || {})
+              ...data
             };
-            rowById.set(String(inputRecord.id), updated);
+            rowById.set(String(payload.id), updated);
           }
-          const updatedRow = rowById.get(String(inputRecord.id)) || null;
+          const updatedRow = rowById.get(String(payload.id)) || null;
           return updatedRow ? toWorkspaceInviteRow(updatedRow) : null;
         }
       }
@@ -127,7 +124,7 @@ function createWorkspaceInvitesApiStub({
 
 test("workspaceInvitesRepository.insert preserves expiresAt and relationship fields through the resource write path", async () => {
   const { api, state } = createWorkspaceInvitesApiStub();
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   await repository.insert({
     workspaceId: "1",
@@ -139,11 +136,11 @@ test("workspaceInvitesRepository.insert preserves expiresAt and relationship fie
     expiresAt: "2026-03-16T00:26:35.709Z"
   });
 
-  assert.equal(state.postPayload.relationships?.workspace?.data?.id, "1");
-  assert.equal(state.postPayload.attributes?.email, "invitee@example.com");
-  assert.equal(state.postPayload.relationships?.invitedByUser?.data?.id, "1");
-  assert.equal(state.postPayload.attributes?.tokenHash, "hash");
-  assert.equal(typeof state.postPayload.attributes?.expiresAt, "string");
+  assert.equal(state.postPayload.data.workspace, "1");
+  assert.equal(state.postPayload.data.email, "invitee@example.com");
+  assert.equal(state.postPayload.data.invitedByUser, "1");
+  assert.equal(state.postPayload.data.tokenHash, "hash");
+  assert.equal(typeof state.postPayload.data.expiresAt, "string");
 });
 
 test("workspaceInvitesRepository.findPendingByTokenHash reads from the canonical invite resource without workspace data", async () => {
@@ -165,7 +162,7 @@ test("workspaceInvitesRepository.findPendingByTokenHash reads from the canonical
       }
     ]
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const invite = await repository.findPendingByTokenHash("hash-token");
 
@@ -197,7 +194,7 @@ test("workspaceInvitesRepository.findByTokenHashWithWorkspace preserves workspac
       }
     ]
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const invite = await repository.findByTokenHashWithWorkspace("hash-token");
 
@@ -227,14 +224,14 @@ test("workspaceInvitesRepository.markAcceptedById uses the internal invite resou
       }]
     ])
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   await repository.markAcceptedById("1");
 
   const payload = state.patchPayloads[0];
-  assert.equal(payload.attributes?.status, "accepted");
-  assert.equal(typeof payload.attributes?.acceptedAt, "string");
-  assert.equal(payload.attributes?.updatedAt, payload.attributes?.acceptedAt);
+  assert.equal(payload.data.status, "accepted");
+  assert.equal(typeof payload.data.acceptedAt, "string");
+  assert.equal(payload.data.updatedAt, payload.data.acceptedAt);
 });
 
 test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps workspace join fields outside the base resource contract", async () => {
@@ -261,7 +258,7 @@ test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps wor
       }
     ]
   });
-  const repository = createRepository({ api, knex: createKnexStub() });
+  const repository = createRepository({ api });
 
   const invites = await repository.listPendingByWorkspaceIdWithWorkspace("9");