@jskit-ai/workspaces-core 0.2.4 → 0.2.5

package/src/server/workspacesRuntime.js

@@ -0,0 +1,185 @@
+import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
+import {
+  addResourceIfMissing,
+  createJsonRestResourceScopeOptions
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { workspaceInvitesResource } from "../shared/resources/workspaceInvitesResource.js";
+import { workspaceMembershipsResource } from "../shared/resources/workspaceMembershipsResource.js";
+import { workspaceResource } from "../shared/resources/workspaceResource.js";
+import { workspaceSettingsResource } from "../shared/resources/workspaceSettingsResource.js";
+import { createWorkspaceRoleCatalog } from "../shared/roles.js";
+import { WORKSPACE_SETTINGS_COLOR_FIELDS, normalizeWorkspaceHexColor } from "../shared/settings.js";
+import { resolveTenancyProfile } from "../shared/tenancyProfile.js";
+import { createRepository as createWorkspaceInvitesRepository } from "./common/repositories/workspaceInvitesRepository.js";
+import { createRepository as createWorkspaceMembershipsRepository } from "./common/repositories/workspaceMembershipsRepository.js";
+import { createRepository as createWorkspacesRepository } from "./common/repositories/workspacesRepository.js";
+import { createService as createWorkspaceService } from "./common/services/workspaceDirectoryService.js";
+import { createWorkspacesServerI18n } from "./i18n.js";
+import { createWorkspaceInviteUrlBuilder } from "./workspaceMembers/workspaceInviteUrls.js";
+import { createService as createWorkspaceMembersService } from "./workspaceMembers/workspaceMembersService.js";
+import { createService as createWorkspacePendingInvitationsService } from "./workspacePendingInvitations/workspacePendingInvitationsService.js";
+import { createRepository as createWorkspaceSettingsRepository } from "./workspaceSettings/workspaceSettingsRepository.js";
+import { createService as createWorkspaceSettingsService } from "./workspaceSettings/workspaceSettingsService.js";
+import { resolveWorkspaceInvitationsPolicy } from "./support/workspaceInvitationsPolicy.js";
+import { workspaceSlugParamsValidator } from "./common/validators/routeParamsValidator.js";
+import { buildWorkspaceInputFromRouteParams } from "./support/workspaceRouteInput.js";
+import { resolveWorkspace } from "./support/resolveWorkspace.js";
+
+function requirePositiveInteger(value, label) {
+  const normalized = Number(value);
+  if (!Number.isInteger(normalized) || normalized < 1) {
+    throw new TypeError(`${label} must be a positive integer.`);
+  }
+  return normalized;
+}
+
+function requireBoolean(value, label) {
+  if (typeof value !== "boolean") {
+    throw new TypeError(`${label} must be boolean.`);
+  }
+  return value;
+}
+
+function requireWorkspaceColorDefaults(defaults) {
+  const colors = {};
+  for (const fieldName of WORKSPACE_SETTINGS_COLOR_FIELDS) {
+    if (defaults?.[fieldName] === undefined) {
+      continue;
+    }
+    const color = normalizeWorkspaceHexColor(defaults[fieldName]);
+    if (!color) {
+      throw new TypeError(`runtime.config.workspaceSettings.defaults.${fieldName} must be a hex color like #1867C0.`);
+    }
+    colors[fieldName] = color;
+  }
+  return colors;
+}
+
+/** @param {import("@jskit-ai/json-rest-api-core/server/types").RuntimeJsonRestApi} jsonRestApi */
+async function installWorkspaceResources(jsonRestApi) {
+  const scopeOptions = { writeSerializers: { "datetime-utc": toDatabaseDateTimeUtc } };
+  await addResourceIfMissing(
+    jsonRestApi,
+    "workspaces",
+    createJsonRestResourceScopeOptions(workspaceResource, scopeOptions)
+  );
+  await addResourceIfMissing(
+    jsonRestApi,
+    "workspaceMemberships",
+    createJsonRestResourceScopeOptions(workspaceMembershipsResource, scopeOptions)
+  );
+  await addResourceIfMissing(
+    jsonRestApi,
+    "workspaceInvites",
+    createJsonRestResourceScopeOptions(workspaceInvitesResource, scopeOptions)
+  );
+  await addResourceIfMissing(
+    jsonRestApi,
+    "workspaceSettings",
+    createJsonRestResourceScopeOptions(workspaceSettingsResource, scopeOptions)
+  );
+}
+
+/**
+ * The `workspaces.core` capability: the workspace repositories and services,
+ * built from the runtime config.
+ * @param {object} dependencies
+ * @param {import("@jskit-ai/kernel/server/types").RuntimeAppRoot} dependencies.appRoot
+ * @param {import("@jskit-ai/kernel/server/types").RuntimeConfig} dependencies.config
+ * @param {import("@jskit-ai/kernel/server/types").RuntimeEnv} dependencies.env
+ * @param {import("./types.js").WorkspaceInviteMailer} dependencies.inviteMailer
+ * @param {import("./types.js").WorkspaceInviteEmailTemplate} dependencies.inviteEmailTemplate
+ * @param {import("./types.js").WorkspaceInviteAcceptanceParticipant} dependencies.inviteAcceptanceParticipant
+ * @param {import("./types.js").PersonalWorkspaceName} dependencies.personalWorkspaceName
+ * @param {import("@jskit-ai/json-rest-api-core/server/types").RuntimeJsonRestApi} dependencies.jsonRestApi
+ * @param {import("@jskit-ai/users-core/server/types").UsersCore} dependencies.users
+ */
+function createWorkspacesRuntime({
+  appRoot,
+  config,
+  env,
+  inviteMailer,
+  inviteEmailTemplate,
+  inviteAcceptanceParticipant,
+  personalWorkspaceName,
+  jsonRestApi,
+  users
+}) {
+  const tenancyProfile = resolveTenancyProfile(config);
+  const invitationsPolicy = resolveWorkspaceInvitationsPolicy({ appConfig: config, tenancyProfile });
+  const invitationsEnabled = invitationsPolicy.enabled === true;
+  const roleCatalog = createWorkspaceRoleCatalog(config);
+  const workspaceSettingsRepository = createWorkspaceSettingsRepository({
+    api: jsonRestApi,
+    defaultInvitesEnabled: requireBoolean(
+      config?.workspaceSettings?.defaults?.invitesEnabled,
+      "runtime.config.workspaceSettings.defaults.invitesEnabled"
+    ),
+    defaultColorSettings: requireWorkspaceColorDefaults(config?.workspaceSettings?.defaults)
+  });
+  const workspacesRepository = createWorkspacesRepository({ api: jsonRestApi });
+  const workspaceMembershipsRepository = createWorkspaceMembershipsRepository({ api: jsonRestApi });
+  const workspaceInvitesRepository = createWorkspaceInvitesRepository({ api: jsonRestApi });
+  const workspaceService = createWorkspaceService({
+    tenancyProfile,
+    roleCatalog,
+    personalWorkspaceName,
+    workspacesRepository,
+    workspaceMembershipsRepository,
+    workspaceSettingsRepository
+  });
+  const workspacePendingInvitationsService = createWorkspacePendingInvitationsService({
+    workspaceInvitesRepository,
+    workspaceMembershipsRepository,
+    roleCatalog,
+    acceptanceParticipant: inviteAcceptanceParticipant
+  });
+  const workspaceMembersService = createWorkspaceMembersService({
+    workspaceMembershipsRepository,
+    workspaceInvitesRepository,
+    inviteExpiresInMs: requirePositiveInteger(
+      config?.workspaceMembers?.defaults?.inviteExpiresInMs,
+      "runtime.config.workspaceMembers.defaults.inviteExpiresInMs"
+    ),
+    roleCatalog,
+    workspaceInvitationsEnabled: invitationsEnabled,
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: config, env }),
+    workspaceInviteMailer: inviteMailer,
+    workspaceInviteEmailTemplate: inviteEmailTemplate,
+    i18n: createWorkspacesServerI18n({ appRoot }),
+    userProfilesRepository: users.repositories.userProfiles,
+    userSettingsRepository: users.repositories.userSettings
+  });
+  const workspaceSettingsService = createWorkspaceSettingsService({
+    workspaceSettingsRepository,
+    workspaceInvitationsEnabled: invitationsEnabled,
+    roleCatalog
+  });
+
+  return Object.freeze({
+    enabled: tenancyProfile.workspace.enabled === true,
+    invitationsEnabled,
+    selfCreateEnabled: tenancyProfile.workspace.allowSelfCreate === true,
+    // The workspace route support the assistant runtime reads.
+    scope: Object.freeze({
+      params: workspaceSlugParamsValidator,
+      buildInputFromRouteParams: buildWorkspaceInputFromRouteParams,
+      resolveWorkspace
+    }),
+    tenancyProfile,
+    repositories: Object.freeze({
+      workspaceInvites: workspaceInvitesRepository,
+      workspaceMemberships: workspaceMembershipsRepository,
+      workspaceSettings: workspaceSettingsRepository,
+      workspaces: workspacesRepository
+    }),
+    services: Object.freeze({
+      directory: workspaceService,
+      members: workspaceMembersService,
+      pendingInvitations: workspacePendingInvitationsService,
+      settings: workspaceSettingsService
+    })
+  });
+}
+
+export { createWorkspacesRuntime, installWorkspaceResources };

