@jskit-ai/workspaces-core 0.1.199 → 0.1.201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.199",
+  "version": "0.1.201",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -18,11 +18,11 @@
     "./shared/resources/workspaceSettingsResource": "./src/shared/resources/workspaceSettingsResource.js"
   },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.221",
-    "@jskit-ai/json-rest-api-core": "0.1.165",
-    "@jskit-ai/resource-core": "0.1.163",
-    "@jskit-ai/resource-crud-core": "0.1.163",
-    "@jskit-ai/users-core": "0.1.234",
+    "@jskit-ai/database-runtime": "0.1.223",
+    "@jskit-ai/json-rest-api-core": "0.1.167",
+    "@jskit-ai/resource-core": "0.1.165",
+    "@jskit-ai/resource-crud-core": "0.1.165",
+    "@jskit-ai/users-core": "0.1.236",
     "json-rest-schema": "^1.0.17"
   },
   "description": "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
@@ -169,8 +169,8 @@
     }
   },
   "peerDependencies": {
-    "@jskit-ai/auth-core": "0.1.219",
-    "@jskit-ai/http-runtime": "0.1.219",
-    "@jskit-ai/kernel": "0.1.221"
+    "@jskit-ai/auth-core": "0.1.221",
+    "@jskit-ai/http-runtime": "0.1.221",
+    "@jskit-ai/kernel": "0.1.223"
   }
 }

package/patterns/workspace-server/PATTERN.md

@@ -30,52 +30,47 @@ contracts exported by `@jskit-ai/workspaces-core`.
 
 ## Transactional invitation participation
 
-Use the existing `workspaces.core` capability. During application feature setup,
-register one callback with
+Through `workspaces.core`, register one callback during feature setup with
 `workspaces.services.pendingInvitations.registerAcceptanceParticipant(fn)`.
 The built-in `workspace.invite.redeem` action invokes
