@jskit-ai/workspaces-core 0.2.4 → 0.2.6

package/src/server/common/contributors/workspaceActionContextContributor.js

@@ -1,4 +1,4 @@
-import { requireServiceMethod } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
+import { resolveRequest } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
 import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 import {
@@ -7,91 +7,81 @@ import {
   ROUTE_VISIBILITY_WORKSPACE,
   ROUTE_VISIBILITY_WORKSPACE_USER
 } from "@jskit-ai/kernel/shared/support/visibility";
-import { resolveActionUser } from "../support/resolveActionUser.js";
+import { resolveActionUser } from "@jskit-ai/users-core/server/resolveActionUser";
+
 const WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET = new Set([
   ROUTE_VISIBILITY_WORKSPACE,
   ROUTE_VISIBILITY_WORKSPACE_USER
 ]);
 
-function normalizeWorkspaceSurfaceIds(surfaceIds = []) {
-  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
-  const normalized = new Set();
-
-  for (const entry of source) {
-    const surfaceId = normalizeSurfaceId(entry);
-    if (!surfaceId) {
-      continue;
-    }
-    normalized.add(surfaceId);
-  }
-
-  return normalized;
-}
-
+/**
+ * @param {object} dependencies
+ * @param {import("../../types.js").WorkspaceDirectoryService} dependencies.workspaceService
+ * @param {string[]} dependencies.workspaceMembershipOptionalSurfaceIds The surfaces' normalized ids.
+ * @param {string[]} dependencies.workspaceSurfaceIds The surfaces' normalized ids.
+ */
 function createWorkspaceActionContextContributor({
   workspaceService,
-  workspaceMembershipOptionalSurfaceIds = [],
-  workspaceSurfaceIds = []
-} = {}) {
+  workspaceMembershipOptionalSurfaceIds,
+  workspaceSurfaceIds
+}) {
   const contributorId = "workspaces.context";
-  const workspaceMembershipOptionalSurfaceIdSet = normalizeWorkspaceSurfaceIds(
-    workspaceMembershipOptionalSurfaceIds
-  );
-  const workspaceSurfaceIdSet = normalizeWorkspaceSurfaceIds(workspaceSurfaceIds);
+  const workspaceMembershipOptionalSurfaceIdSet = new Set(workspaceMembershipOptionalSurfaceIds);
+  const workspaceSurfaceIdSet = new Set(workspaceSurfaceIds);
 
-  requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId);
-
-  return Object.freeze({
-    contributorId,
-    async contribute({ definition = null, input, context } = {}) {
-      const payload = normalizeObject(input);
-      if (!Object.hasOwn(payload, "workspaceSlug")) {
-        return {};
-      }
-
-      const request = context?.requestMeta?.request || null;
-      const actionSurfaces = Array.isArray(definition?.surfaces) ? definition.surfaces : [];
-      const hasWorkspaceActionSurface = actionSurfaces.some((surfaceId) => workspaceSurfaceIdSet.has(surfaceId));
-      const routeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
-      const activeSurfaceId = routeSurfaceId || normalizeSurfaceId(context?.surface);
-      const hasWorkspaceSurface = workspaceSurfaceIdSet.has(routeSurfaceId);
-      const routeVisibilityInput =
-        context?.routeVisibility ?? request?.routeOptions?.config?.visibility ?? ROUTE_VISIBILITY_PUBLIC;
-      const routeVisibility = checkRouteVisibility(routeVisibilityInput);
-      const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
-      if (!hasWorkspaceActionSurface && !hasWorkspaceRouteVisibility && !hasWorkspaceSurface) {
-        return {};
-      }
+  async function contribute({ definition = null, input, context } = {}) {
+    const payload = normalizeObject(input);
+    if (!Object.hasOwn(payload, "workspaceSlug")) {
+      return {};
+    }
 
-      const resolveOptions = { request };
-      if (workspaceMembershipOptionalSurfaceIdSet.has(activeSurfaceId)) {
-        resolveOptions.requireMembership = false;
-      }
+    const request = resolveRequest(context);
+    const actionSurfaces = Array.isArray(definition?.surfaces) ? definition.surfaces : [];
+    const hasWorkspaceActionSurface = actionSurfaces.some((surfaceId) => workspaceSurfaceIdSet.has(surfaceId));
+    const routeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
+    const activeSurfaceId = routeSurfaceId || normalizeSurfaceId(context?.surface);
+    const hasWorkspaceSurface = workspaceSurfaceIdSet.has(routeSurfaceId);
+    const routeVisibilityInput =
+      context?.routeVisibility ?? request?.routeOptions?.config?.visibility ?? ROUTE_VISIBILITY_PUBLIC;
+    const routeVisibility = checkRouteVisibility(routeVisibilityInput);
+    const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
+    if (!hasWorkspaceActionSurface && !hasWorkspaceRouteVisibility && !hasWorkspaceSurface) {
+      return {};
+    }
 
-      const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
-        resolveActionUser(context, payload),
-        payload.workspaceSlug,
-        resolveOptions
-      );
+    const resolveOptions = { request };
+    if (workspaceMembershipOptionalSurfaceIdSet.has(activeSurfaceId)) {
+      resolveOptions.requireMembership = false;
+    }
 
-      const contribution = {
-        requestMeta: {
-          resolvedWorkspaceContext
-        }
-      };
+    const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
+      resolveActionUser(context, payload),
+      payload.workspaceSlug,
+      resolveOptions
+    );
 
-      if (!context?.workspace) {
-        contribution.workspace = resolvedWorkspaceContext.workspace;
-      }
-      if (!context?.membership) {
-        contribution.membership = resolvedWorkspaceContext.membership;
-      }
-      if (!Array.isArray(context?.permissions) || context.permissions.length < 1) {
-        contribution.permissions = resolvedWorkspaceContext.permissions;
+    const contribution = {
+      requestMeta: {
+        resolvedWorkspaceContext
       }
+    };
 
-      return contribution;
+    if (!context?.workspace) {
+      contribution.workspace = resolvedWorkspaceContext.workspace;
+    }
+    if (!context?.membership) {
+      contribution.membership = resolvedWorkspaceContext.membership;
     }
+    if (!Array.isArray(context?.permissions) || context.permissions.length < 1) {
+      contribution.permissions = resolvedWorkspaceContext.permissions;
+    }
+
+    return contribution;
+  }
+
+  return Object.freeze({
+    contributorId,
+    contribute
   });
 }
 

package/src/server/common/contributors/workspaceAuthPolicyContextResolver.js

@@ -1,21 +1,13 @@
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 
-function createWorkspaceAuthPolicyContextResolver({
-  workspaceService,
-  workspaceMembershipOptionalSurfaceIds = []
-} = {}) {
-  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
-    throw new Error(
-      "workspace auth policy context resolver requires workspaceService.resolveWorkspaceContextForUserBySlug()."
-    );
-  }
-
-  const membershipOptionalSurfaceIds = new Set(
-    (Array.isArray(workspaceMembershipOptionalSurfaceIds) ? workspaceMembershipOptionalSurfaceIds : [])
-      .map((entry) => normalizeSurfaceId(entry))
-      .filter(Boolean)
-  );
+/**
+ * @param {object} dependencies
+ * @param {import("../../types.js").WorkspaceDirectoryService} dependencies.workspaceService
+ * @param {string[]} dependencies.workspaceMembershipOptionalSurfaceIds The surfaces' normalized ids.
+ */
+function createWorkspaceAuthPolicyContextResolver({ workspaceService, workspaceMembershipOptionalSurfaceIds }) {
+  const membershipOptionalSurfaceIds = new Set(workspaceMembershipOptionalSurfaceIds);
 
   return async function resolveWorkspaceAuthPolicyContext({ request, actor, meta } = {}) {
     const contextPolicy = normalizeText(meta?.contextPolicy || "none").toLowerCase() || "none";
@@ -29,26 +21,19 @@ function createWorkspaceAuthPolicyContextResolver({
       return {};
     }
 
-    const resolveOptions = { request };
     const activeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
-    if (
+    const requireMembership = !(
       (contextPolicy === "optional" && !permission) ||
       membershipOptionalSurfaceIds.has(activeSurfaceId)
-    ) {
-      resolveOptions.requireMembership = false;
-    }
+    );
 
-    const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
+    const { workspace, membership, permissions } = await workspaceService.resolveWorkspaceContextForUserBySlug(
       actor,
       workspaceSlug,
-      resolveOptions
+      { requireMembership }
     );
 
-    return {
-      workspace: resolvedWorkspaceContext?.workspace || null,
-      membership: resolvedWorkspaceContext?.membership || null,
-      permissions: Array.isArray(resolvedWorkspaceContext?.permissions) ? resolvedWorkspaceContext.permissions : []
-    };
+    return { workspace, membership, permissions };
   };
 }
 

package/src/server/common/contributors/workspaceRouteVisibilityResolver.js

@@ -1,5 +1,6 @@
-import { normalizeOpaqueId, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { resolveActor, resolveActorId } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
 
 function buildVisibilityContribution({ visibility, scopeOwnerId = null, userId = null } = {}) {
   const requiresActorScope = visibility === "workspace_user";
@@ -18,78 +19,62 @@ function buildVisibilityContribution({ visibility, scopeOwnerId = null, userId =
   return contribution;
 }
 
-function createWorkspaceRouteVisibilityResolver({
-  workspaceService,
-  workspaceMembershipOptionalSurfaceIds = []
-} = {}) {
-  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
-    throw new Error("workspace route visibility resolver requires workspaceService.resolveWorkspaceContextForUserBySlug().");
-  }
-
-  const membershipOptionalSurfaceIds = new Set(
-    (Array.isArray(workspaceMembershipOptionalSurfaceIds) ? workspaceMembershipOptionalSurfaceIds : [])
-      .map((entry) => normalizeSurfaceId(entry))
-      .filter(Boolean)
-  );
-
-  return Object.freeze({
-    resolverId: "workspaces.visibility",
-    async resolve({ visibility, context, request, input } = {}) {
-      if (visibility !== "workspace" && visibility !== "workspace_user") {
-        return {};
-      }
-
-      const actor = context?.actor || request?.user || null;
-      const userId = normalizeOpaqueId(actor?.id);
-      const workspace =
-        context?.workspace || context?.requestMeta?.resolvedWorkspaceContext?.workspace || request?.workspace || null;
-      const scopeOwnerId = normalizeRecordId(workspace?.id, { fallback: null });
-      if (!scopeOwnerId) {
-        const workspaceSlug = normalizeText(input?.workspaceSlug).toLowerCase();
+/**
+ * @param {object} dependencies
+ * @param {import("../../types.js").WorkspaceDirectoryService} dependencies.workspaceService
+ * @param {string[]} dependencies.workspaceMembershipOptionalSurfaceIds The surfaces' normalized ids.
+ */
+function createWorkspaceRouteVisibilityResolver({ workspaceService, workspaceMembershipOptionalSurfaceIds }) {
+  const membershipOptionalSurfaceIds = new Set(workspaceMembershipOptionalSurfaceIds);
 
-        if (!workspaceSlug || !actor) {
-          return visibility === "workspace_user"
-            ? buildVisibilityContribution({
-                visibility,
-                userId
-              })
-            : {};
-        }
+  async function resolve({ visibility, context, request, input } = {}) {
+    if (visibility !== "workspace" && visibility !== "workspace_user") {
+      return {};
+    }
 
-        const activeSurfaceId = normalizeSurfaceId(
-          request?.routeOptions?.config?.surface || context?.surface
-        );
-        const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
-          actor,
-          workspaceSlug,
-          {
-            request,
-            ...(membershipOptionalSurfaceIds.has(activeSurfaceId) ? { requireMembership: false } : {})
-          }
-        );
-        const resolvedWorkspaceOwnerId = normalizeRecordId(resolvedWorkspaceContext?.workspace?.id, { fallback: null });
-        if (!resolvedWorkspaceOwnerId) {
-          return visibility === "workspace_user"
-            ? buildVisibilityContribution({
-                visibility,
-                userId
-              })
-            : {};
-        }
+    const actor = resolveActor(context, request);
+    const userId = resolveActorId(context, request);
+    const workspace =
+      context?.workspace || context?.requestMeta?.resolvedWorkspaceContext?.workspace || request?.workspace || null;
+    const scopeOwnerId = normalizeRecordId(workspace?.id, { fallback: null });
+    if (!scopeOwnerId) {
+      const workspaceSlug = normalizeText(input?.workspaceSlug).toLowerCase();
 
-        return buildVisibilityContribution({
-          visibility,
-          scopeOwnerId: resolvedWorkspaceOwnerId,
-          userId
-        });
+      if (!workspaceSlug || !actor) {
+        return visibility === "workspace_user"
+          ? buildVisibilityContribution({
+              visibility,
+              userId
+            })
+          : {};
       }
 
+      const activeSurfaceId = normalizeSurfaceId(
+        request?.routeOptions?.config?.surface || context?.surface
+      );
+      const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
+        actor,
+        workspaceSlug,
+        { requireMembership: !membershipOptionalSurfaceIds.has(activeSurfaceId) }
+      );
+
       return buildVisibilityContribution({
         visibility,
-        scopeOwnerId,
+        scopeOwnerId: normalizeRecordId(resolvedWorkspaceContext.workspace.id),
         userId
       });
     }
+
+    return buildVisibilityContribution({
+      visibility,
+      scopeOwnerId,
+      userId
+    });
+  }
+
+  return Object.freeze({
+    resolverId: "workspaces.visibility",
+    resolve
   });
 }
 

package/src/server/common/formatters/workspaceFormatter.js

@@ -1,6 +1,5 @@
-import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveWorkspaceThemePalettes } from "../../../shared/settings.js";
 
 function mapWorkspaceSummary(workspace, membership, roleCatalog = null) {
   const roleSid = normalizeLowerText(membership?.roleSid || "member") || "member";
@@ -16,11 +15,14 @@ function mapWorkspaceSummary(workspace, membership, roleCatalog = null) {
   };
 }
 
-function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEnabled = true } = {}) {
-  const source = workspaceSettings && typeof workspaceSettings === "object" ? workspaceSettings : {};
-  const invitesAvailable = workspaceInvitationsEnabled === true;
-  const invitesEnabled = invitesAvailable && source.invitesEnabled !== false;
-  const themePalettes = resolveWorkspaceThemePalettes(source);
+/**
+ * A workspace's settings as the bootstrap shows them.
+ * @param {object} workspaceSettings The workspace's settings record.
+ * @param {{ workspaceInvitationsEnabled: boolean }} policy Whether the app allows invitations.
+ */
+function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEnabled }) {
+  const invitesEnabled = workspaceInvitationsEnabled && workspaceSettings.invitesEnabled !== false;
+  const themePalettes = resolveWorkspaceThemePalettes(workspaceSettings);
 
   return {
     lightPrimaryColor: themePalettes.light.color,
@@ -32,8 +34,8 @@ function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEna
     darkSurfaceColor: themePalettes.dark.surfaceColor,
     darkSurfaceVariantColor: themePalettes.dark.surfaceVariantColor,
     invitesEnabled,
-    invitesAvailable,
-    invitesEffective: invitesAvailable && invitesEnabled
+    invitesAvailable: workspaceInvitationsEnabled,
+    invitesEffective: invitesEnabled
   };
 }
 

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

@@ -1,13 +1,13 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import {
-  normalizeLowerText,
-  normalizeRecordId,
+  isLostDuplicateInsertRace,
+  joinOrOpenTransaction,
   normalizeDbRecordId,
-  normalizeText,
-  isDuplicateEntryError,
-  toIsoString,
-  retryDeadlocks
-} from "./repositoryUtils.js";
+  resolveTransaction,
+  retryDeadlocks,
+  toIsoString
+} from "@jskit-ai/database-runtime/shared";
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createJsonRestContext,
   extractJsonRestCollectionRows
@@ -71,21 +71,19 @@ function normalizeInviteWithWorkspace(payload = {}) {
 
   return {
     ...invite,
-    workspaceSlug: payload?.workspace?.slug ? normalizeText(payload.workspace.slug) : undefined,
-    workspaceName: payload?.workspace?.name ? normalizeText(payload.workspace.name) : undefined,
-    workspaceAvatarUrl: payload?.workspace?.avatarUrl ? normalizeText(payload.workspace.avatarUrl) : undefined
+    workspaceSlug: payload.workspace?.slug ? normalizeText(payload.workspace.slug) : undefined,
+    workspaceName: payload.workspace?.name ? normalizeText(payload.workspace.name) : undefined,
+    workspaceAvatarUrl: payload.workspace?.avatarUrl ? normalizeText(payload.workspace.avatarUrl) : undefined
   };
 }
 
-function createRepository({ api } = {}) {
-  if (!api?.resources?.workspaceInvites) {
-    throw new TypeError("workspaceInvitesRepository requires json-rest-api workspaceInvites resource.");
-  }
-
+/** @param {{ api: import("@jskit-ai/json-rest-api-core/server/types").RuntimeJsonRestApi }} dependencies */
+function createRepository({ api }) {
   const withTransaction = (work) => retryDeadlocks(() => api.transaction(work));
 
   async function queryInvites(filters = {}, options = {}, { includeWorkspace = false } = {}) {
     if (options.lock === true) {
+      // readable-check: allow method-probe - platform object: a Knex transaction, which a locking read needs and options may omit
       if (typeof options.trx !== "function" || includeWorkspace) {
         throw new TypeError("Locking invites requires a transaction and no relationship includes.");
       }
@@ -104,6 +102,7 @@ function createRepository({ api } = {}) {
         return [fields[key], value];
       }));
       // Read PostgreSQL's UTC timestamps as text to avoid the driver's local-time conversion.
+      // readable-check: allow method-probe - platform object: a Knex transaction, whose client config names its dialect
       const dateColumn = (name) => options.trx.client?.config?.client === "pg"
         ? options.trx.raw("CAST(?? AS TEXT)", [name])
         : name;
@@ -129,16 +128,17 @@ function createRepository({ api } = {}) {
             filters,
             ...(includeWorkspace ? { include: ["workspace"] } : {})
           },
-          transaction: options?.trx || null,
+          transaction: resolveTransaction(options),
           format: "plain"
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       )
     );
   }
 
   async function lockWorkspaceForInvitations(workspaceId, options = {}) {
-    if (typeof options.trx !== "function" || options.trx.isCompleted?.()) {
+    // readable-check: allow method-probe - platform object: a Knex transaction, which the workspace lock needs and options may omit
+    if (typeof options.trx !== "function" || options.trx.isCompleted()) {
       throw new TypeError("Invitation locking requires an active transaction.");
     }
     const id = normalizeRecordId(workspaceId, { fallback: null });
@@ -227,7 +227,7 @@ function createRepository({ api } = {}) {
       .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
   }
 
-  async function insert(payload = {}, options = {}) {
+  async function insert(payload, options = {}) {
     const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
     const workspaceId = normalizeRecordId(source.workspaceId, { fallback: null });
     if (!workspaceId) {
@@ -262,14 +262,14 @@ function createRepository({ api } = {}) {
           },
           format: "plain",
           returning: "full",
-          transaction: options?.trx || null
+          transaction: resolveTransaction(options)
         },
-        createJsonRestContext(options?.context || null)
+        createJsonRestContext(options.context)
       );
 
       return normalizeInviteRecord(created);
     } catch (error) {
-      if (options?.trx || error?.transactionOutcome !== "rolledBack" || !isDuplicateEntryError(error)) {
+      if (!isLostDuplicateInsertRace(error, options)) {
         throw error;
       }
     }
@@ -293,38 +293,38 @@ function createRepository({ api } = {}) {
       return;
     }
 
-    if (!options.trx) {
-      return withTransaction((trx) => expirePendingByWorkspaceIdAndEmail(workspaceId, email, { ...options, trx }));
-    }
-    await lockWorkspaceForInvitations(normalizedWorkspaceId, options);
-    const patch = normalizeInvitePatchPayload({ status: "expired" });
-    const rows = await queryInvites(
-      {
-        workspace: normalizedWorkspaceId,
-        email: normalizeLowerText(email),
-        status: "pending"
-      },
-      { ...options, lock: true }
-    );
-
-    for (const row of rows) {
-      if (!row?.id) {
-        continue;
-      }
-      await api.resources.workspaceInvites.patch(
+    await joinOrOpenTransaction(options, withTransaction, async (trx) => {
+      const transactionOptions = { ...options, trx };
+      await lockWorkspaceForInvitations(normalizedWorkspaceId, transactionOptions);
+      const patch = normalizeInvitePatchPayload({ status: "expired" });
+      const rows = await queryInvites(
         {
-          id: row.id,
-          data: {
-            status: patch.status,
-            updatedAt: new Date().toISOString()
-          },
-          format: "plain",
-          returning: "full",
-          transaction: options?.trx || null
+          workspace: normalizedWorkspaceId,
+          email: normalizeLowerText(email),
+          status: "pending"
         },
-        createJsonRestContext(options?.context || null)
+        { ...transactionOptions, lock: true }
       );
-    }
+
+      for (const row of rows) {
+        if (!row?.id) {
+          continue;
+        }
+        await api.resources.workspaceInvites.patch(
+          {
+            id: row.id,
+            data: {
+              status: patch.status,
+              updatedAt: new Date().toISOString()
+            },
+            format: "plain",
+            returning: "full",
+            transaction: trx
+          },
+          createJsonRestContext(options.context)
+        );
+      }
+    });
   }
 
   async function transitionPendingById(inviteId, status, options = {}) {
@@ -342,30 +342,29 @@ function createRepository({ api } = {}) {
       }
       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.", {
-        code: "workspaces.invite.invitationNotFoundOrHandled"
-      });
-    }
-    const updatedAt = new Date().toISOString();
-    await api.resources.workspaceInvites.patch(
-      {
-        id,
-        data: {
-          status,
-          [status === "accepted" ? "acceptedAt" : "revokedAt"]: updatedAt,
-          updatedAt
+    await joinOrOpenTransaction(options, withTransaction, async (trx) => {
+      const invite = await findPendingByIdForWorkspace(id, workspaceId, { ...options, trx, workspaceId, lock: true });
+      if (!invite) {
+        throw new AppError(404, "Invitation not found or already handled.", {
+          code: "workspaces.invite.invitationNotFoundOrHandled"
+        });
+      }
+      const updatedAt = new Date().toISOString();
+      await api.resources.workspaceInvites.patch(
+        {
+          id,
+          data: {
+            status,
+            [status === "accepted" ? "acceptedAt" : "revokedAt"]: updatedAt,
+            updatedAt
+          },
+          format: "plain",
+          returning: "full",
+          transaction: trx
         },
-        format: "plain",
-        returning: "full",
-        transaction: options.trx
-      },
-      createJsonRestContext(options.context || null)
-    );
+        createJsonRestContext(options.context)
+      );
+    });
   }
 
   async function markAcceptedById(inviteId, options = {}) {