@jskit-ai/users-core 0.1.47 → 0.1.49

package/src/server/consoleSettings/registerConsoleSettings.js

@@ -1,56 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { createService as createConsoleSettingsService } from "./consoleSettingsService.js";
-import { createService as createConsoleService } from "./consoleService.js";
-import { consoleSettingsActions } from "./consoleSettingsActions.js";
-
-function registerConsoleSettings(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerConsoleSettings requires application singleton()/service()/actions().");
-  }
-
-  const hasConsoleService = typeof app.has === "function" ? app.has("consoleService") : false;
-  if (!hasConsoleService) {
-    app.singleton("consoleService", (scope) =>
-      createConsoleService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository")
-      })
-    );
-  }
-
-  app.service(
-    "users.console.settings.service",
-    (scope) =>
-      createConsoleSettingsService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository"),
-        consoleService: scope.make("consoleService")
-      }),
-    {
-      events: Object.freeze({
-        updateSettings: Object.freeze([
-          Object.freeze({
-            type: "entity.changed",
-            source: "console",
-            entity: "settings",
-            operation: "updated",
-            entityId: 1,
-            realtime: Object.freeze({
-              event: "console.settings.changed",
-              audience: "all_users"
-            })
-          })
-        ])
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(consoleSettingsActions, {
-      domain: "console",
-      dependencies: {
-        consoleSettingsService: "users.console.settings.service"
-      }
-    })
-  );
-}
-
-export { registerConsoleSettings };

package/src/server/registerWorkspaceBootstrap.js

@@ -1,27 +0,0 @@
-import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { createWorkspaceBootstrapContributor } from "./workspaceBootstrapContributor.js";
-
-
-function registerWorkspaceBootstrap(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceBootstrap requires application singleton().");
-  }
-
-  registerBootstrapPayloadContributor(app, "workspaces.core.bootstrap.payloadContributor", (scope) => {
-    const workspaceInvitationsEnabled = scope.make("users.workspace.invitations.enabled");
-
-    return createWorkspaceBootstrapContributor({
-      workspaceService: scope.make("users.workspace.service"),
-      workspacePendingInvitationsService: workspaceInvitationsEnabled
-        ? scope.make("users.workspace.pending-invitations.service")
-        : null,
-      workspaceInvitationsEnabled,
-      usersRepository: scope.make("usersRepository"),
-      appConfig: resolveAppConfig(scope),
-      tenancyProfile: scope.make("users.tenancy.profile")
-    });
-  });
-}
-
-export { registerWorkspaceBootstrap };

package/src/server/registerWorkspaceCore.js