-`fn({ invite, user }, { trx, context })` after recipient/state/expiry validation
-and membership activation inside the same uncommitted managed transaction.
-Forward `trx` to every application owner; throw on invalid reviewed associations
-or failed writes. The framework marks accepted and commits only after success.
-Do not perform external effects or complete the transaction in the participant.
-Non-functions, duplicate registrations and registrations after acceptance/refusal
-begins reject. Ordinary invitations can pass through without an association;
-expected-but-missing, stale, revoked or conflicting associations must fail closed.
-
-For deliberate invitation creation, use `members.prepareInvite(workspace, actor,
+`fn({ invite, user }, { trx, context })` after validating the recipient, state and
+expiry and activating membership in the uncommitted transaction. Forward `trx`
+to every application owner and propagate failures. JSKIT marks accepted and
+commits after the callback succeeds. Keep external effects out of the callback.
+Registration rejects non-functions, duplicates and calls after acceptance/refusal
+begins. Allow ordinary invitations; reject stale, revoked, conflicting or
+unexpectedly missing application associations.
+
+Use `members.prepareInvite(workspace, actor,
 payload, { trx, context })` in `repositories.workspaceInvites.withTransaction`
 or the same JSON REST API's managed `transaction`. It returns
 `{ createdInviteId, inviteTokenPreview }` without delivery. Lock the workspace
 with `repositories.workspaceInvites.lockWorkspaceForInvitations(workspace.id,
 { trx })` before application draft/receipt rows, and save the exact invitation
-association and retry receipt before commit. Failed association restores any
-prior pending invitation. A draft of intended access should not call preparation.
+association and retry receipt before commit. Failure restores the previous
+pending invitation. Keep access drafts separate: preparation creates a real token.
 
 After confirmed commit, call `members.sendInvite(workspace, actor, prepared,
 { context })`. A later attempt can pass only `{ createdInviteId }`. Delivery
-reloads the committed pending invitation and uses stored recipient/role/expiry;
-it does not replace the invitation. Its `inviteDelivery` is separate from
-persistence: `mailer_unconfigured` when no mailer is supplied, `failed` on a
-renderer/mailer exception, or the normalized controlled/provider result.
-Interruption or failure may still mean a provider accepted the message. Receipt
-idempotency and delivery retries are application-owned; email is not exactly once.
-Do not log the returned token/URL. No SMTP setup is required for testing.
+reloads the committed pending invitation and uses its saved recipient, role and
+expiry. `inviteDelivery` reports `mailer_unconfigured`, `failed` on a renderer/mailer
+exception, or the normalized mailer result. Persistence is unchanged by delivery
+failure. A provider may accept a message before failing; the application owns
+receipts and retries. Keep tokens/URLs out of logs and use controlled mailers in tests.
 
 `createInvite`, acceptance and refusal now own managed transactions and reject
-borrowed `options.trx`. Move transactional creation to preparation/post-commit
-sending and acceptance-related writes into the participant. Revocation may join
+borrowed `options.trx`. Use preparation followed by delivery after commit for
+transactional creation; put related acceptance writes in the participant. Revocation may join
 a managed transaction. Raw Knex/savepoint transactions cannot own resource
 writes. Invitation mutations lock workspace then invitation rows, revalidate
-current state and reject attempts to overwrite terminal state. Matching-recipient
-expiry rejection commits revocation before returning 409. Preserve transaction
+current state and reject changes to accepted/revoked invitations. Expiry rejection
+for the matching recipient commits revocation before returning 409. Preserve transaction
 outcomes and causes; a completion-hook error after commit cannot undo writes.
 
 See the human guide's **Workspace tenancy → Transactional invitation
 participation** for the full consumer example, errors, controlled mailer,
-compatibility notes and native verification commands. Application services still
-own authorization, identity/training linking, reviewed scope eligibility and
-required audit. This seam adds no application domain tables or policy.
+compatibility notes and native verification commands. Application services own
+authorization, identity/training linking, scope eligibility and required audit.
 
 ## Invariants
 

package/src/server/common/repositories/workspaceInvitesRepository.js

@@ -88,24 +88,37 @@ function createRepository({ api } = {}) {
       if (typeof options.trx !== "function" || includeWorkspace) {
         throw new TypeError("Locking invites requires a transaction and no relationship includes.");
       }
-      // Read current rows under lock rather than authorising a state transition
-      // from the ordinary resource query's earlier snapshot.
-      const fields = { id: "id", workspace: "workspace_id", email: "email", status: "status", tokenHash: "token_hash" };
+      // Locking reads must see changes committed while waiting for the lock.
+      const fields = {
+        id: "id",
+        workspace: "workspace_id",
+        email: "email",
+        status: "status",
+        tokenHash: "token_hash"
+      };
       const where = Object.fromEntries(Object.entries(filters).map(([key, value]) => {
-        if (!fields[key]) throw new TypeError("Unsupported locking invitation filter.");
+        if (!fields[key]) {
+          throw new TypeError("Unsupported locking invitation filter.");
+        }
         return [fields[key], value];
       }));
-      // PostgreSQL's driver interprets timestamp-without-time-zone as local
-      // time. These owner columns store UTC; preserve their database text just
-      // as the resource read path does before toIsoString normalizes it.
+      // Read PostgreSQL's UTC timestamps as text to avoid the driver's local-time conversion.
       const dateColumn = (name) => options.trx.client?.config?.client === "pg"
         ? options.trx.raw("CAST(?? AS TEXT)", [name])
         : name;
       return options.trx("workspace_invites").where(where).select({
-        id: "id", workspaceId: "workspace_id", email: "email", roleSid: "role_sid",
-        status: "status", tokenHash: "token_hash", invitedByUserId: "invited_by_user_id",
-        expiresAt: dateColumn("expires_at"), acceptedAt: dateColumn("accepted_at"), revokedAt: dateColumn("revoked_at"),
-        createdAt: dateColumn("created_at"), updatedAt: dateColumn("updated_at")
+        id: "id",
+        workspaceId: "workspace_id",
+        email: "email",
+        roleSid: "role_sid",
+        status: "status",
+        tokenHash: "token_hash",
+        invitedByUserId: "invited_by_user_id",
+        expiresAt: dateColumn("expires_at"),
+        acceptedAt: dateColumn("accepted_at"),
+        revokedAt: dateColumn("revoked_at"),
+        createdAt: dateColumn("created_at"),
+        updatedAt: dateColumn("updated_at")
       }).forUpdate();
     }
     return extractJsonRestCollectionRows(
@@ -128,15 +141,17 @@ function createRepository({ api } = {}) {
       throw new TypeError("Invitation locking requires an active transaction.");
     }
     const id = normalizeRecordId(workspaceId, { fallback: null });
-    if (!id) throw new TypeError("Invitation locking requires workspaceId.");
+    if (!id) {
+      throw new TypeError("Invitation locking requires workspaceId.");
+    }
     const row = await options.trx("workspaces").where({ id }).forUpdate().first("id");
-    if (!row) throw new AppError(404, "Invitation workspace no longer exists.");
+    if (!row) {
+      throw new AppError(404, "Invitation workspace no longer exists.");
+    }
   }
 
   async function findPendingByTokenHash(tokenHash, options = {}) {
     if (options.lock === true) {
-      // The service locates the workspace before opening its transaction, then
-      // revalidates this token against current state under workspace/invite locks.
       await lockWorkspaceForInvitations(options.workspaceId, options);
     }
     const filters = options.lock === true
@@ -146,8 +161,7 @@ function createRepository({ api } = {}) {
           status: "pending"
         }
       : { tokenHash: normalizeText(tokenHash), status: "pending" };
-    // The current locking query uses only IDs, keeping bearer-equivalent token
-    // hashes out of native lock-error SQL. Still recheck token correspondence.
+    // Lock by ID so database errors cannot expose token hashes; compare the token here.
     const rows = await queryInvites(filters, options);
     const invite = normalizeInviteRecord(rows[0] || null);
     return invite?.tokenHash === normalizeText(tokenHash) ? invite : null;
@@ -314,18 +328,24 @@ function createRepository({ api } = {}) {
 
   async function transitionPendingById(inviteId, status, options = {}) {
     const id = normalizeRecordId(inviteId, { fallback: null });
-    if (!id) throw new TypeError("Invitation transition requires inviteId.");
+    if (!id) {
+      throw new TypeError("Invitation transition requires inviteId.");
+    }
     let workspaceId = options.workspaceId;
     if (!workspaceId) {
       const candidate = await queryInvites({ id }, { ...options, lock: false });
-      if (!candidate[0]) throw new AppError(404, "Invitation not found or already handled.");
+      if (!candidate[0]) {
+        throw new AppError(404, "Invitation not found or already handled.");
+      }
       workspaceId = normalizeInviteRecord(candidate[0]).workspaceId;
     }
     if (!options.trx) {
       return withTransaction((trx) => transitionPendingById(id, status, { ...options, trx, workspaceId }));
     }
     const invite = await findPendingByIdForWorkspace(id, workspaceId, { ...options, lock: true });
-    if (!invite) throw new AppError(404, "Invitation not found or already handled.");
+    if (!invite) {
+      throw new AppError(404, "Invitation not found or already handled.");
+    }
     const updatedAt = new Date().toISOString();
     await api.resources.workspaceInvites.patch(
       {
@@ -358,7 +378,9 @@ function createRepository({ api } = {}) {
       return null;
     }
 
-    if (options.lock === true) await lockWorkspaceForInvitations(normalizedWorkspaceId, options);
+    if (options.lock === true) {
+      await lockWorkspaceForInvitations(normalizedWorkspaceId, options);
+    }
     const rows = await queryInvites(
       {
         id: normalizedInviteId,

package/src/server/workspaceMembers/workspaceMembersService.js

@@ -236,11 +236,11 @@ function createService({
     return listInvitesPayload(workspace, options);
   }
 
-  // Trusted server composition: authorisation, association and retry receipts
-  // belong to the application. JSON REST writes enforce managed ownership.
   async function prepareInvite(workspace, user, payload = {}, options = {}) {
     ensureWorkspaceInvitationsEnabled();
-    if (!options.trx) throw new TypeError("prepareInvite requires a managed transaction.");
+    if (!options.trx) {
+      throw new TypeError("prepareInvite requires a managed transaction.");
+    }
     const email = normalizeLowerText(payload.email);
     const roleSid = normalizeLowerText(payload.roleSid || "member") || "member";
     if (!assignableRoleIds.includes(roleSid)) {
@@ -280,11 +280,17 @@ function createService({
 
   async function sendInvite(workspace, user, prepared = {}, options = {}) {
     ensureWorkspaceInvitationsEnabled();
-    if (options.trx) throw new TypeError("sendInvite must run after the invitation transaction commits.");
+    if (options.trx) {
+      throw new TypeError("sendInvite must run after the invitation transaction commits.");
+    }
     const invite = await workspaceInvitesRepository.findPendingByIdForWorkspace(
-      prepared.createdInviteId, workspace.id, { ...options, includeWorkspace: true, lock: false }
+      prepared.createdInviteId,
+      workspace.id,
+      { ...options, includeWorkspace: true, lock: false }
     );
-    if (!invite) throw new AppError(404, "Invite not found or already handled.");
+    if (!invite) {
+      throw new AppError(404, "Invite not found or already handled.");
+    }
     if (invite.expiresAt && new Date(invite.expiresAt).getTime() < Date.now()) {
       throw new AppError(409, "Invitation has expired.");
     }
@@ -306,7 +312,9 @@ function createService({
     const inviteDelivery = await deliverInviteEmail({ workspace: savedWorkspace, user, invite, inviteUrl }, options);
     return {
       ...response,
-      inviteTokenPreview: token, inviteUrl, inviteDelivery,
+      inviteTokenPreview: token,
+      inviteUrl,
+      inviteDelivery,
       createdInviteId: normalizeRecordId(invite.id, { fallback: null })
     };
   }
@@ -332,9 +340,13 @@ function createService({
     const revoke = async (trx) => {
       const transactionOptions = { ...options, trx, lock: true, workspaceId: workspace.id };
       const invite = await workspaceInvitesRepository.findPendingByIdForWorkspace(
-        normalizedInviteId, workspace.id, transactionOptions
+        normalizedInviteId,
+        workspace.id,
+        transactionOptions
       );
-      if (!invite) throw new AppError(404, "Invite not found.");
+      if (!invite) {
+        throw new AppError(404, "Invite not found.");
+      }
       await workspaceInvitesRepository.revokeById(normalizedInviteId, transactionOptions);
       return normalizeRecordId(invite.id, { fallback: null });
     };

package/src/server/workspacePendingInvitations/workspacePendingInvitationsService.js

@@ -16,26 +16,34 @@ function createService({
   let registrationClosed = false;
 
   function registerAcceptanceParticipant(participant) {
-    if (typeof participant !== "function") throw new TypeError("Acceptance participant must be a function.");
-    if (acceptanceParticipant) throw new Error("An invitation acceptance participant is already registered.");
-    if (registrationClosed) throw new Error("Invitation acceptance participant registration is closed.");
+    if (typeof participant !== "function") {
+      throw new TypeError("Acceptance participant must be a function.");
+    }
+    if (acceptanceParticipant) {
+      throw new Error("An invitation acceptance participant is already registered.");
+    }
+    if (registrationClosed) {
+      throw new Error("Invitation acceptance participant registration is closed.");
+    }
     acceptanceParticipant = participant;
   }
 
-  async function inTransaction(user, token, options, work) {
+  async function withInviteTransaction(user, token, options, work) {
     if (options.trx) {
       throw new TypeError("Invitation acceptance/refusal owns its transaction; use the acceptance participant for related writes.");
     }
     registrationClosed = true;
-    // Locate the workspace before opening the unit, avoiding a stale MySQL
-    // repeatable-read snapshot while waiting for its lock. Validate again under
-    // that lock; this preliminary read never authorises a write.
+    // Locate outside the transaction to avoid a stale MySQL repeatable-read
+    // snapshot. The callback validates again under the workspace/invite locks.
     const initial = await requirePendingInviteForUserByToken(user, token, options);
     const result = await workspaceInvitesRepository.withTransaction((trx) => work({
-      ...options, trx, lock: true, workspaceId: initial.invite.workspaceId, inviteId: initial.invite.id
+      ...options,
+      trx,
+      lock: true,
+      workspaceId: initial.invite.workspaceId,
+      inviteId: initial.invite.id
     }));
-    // Expiry revocation intentionally commits before reporting rejection, as it
-    // did before acceptance became atomic. Failed commit keeps its real outcome.
+    // Commit expiry revocation before reporting the rejection.
     if (result.expired) {
       throw Object.assign(new AppError(409, "Invitation has expired."), { transactionOutcome: "committed" });
     }
@@ -228,20 +236,25 @@ function createService({
   }
 
   async function acceptInviteByToken({ user, token } = {}, options = {}) {
-    return inTransaction(user, token, options, async (transactionOptions) => {
+    return withInviteTransaction(user, token, options, async (transactionOptions) => {
       const resolved = await resolveInviteActionInput(
-        user, token, transactionOptions, "workspacePendingInvitationsService.acceptInviteByToken"
+        user,
+        token,
+        transactionOptions,
+        "workspacePendingInvitationsService.acceptInviteByToken"
       );
-      if (resolved.expired) return resolved;
+      if (resolved.expired) {
+        return resolved;
+      }
       const { resolvedInvite, workspaceId } = resolved;
       await workspaceMembershipsRepository.upsertMembership(
-        workspaceId, resolvedInvite.user.id,
+        workspaceId,
+        resolvedInvite.user.id,
         { roleSid: resolvedInvite.invite.roleSid, status: "active" },
         transactionOptions
       );
       if (acceptanceParticipant) {
-        // Do not expose the repository's lock flag as a general application
-        // option. Freeze the envelope so participants cannot replace trx.
+        // Repository locking options stay internal to this service.
         await acceptanceParticipant({
           invite: Object.freeze({ ...resolvedInvite.invite }),
           user: Object.freeze({ ...resolvedInvite.user })
@@ -253,11 +266,16 @@ function createService({
   }
 
   async function refuseInviteByToken({ user, token } = {}, options = {}) {
-    return inTransaction(user, token, options, async (transactionOptions) => {
+    return withInviteTransaction(user, token, options, async (transactionOptions) => {
       const resolved = await resolveInviteActionInput(
-        user, token, transactionOptions, "workspacePendingInvitationsService.refuseInviteByToken"
+        user,
+        token,
+        transactionOptions,
+        "workspacePendingInvitationsService.refuseInviteByToken"
       );
-      if (resolved.expired) return resolved;
+      if (resolved.expired) {
+        return resolved;
+      }
       const { resolvedInvite, workspaceId } = resolved;
       await workspaceInvitesRepository.revokeById(resolvedInvite.invite.id, transactionOptions);
       return { decision: "refused", workspaceId };

package/test/repositories.integration.test.js

@@ -17,7 +17,6 @@ import { createRepository as createWorkspacesRepository } from "../src/server/co
 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";
-
 import { verifyInvitationTransactions } from "./support/invitationTransactions.js";
 
 const TABLES = [

package/test/support/invitationTransactions.js

@@ -101,8 +101,7 @@ export async function verifyInvitationTransactions(t, db) {
       input: { token: prepared.inviteTokenPreview, decision, ...extraInput },
       context: { ...options.context, actor }
     });
-    // Lock workspace before application receipt rows, matching acceptance's
-    // lock order. A lost response/retry returns the exact persisted invitation.
+    // Match acceptance's lock order: workspace, then application receipt.
     async function prepareOnce({ fail = false } = {}) {
       return invites.withTransaction(async (trx) => {
         await invites.lockWorkspaceForInvitations(workspace.id, { trx });
@@ -305,8 +304,7 @@ export async function verifyInvitationTransactions(t, db) {
       if (state === "revoked") await f.members.revokeInvite(f.workspace, prepared.createdInviteId);
       if (state === "accepted") await f.redeem(prepared);
       let called = false;
-      // An already-used service intentionally seals registration; use a fresh
-      // instance to verify terminal-state validation independently of sealing.
+      // The earlier acceptance closed registration on the original service.
       const pending = pendingService({ workspaceInvitesRepository: invites, workspaceMembershipsRepository: memberships });
       pending.registerAcceptanceParticipant(async () => { called = true; });
       const membershipBefore = await memberships.findByWorkspaceIdAndUserId(f.workspace.id, f.user.id);
@@ -437,8 +435,7 @@ export async function verifyInvitationTransactions(t, db) {
         holdTransaction = true;
         connections.length = 0;
         const first = acceptanceWins ? f.redeem(prepared) : compete();
-        // Observe errors immediately so an assertion failure cannot create an
-        // unhandled rejection while a competing database operation is pending.
+        // Handle rejections while the competing transaction is still waiting.
         const firstSettled = Promise.allSettled([first]);
         await entered.promise;
         const waiting = Promise.withResolvers();

package/test/workspaceMembersService.test.js

@@ -81,8 +81,6 @@ function createFixture() {
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
-      async lockWorkspaceForInvitations() {},
       async listPendingByWorkspaceIdWithWorkspace(workspaceId) {
         assert.equal(Number(workspaceId), 7);
         return [];
@@ -111,7 +109,9 @@ test("workspaceMembersService.createInvite uses configured inviteExpiresInMs", a
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
+      async withTransaction(work) {
+        return work({});
+      },
       async lockWorkspaceForInvitations() {},
       async expirePendingByWorkspaceIdAndEmail() {},
       async insert(payload) {
@@ -170,7 +170,9 @@ test("workspaceMembersService.createInvite sends generated invite URLs through t
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
+      async withTransaction(work) {
+        return work({});
+      },
       async lockWorkspaceForInvitations() {},
       async expirePendingByWorkspaceIdAndEmail(workspaceId, email) {
         assert.equal(workspaceId, "7");
@@ -258,8 +260,9 @@ test("workspaceMembersService.revokeInvite returns the revoked invite id", async
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
-      async lockWorkspaceForInvitations() {},
+      async withTransaction(work) {
+        return work({});
+      },
       async listPendingByWorkspaceIdWithWorkspace() {
         return [];
       },
@@ -307,8 +310,6 @@ test("workspaceMembersService rejects invite operations when invitations are dis
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
-      async lockWorkspaceForInvitations() {},
       async listPendingByWorkspaceIdWithWorkspace() {
         throw new Error("invite repository should not be called when invitations are disabled");
       },
@@ -449,8 +450,6 @@ test("workspaceMembersService.removeMember marks membership revoked and returns
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
-      async lockWorkspaceForInvitations() {},
       async listPendingByWorkspaceIdWithWorkspace() {
         return [];
       },
@@ -504,8 +503,6 @@ test("workspaceMembersService.removeMember rejects removing the owner", async ()
       }
     },
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
-      async lockWorkspaceForInvitations() {},
       async listPendingByWorkspaceIdWithWorkspace() {
         return [];
       },

package/test/workspacePendingInvitationsService.test.js

@@ -16,7 +16,9 @@ function createFixture({
 
   const service = createService({
     workspaceInvitesRepository: {
-      async withTransaction(work) { return work({}); },
+      async withTransaction(work) {
+        return work({});
+      },
       async listPendingByEmail() {
         return Array.isArray(pendingInvitesByEmail) ? [...pendingInvitesByEmail] : [];
       },
@@ -277,7 +279,6 @@ test("refuseInviteByToken revokes the invite and returns refused", async () => {
   assert.equal(response.workspaceId, "1");
 });
 
-
 test("participant registration rejects invalid, duplicate and late registration", async () => {
   const { service } = createFixture();
   assert.throws(() => service.registerAcceptanceParticipant(null), /must be a function/);
@@ -294,8 +295,12 @@ for (const transactionOutcome of ["committed", "unknown", "rolledBack"]) {
     const failure = Object.assign(new Error("Managed completion failed"), { transactionOutcome, cause });
     const service = createService({
       workspaceInvitesRepository: {
-        async findPendingByTokenHash() { return { workspaceId: "1", email: "a@example.test" }; },
-        async withTransaction() { throw failure; }
+        async findPendingByTokenHash() {
+          return { workspaceId: "1", email: "a@example.test" };
+        },
+        async withTransaction() {
+          throw failure;
+        }
       },
       workspaceMembershipsRepository: {}
     });