package/src/shared/operationMessages.js

@@ -1,16 +1,7 @@
-function createOperationMessages({
-  validationMessage = "Validation failed.",
-  apiValidationMessage = validationMessage
-} = {}) {
-  const validation = String(validationMessage || "Validation failed.");
-  const apiValidation = String(apiValidationMessage || validation || "Validation failed.");
+/** The messages a resource's operations show when their input fails validation. */
+const OPERATION_MESSAGES = Object.freeze({
+  validation: "Validation failed.",
+  apiValidation: "Validation failed."
+});
 
-  return Object.freeze({
-    validation,
-    apiValidation
-  });
-}
-
-export {
-  createOperationMessages
-};
+export { OPERATION_MESSAGES };

package/src/shared/resources/workspaceMembersResource.js

@@ -1,7 +1,7 @@
 import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
 import { createSchema } from "json-rest-schema";
 import { defineResource } from "@jskit-ai/resource-core/shared/resource";
-import { createOperationMessages } from "../operationMessages.js";
+import { OPERATION_MESSAGES } from "../operationMessages.js";
 import { workspaceRoleCatalogSchema } from "./workspaceRoleCatalogSchema.js";
 
 const workspaceSummaryOutputSchema = createSchema({
@@ -206,7 +206,7 @@ const redeemInviteOutputSchema = createSchema({
 
 const workspaceMembersResource = defineResource({
   namespace: "workspaceMembers",
-  messages: createOperationMessages(),
+  messages: OPERATION_MESSAGES,
   operations: {
     rolesList: {
       method: "GET",

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -1,7 +1,7 @@
 import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
 import { createSchema } from "json-rest-schema";
 import { defineResource } from "@jskit-ai/resource-core/shared/resource";
-import { createOperationMessages } from "../operationMessages.js";
+import { OPERATION_MESSAGES } from "../operationMessages.js";
 
 const invitationTokenQuerySchema = createSchema({
   token: {
@@ -64,7 +64,7 @@ const pendingInvitationsListOutputSchema = createSchema({
 
 const workspacePendingInvitationsResource = defineResource({
   namespace: "workspacePendingInvitations",
-  messages: createOperationMessages(),
+  messages: OPERATION_MESSAGES,
   operations: {
     resolve: {
       method: "GET",

package/src/shared/resources/workspaceResource.js

@@ -56,6 +56,9 @@ const workspacePatchBodySchema = createSchema({
   }
 });
 
+// The fields a workspace patch may change.
+const WORKSPACE_PATCH_FIELD_KEYS = Object.freeze(["name", "avatarUrl"]);
+
 const workspaceListItemOutputValidator = createSchemaDefinition(workspaceListItemSchema, "replace");
 
 const resource = defineCrudResource({
@@ -146,4 +149,4 @@ const resource = defineCrudResource({
 });
 
 export { resource as workspaceResource };
-export { workspaceListItemOutputValidator };
+export { WORKSPACE_PATCH_FIELD_KEYS, workspaceListItemOutputValidator };

package/src/shared/roles.js

@@ -65,11 +65,11 @@ function listConfiguredRoleIds(appConfig = {}) {
 }
 
 function resolveConfiguredDefaultInviteRole(appConfig = {}) {
-  return normalizeRoleId(appConfig?.roleCatalog?.workspace?.defaultInviteRole);
+  return normalizeRoleId(appConfig.roleCatalog?.workspace?.defaultInviteRole);
 }
 
 function normalizeConfiguredRoles(appConfig = {}) {
-  const roleCatalog = asRecord(appConfig?.roleCatalog);
+  const roleCatalog = asRecord(appConfig.roleCatalog);
   const configuredRoles = asRecord(roleCatalog.roles);
   const normalizedRoles = {};
 
@@ -139,19 +139,21 @@ function listRoleDescriptors(appConfig = {}) {
   }));
 }
 
-function resolveRolePermissions(roleSid, appConfig = {}) {
+/**
+ * The permissions of one role in a built role catalog; none for an unknown role.
+ * @param {import("../server/types.js").WorkspaceRoleCatalog} roleCatalog
+ * @param {unknown} roleSid
+ * @returns {string[]}
+ */
+function listCatalogRolePermissions(roleCatalog, roleSid) {
   const normalizedRoleId = normalizeRoleId(roleSid);
-  if (!normalizedRoleId) {
-    return [];
-  }
-
-  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
   const role = roleCatalog.roles.find((entry) => entry.id === normalizedRoleId);
-  if (!role) {
-    return [];
-  }
+  return role ? [...role.permissions] : [];
+}
 
-  return [...role.permissions];
+/** The permissions of one role in the app's configured role catalog. */
+function resolveRolePermissions(roleSid, appConfig = {}) {
+  return listCatalogRolePermissions(createWorkspaceRoleCatalog(appConfig), roleSid);
 }
 
 export {
@@ -159,6 +161,7 @@ export {
   ADMIN_ROLE_ID,
   MEMBER_ROLE_ID,
   resolveRolePermissions,
+  listCatalogRolePermissions,
   listRoleDescriptors,
   createWorkspaceRoleCatalog,
   cloneWorkspaceRoleCatalog,

package/src/shared/tenancyProfile.js

@@ -11,7 +11,7 @@ const WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME = "immutable_username";
 const WORKSPACE_SLUG_POLICY_USER_SELECTED = "user_selected";
 
 function resolveWorkspacePolicyOverrides(appConfig = {}) {
-  const tenancyPolicy = isRecord(appConfig?.tenancyPolicy) ? appConfig.tenancyPolicy : {};
+  const tenancyPolicy = isRecord(appConfig.tenancyPolicy) ? appConfig.tenancyPolicy : {};
   const workspacePolicy = isRecord(tenancyPolicy.workspace) ? tenancyPolicy.workspace : {};
 
   return Object.freeze({
@@ -48,7 +48,7 @@ function resolveWorkspacePolicy(mode, overrides = {}) {
 }
 
 function resolveTenancyProfile(appConfig = {}) {
-  const mode = normalizeTenancyMode(appConfig?.tenancyMode);
+  const mode = normalizeTenancyMode(appConfig.tenancyMode);
   const workspacePolicyOverrides = resolveWorkspacePolicyOverrides(appConfig);
 
   return Object.freeze({

package/test/exportsContract.test.js

@@ -18,8 +18,13 @@ test("workspaces-core exports are explicit and aligned with production usage", (
       "./server/WorkspacesIntegrationsProvider",
       "./server/validators/routeParamsValidator",
       "./server/support/workspaceRouteInput",
+      // Workspace CRUD features take their scope, workspace id and route paths from these.
+      "./server/support/workspaceCrud",
+      "./server/support/workspaceRoutePaths",
       "./shared/resources/workspaceResource",
       "./shared/resources/workspaceSettingsResource",
+      // Features that require this package's capabilities take their types from it.
+      "./server/types",
       // The generated client bootstrap registers it so clients render these server codes.
       "./locales/en.json"
     ]

package/test/featureRuntime.test.js

@@ -1,9 +1,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createAuthExtensions } from "@jskit-ai/auth-core/server/authExtensions";
-import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { ActionProvider } from "@jskit-ai/kernel/server/actions";
+import { silentLogger } from "@jskit-ai/kernel/server/runtime/logger";
 import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import { createBootstrapRuntime } from "@jskit-ai/kernel/server/runtime";
+import { createBootstrapRuntime, EventProvider } from "@jskit-ai/kernel/server/runtime";
 import { createUsersExtensions } from "@jskit-ai/users-core/server/usersExtensions";
 import { WorkspacesFeature, createWorkspacesRuntime } from "../src/server/WorkspacesFeature.js";
 import { WorkspacesIntegrationsProvider } from "../src/server/WorkspacesIntegrationsProvider.js";
@@ -66,12 +67,12 @@ test("WorkspacesFeature assembles workspace behavior and explicit integrations",
     setup({ actions, workspaceCapability }) {
       actionCatalogue = actions;
       workspaces = workspaceCapability;
-      workspaceCapability.services.pendingInvitations.registerAcceptanceParticipant(async () => {});
       return {};
     }
   });
   const runtime = createCapabilityRuntime({
     inputs: {
+      "runtime.logger": silentLogger,
       "auth.extensions": authExtensions,
       "runtime.app-root": process.cwd(),
       "runtime.bootstrap": bootstrap,
@@ -100,7 +101,7 @@ test("WorkspacesFeature assembles workspace behavior and explicit integrations",
       },
       "users.extensions": usersExtensions
     },
-    providers: [createActionProvider(), WorkspacesFeature, WorkspacesIntegrationsProvider, probe]
+    providers: [EventProvider, ActionProvider, WorkspacesFeature, WorkspacesIntegrationsProvider, probe]
   });
 
   await runtime.start();
@@ -114,8 +115,6 @@ test("WorkspacesFeature assembles workspace behavior and explicit integrations",
   assert.equal(typeof workspaces.services.directory.resolveWorkspaceContextForUserBySlug, "function");
   assert.equal(typeof workspaces.services.members.prepareInvite, "function");
   assert.equal(typeof workspaces.services.members.sendInvite, "function");
-  assert.throws(() => workspaces.services.pendingInvitations.registerAcceptanceParticipant(null), /must be a function/);
-  assert.throws(() => workspaces.services.pendingInvitations.registerAcceptanceParticipant(async () => {}), /already registered/);
   assert.equal(routes.includes("POST /api/workspaces"), true);
   assert.equal(routes.includes("GET /api/workspace/invitations/resolve"), true);
   assert.equal(actionCatalogue.listDefinitions().length, 16);

package/test/packageMetadata.test.js

@@ -57,3 +57,15 @@ test("workspaces-core publishes an app-owned editable workspace invite email pat
   assert.match(source, /inviteUrl/);
   assert.deepEqual(packageMetadata.migrations, { directories: ["migrations"] });
 });
+
+test("workspaces-core's pattern provides the invite email and mailer from one application feature", async () => {
+  const source = await readFile(
+    path.join(PACKAGE_DIR, "patterns", "workspace-server", "example", "packages", "main", "src", "server", "WorkspaceInvitationsFeature.js"),
+    "utf8"
+  );
+
+  assert.match(source, /inviteEmailTemplate: "workspaces\.invite-email-template"/);
+  assert.match(source, /inviteMailer: "workspaces\.invite-mailer"/);
+  assert.match(source, /inviteEmailTemplate: renderWorkspaceInviteEmail/);
+  assert.match(source, /inviteMailer: createWorkspaceInviteMailer\(\{ env \}\)/);
+});

package/test/repositories.integration.test.js

@@ -113,7 +113,7 @@ describe(`users and workspaces repositories on migrated ${databaseLabel}`, () =>
     workspaces = createWorkspacesRepository({ api });
     memberships = createMembershipsRepository({ api });
     invites = createInvitesRepository({ api });
-    settings = createSettingsRepository({ api });
+    settings = createSettingsRepository({ api, defaultInvitesEnabled: false, defaultColorSettings: {} });
   });
 
   beforeEach(async () => {

package/test/requestedWorkspaceScope.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { BOOTSTRAP_PATH } from "@jskit-ai/kernel/shared/surface/paths";
+import { requestedWorkspaceScope } from "../src/server/support/workspaceRouteInput.js";
+
+test("requestedWorkspaceScope reads the route's workspace slug", () => {
+  const request = {
+    params: { workspaceSlug: " Acme " },
+    query: { workspaceSlug: "other" },
+    routeOptions: { url: "/api/w/:workspaceSlug/contacts" }
+  };
+
+  assert.deepEqual(requestedWorkspaceScope(request), { workspaceSlug: "acme" });
+});
+
+test("requestedWorkspaceScope reads the bootstrap request's workspace query, and no other route's", () => {
+  assert.equal(BOOTSTRAP_PATH, "/api/bootstrap");
+  assert.deepEqual(requestedWorkspaceScope({ params: {}, query: { workspaceSlug: "Acme" }, routeOptions: { url: BOOTSTRAP_PATH } }), {
+    workspaceSlug: "acme"
+  });
+  assert.deepEqual(requestedWorkspaceScope({ params: {}, query: { workspaceSlug: "acme" }, routeOptions: { url: "/api/session" } }), {});
+  assert.deepEqual(requestedWorkspaceScope({ routeOptions: { url: BOOTSTRAP_PATH } }), {});
+  assert.deepEqual(requestedWorkspaceScope({}), {});
+});

package/test/roleLabels.test.js

@@ -7,9 +7,13 @@ import { workspaceMembersResource } from "../src/shared/resources/workspaceMembe
 import { workspaceSettingsResource, WORKSPACE_SETTINGS_FIELD_KEYS } from "../src/shared/resources/workspaceSettingsResource.js";
 import { workspacePendingInvitationsResource } from "../src/shared/resources/workspacePendingInvitationsResource.js";
 import { createService as createMembersService } from "../src/server/workspaceMembers/workspaceMembersService.js";
+import { createWorkspacesServerI18n } from "../src/server/i18n.js";
+import { noInviteAcceptanceParticipant } from "../src/server/workspacePendingInvitations/noInviteAcceptanceParticipant.js";
 import { createService as createSettingsService } from "../src/server/workspaceSettings/workspaceSettingsService.js";
 import { createService as createPendingService } from "../src/server/workspacePendingInvitations/workspacePendingInvitationsService.js";
 import { renderDefaultWorkspaceInviteEmail } from "../src/server/workspaceMembers/defaultWorkspaceInviteEmail.js";
+import { createWorkspaceInviteUrlBuilder } from "../src/server/workspaceMembers/workspaceInviteUrls.js";
+import { unconfiguredWorkspaceInviteMailer } from "../src/server/workspaceMembers/unconfiguredWorkspaceInviteMailer.js";
 
 const config = {
   roleCatalog: {
@@ -59,6 +63,8 @@ test("missing, whitespace and non-string labels retain the original descriptor s
 test("Members and Invitations response validation preserves labels and saved role IDs", async () => {
   let savedRole = "worker";
   const service = createMembersService({
+    workspaceInvitationsEnabled: true,
+    i18n: createWorkspacesServerI18n(),
     roleCatalog: catalog,
     inviteExpiresInMs: 60_000,
     workspaceMembershipsRepository: {
@@ -68,7 +74,10 @@ test("Members and Invitations response validation preserves labels and saved rol
       async findByWorkspaceIdAndUserId() { return { userId: "11", roleSid: savedRole, status: "active" }; },
       async upsertMembership(_workspaceId, _userId, patch) { savedRole = patch.roleSid; }
     },
-    workspaceInvitesRepository: { async listPendingByWorkspaceIdWithWorkspace() { return []; } }
+    workspaceInvitesRepository: { async listPendingByWorkspaceIdWithWorkspace() { return []; } },
+    inviteUrlBuilder: createWorkspaceInviteUrlBuilder({ appConfig: {}, env: {} }),
+    workspaceInviteMailer: unconfiguredWorkspaceInviteMailer,
+    workspaceInviteEmailTemplate: renderDefaultWorkspaceInviteEmail
   });
   for (const roleSid of ["worker", "safety_manager", "administrator", "training_assessor"]) {
     await service.updateMemberRole(workspace, { memberUserId: "11", roleSid });
@@ -79,7 +88,7 @@ test("Members and Invitations response validation preserves labels and saved rol
   }
   const roles = output(workspaceMembersResource, "rolesList", await service.listRoles());
   assert.deepEqual(roles.roles.map((role) => role.label), expectedLabels);
-  const invites = output(workspaceMembersResource, "invitesList", await service.listInvites(workspace));
+  const invites = output(workspaceMembersResource, "invitesList", (await service.listInvitesResponse(workspace)).value);
   assert.deepEqual(invites.roleCatalog.roles.map((role) => role.label), expectedLabels);
   await assert.rejects(service.updateMemberRole(workspace, { memberUserId: "11", roleSid: "Controller" }), /Validation failed/);
   await assert.rejects(service.updateMemberRole(workspace, { memberUserId: "11", roleSid: "owner" }), /Validation failed/);
@@ -87,6 +96,7 @@ test("Members and Invitations response validation preserves labels and saved rol
 
 test("Workspace Settings response validation preserves configured labels", async () => {
   const service = createSettingsService({
+    workspaceInvitationsEnabled: true,
     roleCatalog: catalog,
     workspaceSettingsRepository: {
       async ensureForWorkspaceId() {
@@ -94,9 +104,9 @@ test("Workspace Settings response validation preserves configured labels", async
       }
     }
   });
-  const response = output(workspaceSettingsResource, "view", await service.getWorkspaceSettings(workspace, {
+  const response = output(workspaceSettingsResource, "view", (await service.getWorkspaceSettings(workspace, {
     context: { actor: { id: "9" }, permissions: ["workspace.settings.view"] }
-  }));
+  })).value);
   assert.deepEqual(response.roleCatalog.roles.map((role) => role.label), expectedLabels);
 });
 
@@ -106,6 +116,7 @@ test("pending and resolved invitation responses derive labels while acceptance s
   const invite = { id: "10", workspaceId: "7", workspaceSlug: "example", workspaceName: "Example", roleSid: "safety_manager", status: "pending", email: "person@example.com", expiresAt: "2099-01-01T00:00:00.000Z", tokenHash };
   let membership;
   const service = createPendingService({
+    acceptanceParticipant: noInviteAcceptanceParticipant,
     roleCatalog: catalog,
     workspaceInvitesRepository: {
       async listPendingByEmail() { return [invite]; },
@@ -118,7 +129,7 @@ test("pending and resolved invitation responses derive labels while acceptance s
   });
   const user = { id: "11", email: invite.email };
   const pending = output(workspacePendingInvitationsResource, "list", { pendingInvites: await service.listPendingInvitesForUser(user) });
-  const resolved = output(workspacePendingInvitationsResource, "resolve", await service.resolveInviteByToken(token));
+  const resolved = output(workspacePendingInvitationsResource, "resolve", (await service.resolveInviteByToken(token)).value);
   assert.equal(pending.pendingInvites[0].roleLabel, "Operator");
   assert.equal(resolved.roleLabel, "Operator");
   assert.equal(resolved.roleSid, "safety_manager");
@@ -128,8 +139,19 @@ test("pending and resolved invitation responses derive labels while acceptance s
 });
 
 test("default invitation email uses the configured label with HTML escaping and the original fallback", () => {
-  const labelled = renderDefaultWorkspaceInviteEmail({ roleSid: "worker", roleLabel: " Member <team> " });
+  const i18n = createWorkspacesServerI18n();
+  const input = {
+    email: "reader@example.test",
+    inviteUrl: "/invite/abc",
+    workspace: { name: "Acme", slug: "acme" },
+    inviter: null,
+    roleSid: "worker",
+    expiresAt: "2026-11-02T00:00:00.000Z",
+    locale: "en",
+    t: (key, params) => i18n.t("en", key, params)
+  };
+  const labelled = renderDefaultWorkspaceInviteEmail({ ...input, roleLabel: "Member <team>" });
   assert.match(labelled.text, /as Member <team>/u);
   assert.match(labelled.html, /as Member &lt;team&gt;/u);
-  assert.match(renderDefaultWorkspaceInviteEmail({ roleSid: "worker" }).text, /as worker/u);
+  assert.match(renderDefaultWorkspaceInviteEmail(input).text, /as worker/u);
 });