@@ -1,73 +0,0 @@
-import {
-  registerActionContextContributor
-} from "@jskit-ai/kernel/server/actions";
-import { registerRouteVisibilityResolver } from "@jskit-ai/kernel/server/http";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { createService as createWorkspaceService } from "./common/services/workspaceContextService.js";
-import { createWorkspaceActionContextContributor } from "./common/contributors/workspaceActionContextContributor.js";
-import { createWorkspaceRouteVisibilityResolver } from "./common/contributors/workspaceRouteVisibilityResolver.js";
-import { createWorkspaceAuthPolicyContextResolver } from "./common/contributors/workspaceAuthPolicyContextResolver.js";
-import { TENANCY_MODE_WORKSPACES } from "../shared/tenancyProfile.js";
-import { resolveWorkspaceInvitationsPolicy } from "./support/workspaceInvitationsPolicy.js";
-import { resolveWorkspaceSurfaceIdsFromAppConfig } from "./support/workspaceActionSurfaces.js";
-
-
-function registerWorkspaceCore(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceCore requires application singleton().");
-  }
-
-  app.singleton("users.workspace.service", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceService({
-      appConfig,
-      workspacesRepository: scope.make("workspacesRepository"),
-      workspaceMembershipsRepository: scope.make("workspaceMembershipsRepository"),
-      workspaceSettingsRepository: scope.make("workspaceSettingsRepository")
-    });
-  });
-  app.singleton("users.workspace.enabled", (scope) => {
-    return scope.make("users.tenancy.profile").workspace.enabled === true;
-  });
-
-  app.singleton("users.workspace.self-create.enabled", (scope) => {
-    return scope.make("users.tenancy.profile").workspace.allowSelfCreate === true;
-  });
-
-  app.singleton("users.workspace.tenancy.enabled", (scope) => {
-    return scope.make("users.tenancy.profile").mode === TENANCY_MODE_WORKSPACES;
-  });
-
-  app.singleton("users.workspace.invitations.enabled", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    const tenancyProfile = scope.make("users.tenancy.profile");
-    return resolveWorkspaceInvitationsPolicy({
-      appConfig,
-      tenancyProfile
-    }).enabled;
-  });
-
-  registerActionContextContributor(app, "users.core.workspace.actionContextContributor", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return createWorkspaceActionContextContributor({
-      workspaceService: scope.make("users.workspace.service"),
-      workspaceSurfaceIds: resolveWorkspaceSurfaceIdsFromAppConfig(appConfig)
-    });
-  });
-
-  if (typeof app.has !== "function" || !app.has("auth.policy.contextResolver")) {
-    app.singleton("auth.policy.contextResolver", (scope) =>
-      createWorkspaceAuthPolicyContextResolver({
-        workspaceService: scope.make("users.workspace.service")
-      })
-    );
-  }
-
-  registerRouteVisibilityResolver(app, "users.core.workspace.routeVisibilityResolver", (scope) =>
-    createWorkspaceRouteVisibilityResolver({
-      workspaceService: scope.make("users.workspace.service")
-    })
-  );
-}
-
-export { registerWorkspaceCore };

package/src/server/registerWorkspaceRepositories.js

@@ -1,26 +0,0 @@
-import { createRepository as createWorkspacesRepository } from "./common/repositories/workspacesRepository.js";
-import { createRepository as createWorkspaceMembershipsRepository } from "./common/repositories/workspaceMembershipsRepository.js";
-import { createRepository as createWorkspaceInvitesRepository } from "./common/repositories/workspaceInvitesRepository.js";
-
-function registerWorkspaceRepositories(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerWorkspaceRepositories requires application singleton().");
-  }
-
-  app.singleton("workspacesRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspacesRepository(knex);
-  });
-
-  app.singleton("workspaceMembershipsRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspaceMembershipsRepository(knex);
-  });
-
-  app.singleton("workspaceInvitesRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createWorkspaceInvitesRepository(knex);
-  });
-}
-
-export { registerWorkspaceRepositories };

package/src/server/support/resolveWorkspace.js

@@ -1,16 +0,0 @@
-import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
-
-function resolveRequest(context = {}) {
-  const requestMeta = normalizeObject(context?.requestMeta);
-  return normalizeObject(requestMeta.request);
-}
-
-function resolveWorkspace(context = {}, input = {}) {
-  const payload = normalizeObject(input);
-  const requestMeta = normalizeObject(context?.requestMeta);
-  const resolvedWorkspaceContext = normalizeObject(requestMeta.resolvedWorkspaceContext);
-
-  return payload.workspace || resolvedWorkspaceContext.workspace || context?.workspace || resolveRequest(context)?.workspace || null;
-}
-
-export { resolveWorkspace };

package/src/server/support/workspaceActionSurfaces.js

