@jskit-ai/users-core 0.1.48 → 0.1.49

package/src/server/common/services/workspaceContextService.js

@@ -1,281 +0,0 @@
-import { createHash } from "node:crypto";
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import {
-  TENANCY_MODE_NONE,
-  resolveTenancyProfile
-} from "../../../shared/tenancyProfile.js";
-import {
-  resolveRolePermissions
-} from "../../../shared/roles.js";
-import {
-  mapWorkspaceSummary
-} from "../formatters/workspaceFormatter.js";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { authenticatedUserValidator } from "../validators/authenticatedUserValidator.js";
-
-function toSlugPart(value) {
-  const normalized = normalizeLowerText(value)
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 48);
-  return normalized || "workspace";
-}
-
-function buildWorkspaceBaseSlug(user = {}) {
-  const username = normalizeLowerText(user.username);
-  if (username) {
-    return toSlugPart(username);
-  }
-  const displayName = normalizeText(user.displayName);
-  if (displayName) {
-    return toSlugPart(displayName);
-  }
-  const email = normalizeLowerText(user.email);
-  if (email.includes("@")) {
-    return toSlugPart(email.split("@")[0]);
-  }
-  return "workspace";
-}
-
-function buildWorkspaceName(user = {}) {
-  const displayName = normalizeText(user.displayName);
-  if (displayName) {
-    return `${displayName}'s Workspace`;
-  }
-  const email = normalizeLowerText(user.email);
-  if (email) {
-    return `${email}'s Workspace`;
-  }
-  return "Workspace";
-}
-
-function buildPermissionsFromMembership(membership, appConfig = {}) {
-  const roleSid = normalizeLowerText(membership?.roleSid || "member");
-  return resolveRolePermissions(roleSid, appConfig);
-}
-
-function hashInviteToken(token) {
-  return createHash("sha256").update(normalizeText(token)).digest("hex");
-}
-
-function normalizeWorkspaceCreationInput(payload = {}) {
-  const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  return {
-    name: normalizeText(source.name),
-    requestedSlug: normalizeLowerText(source.slug)
-  };
-}
-
-function createService({
-  appConfig = {},
-  workspacesRepository,
-  workspaceMembershipsRepository,
-  workspaceSettingsRepository
-} = {}) {
-  if (
-    !workspacesRepository ||
-    !workspaceMembershipsRepository ||
-    !workspaceSettingsRepository
-  ) {
-    throw new Error("workspaceService requires repositories.");
-  }
-
-  const resolvedTenancyProfile = resolveTenancyProfile(appConfig);
-  const resolvedTenancyMode = resolvedTenancyProfile.mode;
-  const workspacePolicy = resolvedTenancyProfile.workspace;
-  async function ensureUniqueWorkspaceSlug(baseSlug, options = {}) {
-    let suffix = 0;
-    while (suffix < 1000) {
-      suffix += 1;
-      const candidate = suffix === 1 ? toSlugPart(baseSlug) : `${toSlugPart(baseSlug)}-${suffix}`;
-      const existing = await workspacesRepository.findBySlug(candidate, options);
-      if (!existing) {
-        return candidate;
-      }
-    }
-    throw new AppError(500, "Unable to generate unique workspace slug.");
-  }
-
-  async function ensureWorkspaceSettingsForWorkspace(workspace, options = {}) {
-    return workspaceSettingsRepository.ensureForWorkspaceId(workspace?.id, {
-      ...options,
-      workspace
-    });
-  }
-
-  async function ensurePersonalWorkspaceForUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      throw new AppError(400, "Invalid authenticated user payload.");
-    }
-
-    const existing = await workspacesRepository.findPersonalByOwnerUserId(normalizedUser.id, options);
-    if (existing) {
-      await workspaceMembershipsRepository.ensureOwnerMembership(existing.id, normalizedUser.id, options);
-      await ensureWorkspaceSettingsForWorkspace(existing, options);
-      return existing;
-    }
-
-    const slug = await ensureUniqueWorkspaceSlug(buildWorkspaceBaseSlug(normalizedUser), options);
-    const inserted = await workspacesRepository.insert(
-      {
-        slug,
-        name: buildWorkspaceName(normalizedUser),
-        ownerUserId: normalizedUser.id,
-        isPersonal: true,
-        avatarUrl: ""
-      },
-      options
-    );
-
-    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUser.id, options);
-    await ensureWorkspaceSettingsForWorkspace(inserted, options);
-    return inserted;
-  }
-
-  async function listWorkspacesForUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      return [];
-    }
-
-    if (resolvedTenancyMode === TENANCY_MODE_NONE) {
-      return [];
-    }
-
-    const list = await workspacesRepository.listForUserId(normalizedUser.id, options);
-    const accessible = list
-      .map((entry) => mapWorkspaceSummary(entry, { roleSid: entry.roleSid, status: entry.membershipStatus }))
-      .filter((entry) => entry.isAccessible);
-
-    return accessible;
-  }
-
-  async function listWorkspacesForAuthenticatedUser(user, options = {}) {
-    return listWorkspacesForUser(user, options);
-  }
-
-  async function provisionWorkspaceForNewUser(user, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      throw new AppError(400, "Invalid authenticated user payload.");
-    }
-
-    if (workspacePolicy.autoProvision !== true) {
-      return null;
-    }
-
-    return ensurePersonalWorkspaceForUser(normalizedUser, options);
-  }
-
-  async function createWorkspaceForAuthenticatedUser(user, payload = {}, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      throw new AppError(401, "Authentication required.");
-    }
-
-    if (workspacePolicy.allowSelfCreate !== true) {
-      throw new AppError(403, "Workspace creation is disabled for this tenancy mode.");
-    }
-
-    const createInput = normalizeWorkspaceCreationInput(payload);
-    if (!createInput.name) {
-      throw new AppError(400, "Workspace name is required.");
-    }
-
-    const slugBase = createInput.requestedSlug || toSlugPart(createInput.name);
-    const slug = await ensureUniqueWorkspaceSlug(slugBase, options);
-    const inserted = await workspacesRepository.insert(
-      {
-        slug,
-        name: createInput.name,
-        ownerUserId: normalizedUser.id,
-        isPersonal: false,
-        avatarUrl: ""
-      },
-      options
-    );
-
-    await workspaceMembershipsRepository.ensureOwnerMembership(inserted.id, normalizedUser.id, options);
-    await ensureWorkspaceSettingsForWorkspace(inserted, options);
-    return inserted;
-  }
-
-  async function getWorkspaceForAuthenticatedUser(user, workspaceSlug, options = {}) {
-    const workspaceContext = await resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options);
-    return workspaceContext.workspace;
-  }
-
-  async function updateWorkspaceForAuthenticatedUser(user, workspaceSlug, patch = {}, options = {}) {
-    const workspaceContext = await resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options);
-    return workspacesRepository.updateById(workspaceContext.workspace.id, patch, options);
-  }
-
-  async function resolveWorkspaceContextForUserBySlug(user, workspaceSlug, options = {}) {
-    const normalizedUser = authenticatedUserValidator.normalize(user);
-    if (!normalizedUser) {
-      throw new AppError(401, "Authentication required.");
-    }
-
-    if (resolvedTenancyMode === TENANCY_MODE_NONE) {
-      throw new AppError(403, "Workspace context is disabled.");
-    }
-
-    const normalizedWorkspaceSlug = normalizeLowerText(workspaceSlug);
-    if (!normalizedWorkspaceSlug) {
-      throw new AppError(400, "workspaceSlug is required.");
-    }
-
-    const workspace = await workspacesRepository.findBySlug(normalizedWorkspaceSlug, options);
-
-    if (!workspace) {
-      throw new AppError(404, "Workspace not found.");
-    }
-
-    let membership = await workspaceMembershipsRepository.findByWorkspaceIdAndUserId(
-      workspace.id,
-      normalizedUser.id,
-      options
-    );
-    const actorOwnsWorkspace =
-      normalizeRecordId(workspace.ownerUserId, { fallback: null }) ===
-      normalizeRecordId(normalizedUser.id, { fallback: null });
-    const membershipIsActive = normalizeLowerText(membership?.status) === "active";
-
-    if (!membershipIsActive && actorOwnsWorkspace) {
-      membership = await workspaceMembershipsRepository.ensureOwnerMembership(workspace.id, normalizedUser.id, options);
-    }
-
-    if (!membership || normalizeLowerText(membership.status) !== "active") {
-      throw new AppError(403, "You do not have access to this workspace.");
-    }
-
-    const workspaceSettings = await ensureWorkspaceSettingsForWorkspace(workspace, options);
-    const permissions = buildPermissionsFromMembership(membership, appConfig);
-
-    return {
-      workspace,
-      membership,
-      permissions,
-      workspaceSettings
-    };
-  }
-
-  return Object.freeze({
-    toSlugPart,
-    buildWorkspaceName,
-    buildWorkspaceBaseSlug,
-    hashInviteToken,
-    ensurePersonalWorkspaceForUser,
-    provisionWorkspaceForNewUser,
-    createWorkspaceForAuthenticatedUser,
-    getWorkspaceForAuthenticatedUser,
-    updateWorkspaceForAuthenticatedUser,
-    listWorkspacesForUser,
-    listWorkspacesForAuthenticatedUser,
-    resolveWorkspaceContextForUserBySlug
-  });
-}
-
-export { createService };

