@jskit-ai/workspaces-core 0.2.3 → 0.2.5

package/src/server/support/workspaceActionSurfaces.js

@@ -24,7 +24,7 @@ function resolveWorkspaceSurfaceIdsFromAppConfig(appConfig = {}) {
 }
 
 function resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig(appConfig = {}) {
-  const policies = isRecord(appConfig?.surfaceAccessPolicies) ? appConfig.surfaceAccessPolicies : {};
+  const policies = isRecord(appConfig.surfaceAccessPolicies) ? appConfig.surfaceAccessPolicies : {};
 
   return resolveSurfaceIdsFromAppConfig(appConfig, (definition) => {
     if (definition.requiresWorkspace !== true) {
@@ -40,7 +40,7 @@ function resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig(appConfig = {
 }
 
 function resolveSurfaceIdsFromAppConfig(appConfig = {}, predicate) {
-  const source = isRecord(appConfig?.surfaceDefinitions) ? appConfig.surfaceDefinitions : {};
+  const source = isRecord(appConfig.surfaceDefinitions) ? appConfig.surfaceDefinitions : {};
   const resolved = [];
 
   for (const [key, value] of Object.entries(source)) {
@@ -60,46 +60,12 @@ function resolveSurfaceIdsFromAppConfig(appConfig = {}, predicate) {
   return normalizeSurfaceIds(resolved);
 }
 
-function materializeWorkspaceActionSurfaces(actions = [], { workspaceSurfaceIds = [] } = {}) {
-  const sourceActions = Array.isArray(actions) ? actions : [];
-  const resolvedWorkspaceSurfaceIds = normalizeSurfaceIds(workspaceSurfaceIds);
-  const materialized = [];
-
-  for (const entry of sourceActions) {
-    const action = isRecord(entry) ? entry : {};
-    const surfacesFrom = String(action.surfacesFrom || "")
-      .trim()
-      .toLowerCase();
-    if (surfacesFrom !== "workspace") {
-      materialized.push(action);
-      continue;
-    }
-
-    if (resolvedWorkspaceSurfaceIds.length < 1) {
-      continue;
-    }
-
-    const { surfacesFrom: _ignored, ...rest } = action;
-    materialized.push({
-      ...rest,
-      surfaces: [...resolvedWorkspaceSurfaceIds]
-    });
-  }
-
-  return Object.freeze(materialized.map((entry) => Object.freeze({ ...entry })));
-}
-
-function materializeWorkspaceActionSurfacesFromAppConfig(actions = [], { appConfig = {} } = {}) {
-  const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
-  return materializeWorkspaceActionSurfaces(actions, { workspaceSurfaceIds });
-}
-
 function resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig = {}) {
   const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
   const workspaceSurfaceSet = new Set(workspaceSurfaceIds);
 
   const resolvedSurfaceId = resolveDefaultWorkspaceSurfaceId({
-    defaultSurfaceId: appConfig?.surfaceDefaultId,
+    defaultSurfaceId: appConfig.surfaceDefaultId,
     workspaceSurfaceIds,
     surfaceRequiresWorkspace(surfaceId) {
       return workspaceSurfaceSet.has(surfaceId);
@@ -109,7 +75,7 @@ function resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig = {}) {
   return (
     normalizeSurfaceId(resolvedSurfaceId) ||
     normalizeSurfaceId(workspaceSurfaceIds[0]) ||
-    normalizeSurfaceId(appConfig?.surfaceDefaultId) ||
+    normalizeSurfaceId(appConfig.surfaceDefaultId) ||
     ""
   );
 }
@@ -117,7 +83,5 @@ function resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig = {}) {
 export {
   resolveWorkspaceSurfaceIdsFromAppConfig,
   resolveWorkspaceMembershipOptionalSurfaceIdsFromAppConfig,
-  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
-  materializeWorkspaceActionSurfaces,
-  materializeWorkspaceActionSurfacesFromAppConfig
+  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig
 };

package/src/server/support/workspaceCrud.js

@@ -0,0 +1,25 @@
+import { routeParamsValidator, workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
+import { buildWorkspaceInputFromRouteParams } from "./workspaceRouteInput.js";
+
+/**
+ * The workspace scope's input: the workspace slug in the request's route params.
+ * @param {{ input: { params: Record<string, unknown> } }} request
+ */
+function workspaceCrudScopeInput(request) {
+  return buildWorkspaceInputFromRouteParams(request.input.params);
+}
+
+/**
+ * The scope a workspace CRUD feature hands defineCrudJsonApiFeature: its routes
+ * live under /w/:workspaceSlug, and the workspace slug is the scope's only input.
+ * @type {import("@jskit-ai/crud-core/server/types").CrudScope}
+ */
+const WORKSPACE_CRUD_SCOPE = Object.freeze({
+  routeBase: "/w/:workspaceSlug",
+  actionInputValidator: workspaceSlugParamsValidator,
+  routeParamsValidator,
+  inputKeys: Object.freeze(["workspaceSlug"]),
+  input: workspaceCrudScopeInput
+});
+
+export { WORKSPACE_CRUD_SCOPE };

package/src/server/support/workspaceInvitationsPolicy.js

@@ -1,33 +1,25 @@
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  normalizeTenancyMode
-} from "../../shared/tenancyMode.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { TENANCY_MODE_PERSONAL } from "../../shared/tenancyMode.js";
 
-function normalizeWorkspaceInvitationsConfig(appConfig = {}) {
-  const source = appConfig && typeof appConfig === "object" && !Array.isArray(appConfig)
-    ? appConfig.workspaceInvitations
-    : null;
-  const normalizedSource = source && typeof source === "object" && !Array.isArray(source)
-    ? source
-    : {};
+/** @param {import("@jskit-ai/kernel/server/types").RuntimeConfig} appConfig */
+function normalizeWorkspaceInvitationsConfig(appConfig) {
+  const source = isRecord(appConfig.workspaceInvitations) ? appConfig.workspaceInvitations : {};
 
   return Object.freeze({
-    enabled: normalizedSource.enabled !== false,
-    allowInPersonalMode: normalizedSource.allowInPersonalMode !== false
+    enabled: source.enabled !== false,
+    allowInPersonalMode: source.allowInPersonalMode !== false
   });
 }
 
-function resolveWorkspaceInvitationsPolicy({
-  appConfig = {},
-  tenancyProfile = null
-} = {}) {
+/**
+ * @param {object} options
+ * @param {import("@jskit-ai/kernel/server/types").RuntimeConfig} options.appConfig
+ * @param {import("../types.js").WorkspaceTenancyProfile} options.tenancyProfile
+ */
+function resolveWorkspaceInvitationsPolicy({ appConfig, tenancyProfile }) {
   const config = normalizeWorkspaceInvitationsConfig(appConfig);
-  const normalizedTenancyProfile = tenancyProfile && typeof tenancyProfile === "object"
-    ? tenancyProfile
-    : {};
-  const tenancyMode = normalizeTenancyMode(normalizedTenancyProfile.mode || appConfig?.tenancyMode);
-  const workspaceEnabled = normalizedTenancyProfile?.workspace?.enabled === true || tenancyMode !== TENANCY_MODE_NONE;
+  const tenancyMode = tenancyProfile.mode;
+  const workspaceEnabled = tenancyProfile.workspace.enabled === true;
   const enabledForTenancyMode = tenancyMode !== TENANCY_MODE_PERSONAL || config.allowInPersonalMode === true;
   const enabled = config.enabled === true && workspaceEnabled && enabledForTenancyMode;
 
@@ -39,7 +31,4 @@ function resolveWorkspaceInvitationsPolicy({
   });
 }
 
-export {
-  normalizeWorkspaceInvitationsConfig,
-  resolveWorkspaceInvitationsPolicy
-};
+export { resolveWorkspaceInvitationsPolicy };

package/src/server/support/workspaceRouteInput.js

@@ -1,7 +1,8 @@
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { BOOTSTRAP_PATH } from "@jskit-ai/kernel/shared/surface/paths";
 
 function readWorkspaceSlugFromRouteParams(params = {}) {
-  const workspaceSlug = normalizeText(params?.workspaceSlug).toLowerCase();
+  const workspaceSlug = normalizeText(params.workspaceSlug).toLowerCase();
   return workspaceSlug || "";
 }
 
@@ -16,7 +17,23 @@ function buildWorkspaceInputFromRouteParams(params = {}) {
   };
 }
 
+/**
+ * The workspace a request asks for, for code that runs before the workspace action context contributor, such as an
+ * auth service decorator: the route's `workspaceSlug` param, else the bootstrap request's `workspaceSlug` query.
+ * It reads what the router matched and parsed, never the URL. `{}` when the request names no workspace.
+ * @param {{ params?: Record<string, unknown>, query?: Record<string, unknown>, routeOptions?: { url?: string } }} request
+ * @returns {{ workspaceSlug?: string }}
+ */
+function requestedWorkspaceScope(request) {
+  const routeInput = buildWorkspaceInputFromRouteParams(request.params || {});
+  if (routeInput.workspaceSlug || request.routeOptions?.url !== BOOTSTRAP_PATH) {
+    return routeInput;
+  }
+  return buildWorkspaceInputFromRouteParams({ workspaceSlug: request.query?.workspaceSlug });
+}
+
 export {
   readWorkspaceSlugFromRouteParams,
-  buildWorkspaceInputFromRouteParams
+  buildWorkspaceInputFromRouteParams,
+  requestedWorkspaceScope
 };

package/src/server/{common/support → support}/workspaceRoutePaths.js

@@ -1,13 +1,19 @@
 import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
 import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
 
+/** The API base of the workspace routes, /api/w/:workspaceSlug. */
 const WORKSPACE_ROUTE_BASE_PATH = resolveScopedApiBasePath({
   routeBase: "/w/:workspaceSlug",
   strictParams: false
 });
 
-function resolveWorkspaceRoutePath(relativePath = "/") {
-  const normalizedRelativePath = normalizePathname(relativePath || "/");
+/**
+ * A workspace route's path: relativePath under /api/w/:workspaceSlug; the
+ * base itself when relativePath is left out or empty.
+ * @param {string} [relativePath]
+ */
+function resolveWorkspaceRoutePath(relativePath) {
+  const normalizedRelativePath = normalizePathname(relativePath);
   if (normalizedRelativePath === "/") {
     return WORKSPACE_ROUTE_BASE_PATH;
   }

package/src/server/types.js

@@ -0,0 +1,47 @@
+// The type of the `workspaces.core` capability, for features that require it.
+
+/** @typedef {ReturnType<typeof import("./workspacesRuntime.js").createWorkspacesRuntime>} WorkspacesCore */
+
+/** @typedef {ReturnType<typeof import("./common/services/workspaceDirectoryService.js").createService>} WorkspaceDirectoryService The workspace directory service: `services.directory` of `workspaces.core`. */
+/** @typedef {ReturnType<typeof import("./workspaceMembers/workspaceMembersService.js").createService>} WorkspaceMembersService The workspace members service: `services.members` of `workspaces.core`. */
+/** @typedef {ReturnType<typeof import("./workspacePendingInvitations/workspacePendingInvitationsService.js").createService>} WorkspacePendingInvitationsService The pending invitations service: `services.pendingInvitations` of `workspaces.core`. */
+/** @typedef {ReturnType<typeof import("./workspaceSettings/workspaceSettingsService.js").createService>} WorkspaceSettingsService The workspace settings service: `services.settings` of `workspaces.core`. */
+
+/** @typedef {ReturnType<typeof import("./common/repositories/workspacesRepository.js").createRepository>} WorkspacesRepository */
+/** @typedef {ReturnType<typeof import("./common/repositories/workspaceMembershipsRepository.js").createRepository>} WorkspaceMembershipsRepository */
+/** @typedef {ReturnType<typeof import("./common/repositories/workspaceInvitesRepository.js").createRepository>} WorkspaceInvitesRepository */
+/** @typedef {ReturnType<typeof import("./workspaceSettings/workspaceSettingsRepository.js").createRepository>} WorkspaceSettingsRepository */
+/** @typedef {ReturnType<typeof import("../shared/roles.js").createWorkspaceRoleCatalog>} WorkspaceRoleCatalog */
+/** @typedef {ReturnType<typeof import("../shared/tenancyProfile.js").resolveTenancyProfile>} WorkspaceTenancyProfile */
+/** @typedef {ReturnType<typeof import("./workspaceMembers/workspaceInviteUrls.js").createWorkspaceInviteUrlBuilder>} WorkspaceInviteUrlBuilder The invitation URL a token opens, from the app's public URL and invite path. */
+/** @typedef {ReturnType<typeof import("./i18n.js").createWorkspacesServerI18n>} WorkspacesServerI18n The workspace texts rendered on the server, in a recipient's language. */
+
+/**
+ * The `workspaces.invite-mailer` capability: a feature that provides it sends
+ * workspace invitation email. Its result is the delivery outcome; the status
+ * defaults to "sent".
+ * @typedef {object} WorkspaceInviteMailer
+ * @property {(message: { email: string, inviteUrl: string, workspace: object, inviter: object | null, roleSid: string, expiresAt: string, locale: string, message: object }, options?: object) => Promise<{ status?: string, message?: string, messageCode?: string, messageParams?: object, providerMessageId?: string } | void>} sendWorkspaceInvite
+ */
+
+/**
+ * The `workspaces.invite-email-template` capability: renders an invitation
+ * email's `{ subject, text, html }`.
+ * @typedef {(input: { email: string, inviteUrl: string, workspace: object, inviter: object | null, roleSid: string, roleLabel?: string, expiresAt: string, locale: string, t: (key: string, params?: object) => string }) => object | Promise<object>} WorkspaceInviteEmailTemplate
+ */
+
+/**
+ * The `workspaces.invite-acceptance-participant` capability: the application's
+ * writes for an accepted invitation. It runs after the membership is activated,
+ * inside the uncommitted acceptance transaction (`trx`), and a failure rolls the
+ * acceptance back.
+ * @typedef {(acceptance: { invite: object, user: object }, options: { trx: unknown, context?: object }) => Promise<void>} WorkspaceInviteAcceptanceParticipant
+ */
+
+/**
+ * The `workspaces.personal-workspace-name` capability: names the personal
+ * workspace provisioned for a user. An empty name falls back to the default.
+ * @typedef {(user: object) => string} PersonalWorkspaceName
+ */
+
+export {};

package/src/server/workspaceBootstrapContributor.js

@@ -1,10 +1,6 @@
-import { requireServiceMethod } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  TENANCY_MODE_NONE,
-  resolveTenancyProfile
-} from "../shared/tenancyProfile.js";
+import { normalizeLowerText, normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { TENANCY_MODE_NONE } from "../shared/tenancyProfile.js";
 import {
   mapMembershipSummary,
   mapWorkspaceSettingsPublic,
@@ -16,25 +12,18 @@ const REQUESTED_WORKSPACE_STATUS_NOT_FOUND = "not_found";
 const REQUESTED_WORKSPACE_STATUS_FORBIDDEN = "forbidden";
 const REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED = "unauthenticated";
 
-function normalizeQueryPayload(value = {}) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value;
-}
-
-function resolveBootstrapWorkspaceSlug({ query = {}, request = null } = {}) {
-  const normalizedQuery = normalizeQueryPayload(query);
+function resolveBootstrapWorkspaceSlug({ query, request }) {
+  const normalizedQuery = normalizeObjectInput(query);
   if (Object.hasOwn(normalizedQuery, "workspaceSlug")) {
     return normalizeLowerText(normalizedQuery.workspaceSlug);
   }
 
-  const normalizedInputQuery = normalizeQueryPayload(request?.input?.query);
+  const normalizedInputQuery = normalizeObjectInput(request?.input?.query);
   if (Object.hasOwn(normalizedInputQuery, "workspaceSlug")) {
     return normalizeLowerText(normalizedInputQuery.workspaceSlug);
   }
 
-  const normalizedRequestQuery = normalizeQueryPayload(request?.query);
+  const normalizedRequestQuery = normalizeObjectInput(request?.query);
   if (Object.hasOwn(normalizedRequestQuery, "workspaceSlug")) {
     return normalizeLowerText(normalizedRequestQuery.workspaceSlug);
   }
@@ -42,7 +31,7 @@ function resolveBootstrapWorkspaceSlug({ query = {}, request = null } = {}) {
   return "";
 }
 
-function normalizeRequestedWorkspaceStatus(value = "") {
+function normalizeRequestedWorkspaceStatus(value) {
   const normalizedValue = normalizeLowerText(value);
   if (
     normalizedValue === REQUESTED_WORKSPACE_STATUS_RESOLVED ||
@@ -55,7 +44,7 @@ function normalizeRequestedWorkspaceStatus(value = "") {
   return "";
 }
 
-function createRequestedWorkspacePayload(workspaceSlug = "", status = "") {
+function buildRequestedWorkspacePayload(workspaceSlug, status) {
   const normalizedWorkspaceSlug = normalizeLowerText(workspaceSlug);
   const normalizedStatus = normalizeRequestedWorkspaceStatus(status);
   if (!normalizedWorkspaceSlug || !normalizedStatus) {
@@ -81,144 +70,118 @@ function resolveRequestedWorkspaceStatusFromError(error) {
   return "";
 }
 
-function resolveBootstrapTenancyProfile(tenancyProfile = null, appConfig = {}) {
-  const fallback = resolveTenancyProfile(appConfig);
-  return Object.freeze({
-    mode: fallback.mode,
-    workspace: Object.freeze({
-      enabled: fallback.workspace.enabled === true,
-      autoProvision: fallback.workspace.autoProvision === true,
-      allowSelfCreate: fallback.workspace.allowSelfCreate === true,
-      slugPolicy: fallback.workspace.slugPolicy
-    })
-  });
-}
-
+/**
+ * @param {object} dependencies
+ * @param {import("./types.js").WorkspaceDirectoryService} dependencies.workspaceService
+ * @param {import("./types.js").WorkspacePendingInvitationsService} dependencies.workspacePendingInvitationsService
+ * @param {import("@jskit-ai/users-core/server/types").UserProfilesRepository} dependencies.userProfilesRepository
+ * @param {boolean} dependencies.workspaceInvitationsEnabled
+ * @param {import("./types.js").WorkspaceTenancyProfile} dependencies.tenancyProfile
+ */
 function createWorkspaceBootstrapContributor({
   workspaceService,
   workspacePendingInvitationsService,
   userProfilesRepository,
-  workspaceInvitationsEnabled = false,
-  appConfig = {},
-  tenancyProfile = null
-} = {}) {
-  const contributorId = "users.workspace.bootstrap";
-  const resolvedTenancyProfile = resolveBootstrapTenancyProfile(tenancyProfile, appConfig);
-
-  requireServiceMethod(workspaceService, "listWorkspacesForUser", contributorId, {
-    serviceLabel: "workspaceService"
-  });
-  requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId, {
-    serviceLabel: "workspaceService"
-  });
-  if (workspaceInvitationsEnabled) {
-    requireServiceMethod(workspacePendingInvitationsService, "listPendingInvitesForUser", contributorId, {
-      serviceLabel: "workspacePendingInvitationsService"
-    });
-  }
-  requireServiceMethod(userProfilesRepository, "findById", contributorId, {
-    serviceLabel: "internal.repository.user-profiles"
-  });
-
-  return Object.freeze({
-    contributorId,
-    order: 200,
-    async contribute({ request = null, query = {}, payload = {} } = {}) {
-      const inheritedAppState = payload?.app && typeof payload.app === "object" ? payload.app : {};
-      const inheritedFeatures =
-        inheritedAppState.features && typeof inheritedAppState.features === "object" ? inheritedAppState.features : {};
-      const normalizedUserId = normalizeRecordId(
-        payload?.session?.authenticated === true ? payload?.session?.userId : null,
-        { fallback: null }
-      );
-      const normalizedWorkspaceSlug = resolveBootstrapWorkspaceSlug({ query, request });
-      if (!normalizedUserId) {
-        if (!normalizedWorkspaceSlug || resolvedTenancyProfile.mode === TENANCY_MODE_NONE) {
-          return {};
-        }
-
-        return {
-          tenancy: resolvedTenancyProfile,
-          app: {
-            ...inheritedAppState,
-            features: {
-              ...inheritedFeatures,
-              workspaceSwitching: normalizeLowerText(resolvedTenancyProfile.mode) !== TENANCY_MODE_NONE,
-              workspaceInvites: workspaceInvitationsEnabled === true
-            }
-          },
-          requestedWorkspace: createRequestedWorkspacePayload(
-            normalizedWorkspaceSlug,
-            REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
-          )
-        };
-      }
-
-      const latestProfile = await userProfilesRepository.findById(normalizedUserId);
-      if (!latestProfile) {
+  workspaceInvitationsEnabled,
+  tenancyProfile
+}) {
+  /** @param {{ request?: object, query?: object, payload: object }} bootstrap The kernel bootstrap's request, query and payload so far. */
+  async function contribute({ request, query, payload }) {
+    const inheritedAppState = payload.app && typeof payload.app === "object" ? payload.app : {};
+    const inheritedFeatures =
+      inheritedAppState.features && typeof inheritedAppState.features === "object" ? inheritedAppState.features : {};
+    const normalizedUserId = normalizeRecordId(
+      payload.session?.authenticated === true ? payload.session?.userId : null,
+      { fallback: null }
+    );
+    const normalizedWorkspaceSlug = resolveBootstrapWorkspaceSlug({ query, request });
+    if (!normalizedUserId) {
+      if (!normalizedWorkspaceSlug || tenancyProfile.mode === TENANCY_MODE_NONE) {
         return {};
       }
 
-      const pendingInvites =
-        workspaceInvitationsEnabled
-          ? await workspacePendingInvitationsService.listPendingInvitesForUser(latestProfile, {
-              context: {
-                actor: latestProfile
-              }
-            })
-          : [];
-      const workspaces = await workspaceService.listWorkspacesForUser(latestProfile, { request });
-      let workspaceContext = null;
-      let requestedWorkspace = null;
-      if (normalizedWorkspaceSlug && resolvedTenancyProfile.mode !== TENANCY_MODE_NONE) {
-        try {
-          workspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
-            latestProfile,
-            normalizedWorkspaceSlug,
-            { request }
-          );
-          requestedWorkspace = createRequestedWorkspacePayload(
-            normalizedWorkspaceSlug,
-            REQUESTED_WORKSPACE_STATUS_RESOLVED
-          );
-        } catch (error) {
-          const requestedWorkspaceStatus = resolveRequestedWorkspaceStatusFromError(error);
-          if (!requestedWorkspaceStatus) {
-            throw error;
-          }
-          requestedWorkspace = createRequestedWorkspacePayload(normalizedWorkspaceSlug, requestedWorkspaceStatus);
-        }
-      }
-
       return {
-        tenancy: resolvedTenancyProfile,
+        tenancy: tenancyProfile,
         app: {
           ...inheritedAppState,
           features: {
             ...inheritedFeatures,
-            workspaceSwitching: normalizeLowerText(resolvedTenancyProfile.mode) !== TENANCY_MODE_NONE,
-            workspaceInvites: workspaceInvitationsEnabled === true
+            workspaceSwitching: tenancyProfile.mode !== TENANCY_MODE_NONE,
+            workspaceInvites: workspaceInvitationsEnabled
           }
         },
-        workspaces: [...workspaces],
-        pendingInvites,
-        activeWorkspace: workspaceContext
-          ? mapWorkspaceSummary(workspaceContext.workspace, {
-              roleSid: workspaceContext.membership?.roleSid,
-              status: workspaceContext.membership?.status
-            })
-          : null,
-        membership: mapMembershipSummary(workspaceContext?.membership, workspaceContext?.workspace),
-        requestedWorkspace,
-        permissions: workspaceContext ? [...workspaceContext.permissions] : [],
-        workspaceSettings: workspaceContext
-          ? mapWorkspaceSettingsPublic(workspaceContext.workspaceSettings, {
-              workspaceInvitationsEnabled
-            })
-          : null
+        requestedWorkspace: buildRequestedWorkspacePayload(
+          normalizedWorkspaceSlug,
+          REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
+        )
       };
     }
-  });
+
+    const latestProfile = await userProfilesRepository.findById(normalizedUserId);
+    if (!latestProfile) {
+      return {};
+    }
+
+    const pendingInvites =
+      workspaceInvitationsEnabled
+        ? await workspacePendingInvitationsService.listPendingInvitesForUser(latestProfile, {
+            context: {
+              actor: latestProfile
+            }
+          })
+        : [];
+    const workspaces = await workspaceService.listWorkspacesForUser(latestProfile);
+    let workspaceContext = null;
+    let requestedWorkspace = null;
+    if (normalizedWorkspaceSlug && tenancyProfile.mode !== TENANCY_MODE_NONE) {
+      try {
+        workspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
+          latestProfile,
+          normalizedWorkspaceSlug
+        );
+        requestedWorkspace = buildRequestedWorkspacePayload(
+          normalizedWorkspaceSlug,
+          REQUESTED_WORKSPACE_STATUS_RESOLVED
+        );
+      } catch (error) {
+        const requestedWorkspaceStatus = resolveRequestedWorkspaceStatusFromError(error);
+        if (!requestedWorkspaceStatus) {
+          throw error;
+        }
+        requestedWorkspace = buildRequestedWorkspacePayload(normalizedWorkspaceSlug, requestedWorkspaceStatus);
+      }
+    }
+
+    return {
+      tenancy: tenancyProfile,
+      app: {
+        ...inheritedAppState,
+        features: {
+          ...inheritedFeatures,
+          workspaceSwitching: tenancyProfile.mode !== TENANCY_MODE_NONE,
+          workspaceInvites: workspaceInvitationsEnabled
+        }
+      },
+      workspaces: [...workspaces],
+      pendingInvites,
+      activeWorkspace: workspaceContext
+        ? mapWorkspaceSummary(workspaceContext.workspace, {
+            roleSid: workspaceContext.membership?.roleSid,
+            status: workspaceContext.membership?.status
+          })
+        : null,
+      membership: mapMembershipSummary(workspaceContext?.membership, workspaceContext?.workspace),
+      requestedWorkspace,
+      permissions: workspaceContext ? [...workspaceContext.permissions] : [],
+      workspaceSettings: workspaceContext
+        ? mapWorkspaceSettingsPublic(workspaceContext.workspaceSettings, {
+            workspaceInvitationsEnabled
+          })
+        : null
+    };
+  }
+
+  return Object.freeze({ contribute });
 }
 
 export { createWorkspaceBootstrapContributor };