@@ -1,135 +0,0 @@
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { isRecord, normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveDefaultWorkspaceSurfaceId } from "../../shared/support/workspacePathModel.js";
-
-const CONSOLE_OWNER_ACCESS_POLICY_ID = "console_owner";
-
-function normalizeSurfaceIds(surfaceIds = []) {
-  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
-  const seen = new Set();
-  const normalized = [];
-
-  for (const candidate of source) {
-    const surfaceId = normalizeSurfaceId(candidate);
-    if (!surfaceId || seen.has(surfaceId)) {
-      continue;
-    }
-    seen.add(surfaceId);
-    normalized.push(surfaceId);
-  }
-
-  return normalized;
-}
-
-function resolveWorkspaceSurfaceIdsFromAppConfig(appConfig = {}) {
-  return resolveSurfaceIdsFromAppConfig(appConfig, (definition) => definition.requiresWorkspace === true);
-}
-
-function resolveConsoleSurfaceIdsFromAppConfig(appConfig = {}) {
-  return resolveSurfaceIdsFromAppConfig(appConfig, (definition) => {
-    return (
-      definition.requiresWorkspace !== true &&
-      normalizeLowerText(definition.accessPolicyId) === CONSOLE_OWNER_ACCESS_POLICY_ID
-    );
-  });
-}
-
-function resolveSurfaceIdsFromAppConfig(appConfig = {}, predicate) {
-  const source = isRecord(appConfig?.surfaceDefinitions) ? appConfig.surfaceDefinitions : {};
-  const resolved = [];
-
-  for (const [key, value] of Object.entries(source)) {
-    const definition = isRecord(value) ? value : {};
-    const surfaceId = normalizeSurfaceId(definition.id || key);
-    if (!surfaceId) {
-      continue;
-    }
-    if (definition.enabled === false) {
-      continue;
-    }
-    if (typeof predicate === "function" && predicate(definition) === true) {
-      resolved.push(surfaceId);
-    }
-  }
-
-  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 registerUsersCoreActionSurfaceSources(app) {
-  if (!app || typeof app.actionSurfaceSource !== "function") {
-    return;
-  }
-
-  app.actionSurfaceSource("workspace", ({ scope }) => {
-    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
-    return resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
-  });
-
-  app.actionSurfaceSource("console", ({ scope }) => {
-    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
-    return resolveConsoleSurfaceIdsFromAppConfig(appConfig);
-  });
-}
-
-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,
-    workspaceSurfaceIds,
-    surfaceRequiresWorkspace(surfaceId) {
-      return workspaceSurfaceSet.has(surfaceId);
-    }
-  });
-
-  return (
-    normalizeSurfaceId(resolvedSurfaceId) ||
-    normalizeSurfaceId(workspaceSurfaceIds[0]) ||
-    normalizeSurfaceId(appConfig?.surfaceDefaultId) ||
-    ""
-  );
-}
-
-export {
-  resolveWorkspaceSurfaceIdsFromAppConfig,
-  resolveConsoleSurfaceIdsFromAppConfig,
-  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
-  materializeWorkspaceActionSurfaces,
-  materializeWorkspaceActionSurfacesFromAppConfig,
-  registerUsersCoreActionSurfaceSources
-};

package/src/server/support/workspaceInvitationsPolicy.js

@@ -1,45 +0,0 @@
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  normalizeTenancyMode
-} 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
-    : {};
-
-  return Object.freeze({
-    enabled: normalizedSource.enabled !== false,
-    allowInPersonalMode: normalizedSource.allowInPersonalMode !== false
-  });
-}
-
-function resolveWorkspaceInvitationsPolicy({
-  appConfig = {},
-  tenancyProfile = null
-} = {}) {
-  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 enabledForTenancyMode = tenancyMode !== TENANCY_MODE_PERSONAL || config.allowInPersonalMode === true;
-  const enabled = config.enabled === true && workspaceEnabled && enabledForTenancyMode;
-
-  return Object.freeze({
-    enabled,
-    workspaceEnabled,
-    allowInPersonalMode: config.allowInPersonalMode,
-    tenancyMode
-  });
-}
-
-export {
-  normalizeWorkspaceInvitationsConfig,
-  resolveWorkspaceInvitationsPolicy
-};

package/src/server/support/workspaceRouteInput.js

@@ -1,22 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function readWorkspaceSlugFromRouteParams(params = {}) {
-  const workspaceSlug = normalizeText(params?.workspaceSlug).toLowerCase();
-  return workspaceSlug || "";
-}
-
-function buildWorkspaceInputFromRouteParams(params = {}) {
-  const workspaceSlug = readWorkspaceSlugFromRouteParams(params);
-  if (!workspaceSlug) {
-    return {};
-  }
-
-  return {
-    workspaceSlug
-  };
-}
-
-export {
-  readWorkspaceSlugFromRouteParams,
-  buildWorkspaceInputFromRouteParams
-};

package/src/server/workspaceBootstrapContributor.js