package/src/server/common/support/workspaceRoutePaths.js

@@ -1,17 +0,0 @@
-import {
-  USERS_WORKSPACE_API_BASE_PATH,
-  normalizeApiRelativePath
-} from "../../../shared/support/usersApiPaths.js";
-
-const USERS_WORKSPACE_ROUTE_BASE_PATH = USERS_WORKSPACE_API_BASE_PATH;
-
-function resolveWorkspaceRoutePath(relativePath = "/") {
-  const normalizedRelativePath = normalizeApiRelativePath(relativePath);
-  if (normalizedRelativePath === "/") {
-    return USERS_WORKSPACE_ROUTE_BASE_PATH;
-  }
-
-  return `${USERS_WORKSPACE_ROUTE_BASE_PATH}${normalizedRelativePath}`;
-}
-
-export { USERS_WORKSPACE_ROUTE_BASE_PATH, resolveWorkspaceRoutePath };

package/src/server/common/validators/routeParamsValidator.js

@@ -1,62 +0,0 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function normalizeRouteParams(input = {}) {
-  const source = normalizeObjectInput(input);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "workspaceSlug")) {
-    normalized.workspaceSlug = normalizeText(source.workspaceSlug).toLowerCase();
-  }
-
-  if (Object.hasOwn(source, "memberUserId")) {
-    normalized.memberUserId = normalizeText(source.memberUserId);
-  }
-
-  if (Object.hasOwn(source, "inviteId")) {
-    normalized.inviteId = normalizeText(source.inviteId);
-  }
-
-  if (Object.hasOwn(source, "provider")) {
-    normalized.provider = normalizeText(source.provider);
-  }
-
-  return normalized;
-}
-
-function normalizeWorkspaceSlugParams(input = {}) {
-  const source = normalizeObjectInput(input);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "workspaceSlug")) {
-    normalized.workspaceSlug = normalizeText(source.workspaceSlug).toLowerCase();
-  }
-
-  return normalized;
-}
-
-const routeParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspaceSlug: Type.Optional(Type.String({ minLength: 1 })),
-      memberUserId: Type.Optional(Type.String({ minLength: 1 })),
-      inviteId: Type.Optional(Type.String({ minLength: 1 })),
-      provider: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeRouteParams
-});
-
-const workspaceSlugParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspaceSlug: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceSlugParams
-});
-
-export { routeParamsValidator, workspaceSlugParamsValidator };

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,118 +0,0 @@
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveDefaultWorkspaceSurfaceId } from "../../shared/support/workspacePathModel.js";
-
-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 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);
-  });
-}
-
-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,
-  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
-};