@@ -1,211 +0,0 @@
-import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeLowerText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  TENANCY_MODE_NONE,
-  resolveTenancyProfile
-} from "../shared/tenancyProfile.js";
-import { workspacePendingInvitationsResource } from "../shared/resources/workspacePendingInvitationsResource.js";
-import {
-  mapMembershipSummary,
-  mapWorkspaceSettingsPublic,
-  mapWorkspaceSummary
-} from "./common/formatters/workspaceFormatter.js";
-
-const REQUESTED_WORKSPACE_STATUS_RESOLVED = "resolved";
-const REQUESTED_WORKSPACE_STATUS_NOT_FOUND = "not_found";
-const REQUESTED_WORKSPACE_STATUS_FORBIDDEN = "forbidden";
-const REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED = "unauthenticated";
-
-function normalizePendingInvites(invites) {
-  return workspacePendingInvitationsResource.operations.list.outputValidator.normalize({
-    pendingInvites: invites
-  }).pendingInvites;
-}
-
-function normalizeQueryPayload(value = {}) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return {};
-  }
-  return value;
-}
-
-function resolveBootstrapWorkspaceSlug({ query = {}, request = null } = {}) {
-  const normalizedQuery = normalizeQueryPayload(query);
-  if (Object.hasOwn(normalizedQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedQuery.workspaceSlug);
-  }
-
-  const normalizedInputQuery = normalizeQueryPayload(request?.input?.query);
-  if (Object.hasOwn(normalizedInputQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedInputQuery.workspaceSlug);
-  }
-
-  const normalizedRequestQuery = normalizeQueryPayload(request?.query);
-  if (Object.hasOwn(normalizedRequestQuery, "workspaceSlug")) {
-    return normalizeLowerText(normalizedRequestQuery.workspaceSlug);
-  }
-
-  return "";
-}
-
-function normalizeRequestedWorkspaceStatus(value = "") {
-  const normalizedValue = normalizeLowerText(value);
-  if (
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_RESOLVED ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_NOT_FOUND ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_FORBIDDEN ||
-    normalizedValue === REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
-  ) {
-    return normalizedValue;
-  }
-  return "";
-}
-
-function createRequestedWorkspacePayload(workspaceSlug = "", status = "") {
-  const normalizedWorkspaceSlug = normalizeLowerText(workspaceSlug);
-  const normalizedStatus = normalizeRequestedWorkspaceStatus(status);
-  if (!normalizedWorkspaceSlug || !normalizedStatus) {
-    return null;
-  }
-  return {
-    slug: normalizedWorkspaceSlug,
-    status: normalizedStatus
-  };
-}
-
-function resolveRequestedWorkspaceStatusFromError(error) {
-  const statusCode = Number(error?.statusCode || error?.status || 0);
-  if (statusCode === 404) {
-    return REQUESTED_WORKSPACE_STATUS_NOT_FOUND;
-  }
-  if (statusCode === 403) {
-    return REQUESTED_WORKSPACE_STATUS_FORBIDDEN;
-  }
-  if (statusCode === 401) {
-    return REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED;
-  }
-  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
-    })
-  });
-}
-
-function createWorkspaceBootstrapContributor({
-  workspaceService,
-  workspacePendingInvitationsService,
-  usersRepository,
-  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(usersRepository, "findById", contributorId, {
-    serviceLabel: "usersRepository"
-  });
-
-  return Object.freeze({
-    contributorId,
-    async contribute({ request = null, query = {}, payload = {} } = {}) {
-      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 {
-          requestedWorkspace: createRequestedWorkspacePayload(
-            normalizedWorkspaceSlug,
-            REQUESTED_WORKSPACE_STATUS_UNAUTHENTICATED
-          )
-        };
-      }
-
-      const latestProfile = await usersRepository.findById(normalizedUserId);
-      if (!latestProfile) {
-        return {};
-      }
-
-      const pendingInvites =
-        workspaceInvitationsEnabled
-          ? normalizePendingInvites(
-              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 {
-        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
-      };
-    }
-  });
-}
-
-export { createWorkspaceBootstrapContributor };