@jskit-ai/users-core 0.1.4

package/src/shared/resources/workspaceSettingsResource.js

@@ -0,0 +1,178 @@
+import { Type } from "typebox";
+import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import {
+  normalizeObjectInput,
+  createCursorListValidator
+} from "@jskit-ai/kernel/shared/validators";
+import { workspaceSettingsFields } from "./workspaceSettingsFields.js";
+import { createWorkspaceRoleCatalog } from "../roles.js";
+
+function buildCreateBodySchema() {
+  const properties = {};
+  for (const field of workspaceSettingsFields) {
+    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
+  }
+
+  return Type.Object(properties, {
+    additionalProperties: false,
+    messages: {
+      additionalProperties: "Unexpected field.",
+      default: "Invalid value."
+    }
+  });
+}
+
+function buildSettingsOutputSchema() {
+  const properties = {};
+  for (const field of workspaceSettingsFields) {
+    properties[field.key] = field.outputSchema;
+  }
+  properties.invitesAvailable = Type.Boolean();
+  properties.invitesEffective = Type.Boolean();
+
+  return Type.Object(properties, { additionalProperties: false });
+}
+
+function buildResponseRecordSchema() {
+  return Type.Object(
+    {
+      workspace: Type.Object(
+        {
+          id: Type.Integer({ minimum: 1 }),
+          slug: Type.String({ minLength: 1 }),
+          ownerUserId: Type.Integer({ minimum: 1 })
+        },
+        { additionalProperties: false }
+      ),
+      settings: buildSettingsOutputSchema(),
+      roleCatalog: Type.Object(
+        {
+          collaborationEnabled: Type.Boolean(),
+          defaultInviteRole: Type.String(),
+          roles: Type.Array(Type.Object({}, { additionalProperties: true })),
+          assignableRoleIds: Type.Array(Type.String({ minLength: 1 }))
+        },
+        { additionalProperties: true }
+      )
+    },
+    { additionalProperties: false }
+  );
+}
+
+function normalizeInput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {};
+
+  for (const field of workspaceSettingsFields) {
+    if (!Object.hasOwn(source, field.key)) {
+      continue;
+    }
+    normalized[field.key] = field.normalizeInput(source[field.key], {
+      payload: source
+    });
+  }
+
+  return normalized;
+}
+
+function normalizeOutput(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const workspace = normalizeObjectInput(source.workspace);
+  const settings = normalizeObjectInput(source.settings);
+  const normalizedSettings = {};
+
+  for (const field of workspaceSettingsFields) {
+    const rawValue = Object.hasOwn(settings, field.key)
+      ? settings[field.key]
+      : field.resolveDefault({
+          workspace,
+          settings
+        });
+    normalizedSettings[field.key] = field.normalizeOutput(rawValue, {
+      workspace,
+      settings
+    });
+  }
+
+  const invitesEnabled = normalizedSettings.invitesEnabled !== false;
+  const invitesAvailable = settings.invitesAvailable !== false;
+  const invitesEffective =
+    typeof settings.invitesEffective === "boolean" ? settings.invitesEffective : invitesEnabled;
+  normalizedSettings.invitesEnabled = invitesEnabled;
+  normalizedSettings.invitesAvailable = invitesAvailable;
+  normalizedSettings.invitesEffective = invitesEffective;
+  const roleCatalog = normalizeObjectInput(source.roleCatalog);
+  const hasRoleCatalog =
+    Array.isArray(roleCatalog.roles) &&
+    roleCatalog.roles.length > 0 &&
+    Array.isArray(roleCatalog.assignableRoleIds);
+
+  return {
+    workspace: {
+      id: Number(workspace.id),
+      slug: normalizeText(workspace.slug),
+      ownerUserId: Number(workspace.ownerUserId)
+    },
+    settings: normalizedSettings,
+    roleCatalog: hasRoleCatalog ? roleCatalog : createWorkspaceRoleCatalog()
+  };
+}
+
+const responseRecordValidator = Object.freeze({
+  get schema() {
+    return buildResponseRecordSchema();
+  },
+  normalize: normalizeOutput
+});
+
+const resource = {
+  resource: "workspaceSettings",
+  messages: {
+    validation: "Fix invalid workspace settings values and try again.",
+    saveSuccess: "Workspace settings updated.",
+    saveError: "Unable to update workspace settings.",
+    apiValidation: "Validation failed."
+  },
+  operations: {
+    view: {
+      method: "GET",
+      outputValidator: responseRecordValidator
+    },
+    list: {
+      method: "GET",
+      outputValidator: createCursorListValidator(responseRecordValidator)
+    },
+    create: {
+      method: "POST",
+      bodyValidator: {
+        get schema() {
+          return buildCreateBodySchema();
+        },
+        normalize: normalizeInput
+      },
+      outputValidator: responseRecordValidator
+    },
+    replace: {
+      method: "PUT",
+      bodyValidator: {
+        get schema() {
+          return buildCreateBodySchema();
+        },
+        normalize: normalizeInput
+      },
+      outputValidator: responseRecordValidator
+    },
+    patch: {
+      method: "PATCH",
+      bodyValidator: {
+        get schema() {
+          return Type.Partial(buildCreateBodySchema(), { additionalProperties: false });
+        },
+        normalize: normalizeInput
+      },
+      outputValidator: responseRecordValidator
+    }
+  }
+};
+
+export { resource as workspaceSettingsResource };

package/src/shared/roles.js

@@ -0,0 +1,136 @@
+import {
+  hasPermission,
+  normalizePermissionList
+} from "@jskit-ai/kernel/shared/support";
+
+const OWNER_ROLE_ID = "owner";
+const ADMIN_ROLE_ID = "admin";
+const MEMBER_ROLE_ID = "member";
+
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+function normalizeRoleId(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase();
+}
+
+function createRoleDescriptor(roleId, configuredDefinition) {
+  const source = asRecord(configuredDefinition);
+  const assignable = roleId === OWNER_ROLE_ID ? false : source.assignable === true;
+  const permissions = normalizePermissionList(source.permissions);
+
+  return Object.freeze({
+    id: roleId,
+    assignable,
+    permissions: Object.freeze([...permissions])
+  });
+}
+
+function listConfiguredRoleIds(appConfig = {}) {
+  const configuredRoles = normalizeConfiguredRoles(appConfig);
+  return Object.freeze(Object.keys(configuredRoles));
+}
+
+function resolveConfiguredDefaultInviteRole(appConfig = {}) {
+  return normalizeRoleId(appConfig?.workspaceRoles?.defaultInviteRole);
+}
+
+function normalizeConfiguredRoles(appConfig = {}) {
+  const workspaceRoles = asRecord(appConfig?.workspaceRoles);
+  const configuredRoles = asRecord(workspaceRoles.roles);
+  const normalizedRoles = {};
+
+  for (const [roleId, roleDefinition] of Object.entries(configuredRoles)) {
+    const normalizedRoleId = normalizeRoleId(roleId);
+    if (!normalizedRoleId) {
+      continue;
+    }
+    normalizedRoles[normalizedRoleId] = roleDefinition;
+  }
+
+  return normalizedRoles;
+}
+
+function createWorkspaceRoleCatalog(appConfig = {}) {
+  const configuredRoles = normalizeConfiguredRoles(appConfig);
+  const roleIds = listConfiguredRoleIds(appConfig);
+  const roles = roleIds.map((roleId) => createRoleDescriptor(roleId, configuredRoles[roleId]));
+  const assignableRoleIds = roles.filter((role) => role.assignable).map((role) => role.id);
+  const configuredDefaultInviteRole = resolveConfiguredDefaultInviteRole(appConfig);
+  const defaultInviteRole = assignableRoleIds.includes(configuredDefaultInviteRole)
+    ? configuredDefaultInviteRole
+    : assignableRoleIds[0] || "";
+
+  return Object.freeze({
+    collaborationEnabled: assignableRoleIds.length > 0 && Boolean(defaultInviteRole),
+    defaultInviteRole,
+    roles: Object.freeze(
+      roles.map((role) =>
+        Object.freeze({
+          id: role.id,
+          assignable: role.assignable,
+          permissions: Object.freeze([...role.permissions])
+        })
+      )
+    ),
+    assignableRoleIds: Object.freeze([...assignableRoleIds])
+  });
+}
+
+function cloneWorkspaceRoleCatalog(roleCatalog = null) {
+  const source = asRecord(roleCatalog);
+
+  return {
+    collaborationEnabled: source.collaborationEnabled === true,
+    defaultInviteRole: String(source.defaultInviteRole || ""),
+    roles: Array.isArray(source.roles)
+      ? source.roles.map((role) => ({
+          id: normalizeRoleId(role?.id),
+          assignable: role?.assignable === true,
+          permissions: Array.isArray(role?.permissions) ? [...role.permissions] : []
+        }))
+      : [],
+    assignableRoleIds: Array.isArray(source.assignableRoleIds) ? [...source.assignableRoleIds] : []
+  };
+}
+
+function listRoleDescriptors(appConfig = {}) {
+  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
+  return roleCatalog.roles.map((role) => ({
+    id: role.id,
+    assignable: role.assignable,
+    permissions: [...role.permissions]
+  }));
+}
+
+function resolveRolePermissions(roleId, appConfig = {}) {
+  const normalizedRoleId = normalizeRoleId(roleId);
+  if (!normalizedRoleId) {
+    return [];
+  }
+
+  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
+  const role = roleCatalog.roles.find((entry) => entry.id === normalizedRoleId);
+  if (!role) {
+    return [];
+  }
+
+  return [...role.permissions];
+}
+
+export {
+  OWNER_ROLE_ID,
+  ADMIN_ROLE_ID,
+  MEMBER_ROLE_ID,
+  resolveRolePermissions,
+  listRoleDescriptors,
+  createWorkspaceRoleCatalog,
+  cloneWorkspaceRoleCatalog,
+  hasPermission
+};

package/src/shared/settings.js

@@ -0,0 +1,31 @@
+const DEFAULT_WORKSPACE_COLOR = "#0F6B54";
+
+const DEFAULT_USER_SETTINGS = Object.freeze({
+  theme: "system",
+  locale: "en",
+  timeZone: "UTC",
+  dateFormat: "yyyy-mm-dd",
+  numberFormat: "1,234.56",
+  currencyCode: "USD",
+  avatarSize: 64,
+  productUpdates: true,
+  accountActivity: true,
+  securityAlerts: true,
+  passwordSignInEnabled: true,
+  passwordSetupRequired: false,
+  lastActiveWorkspaceId: null
+});
+
+function coerceWorkspaceColor(value) {
+  const normalized = String(value || "").trim();
+  if (/^#[0-9A-Fa-f]{6}$/.test(normalized)) {
+    return normalized.toUpperCase();
+  }
+  return DEFAULT_WORKSPACE_COLOR;
+}
+
+export {
+  DEFAULT_WORKSPACE_COLOR,
+  DEFAULT_USER_SETTINGS,
+  coerceWorkspaceColor
+};

package/src/shared/support/usersApiPaths.js

@@ -0,0 +1,34 @@
+import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
+
+const USERS_PUBLIC_API_BASE_PATH = "/api";
+const USERS_WORKSPACE_API_BASE_PATH = "/api/w/:workspaceSlug/workspace";
+
+function normalizeApiRelativePath(relativePath = "/") {
+  const normalizedPath = normalizePathname(relativePath);
+  return normalizedPath || "/";
+}
+
+function normalizeSurfaceWorkspaceRequirement(value = false) {
+  return value === true;
+}
+
+function resolveApiBasePath({ surfaceRequiresWorkspace = false, relativePath = "/" } = {}) {
+  const basePath = normalizeSurfaceWorkspaceRequirement(surfaceRequiresWorkspace)
+    ? USERS_WORKSPACE_API_BASE_PATH
+    : USERS_PUBLIC_API_BASE_PATH;
+  const normalizedRelativePath = normalizeApiRelativePath(relativePath);
+
+  if (normalizedRelativePath === "/") {
+    return basePath;
+  }
+
+  return `${basePath}${normalizedRelativePath}`;
+}
+
+export {
+  USERS_PUBLIC_API_BASE_PATH,
+  USERS_WORKSPACE_API_BASE_PATH,
+  normalizeApiRelativePath,
+  normalizeSurfaceWorkspaceRequirement,
+  resolveApiBasePath
+};

package/src/shared/support/usersVisibility.js

@@ -0,0 +1,45 @@
+import { normalizeRouteVisibilityToken } from "@jskit-ai/kernel/shared/support/visibility";
+
+const USERS_ROUTE_VISIBILITY_PUBLIC = "public";
+const USERS_ROUTE_VISIBILITY_USER = "user";
+const USERS_ROUTE_VISIBILITY_WORKSPACE = "workspace";
+const USERS_ROUTE_VISIBILITY_WORKSPACE_USER = "workspace_user";
+
+const USERS_ROUTE_VISIBILITY_LEVELS = Object.freeze([
+  USERS_ROUTE_VISIBILITY_PUBLIC,
+  USERS_ROUTE_VISIBILITY_USER,
+  USERS_ROUTE_VISIBILITY_WORKSPACE,
+  USERS_ROUTE_VISIBILITY_WORKSPACE_USER
+]);
+const USERS_ROUTE_VISIBILITY_LEVEL_SET = new Set(USERS_ROUTE_VISIBILITY_LEVELS);
+
+function normalizeScopedRouteVisibility(value, { fallback = USERS_ROUTE_VISIBILITY_PUBLIC } = {}) {
+  const normalized = normalizeRouteVisibilityToken(value, { fallback: USERS_ROUTE_VISIBILITY_PUBLIC });
+  if (USERS_ROUTE_VISIBILITY_LEVEL_SET.has(normalized)) {
+    return normalized;
+  }
+
+  const normalizedFallback = normalizeRouteVisibilityToken(fallback, { fallback: USERS_ROUTE_VISIBILITY_PUBLIC });
+  if (USERS_ROUTE_VISIBILITY_LEVEL_SET.has(normalizedFallback)) {
+    return normalizedFallback;
+  }
+
+  return USERS_ROUTE_VISIBILITY_PUBLIC;
+}
+
+function isWorkspaceVisibility(visibility = "") {
+  const normalized = normalizeScopedRouteVisibility(visibility, {
+    fallback: USERS_ROUTE_VISIBILITY_PUBLIC
+  });
+  return normalized === USERS_ROUTE_VISIBILITY_WORKSPACE || normalized === USERS_ROUTE_VISIBILITY_WORKSPACE_USER;
+}
+
+export {
+  USERS_ROUTE_VISIBILITY_PUBLIC,
+  USERS_ROUTE_VISIBILITY_USER,
+  USERS_ROUTE_VISIBILITY_WORKSPACE,
+  USERS_ROUTE_VISIBILITY_WORKSPACE_USER,
+  USERS_ROUTE_VISIBILITY_LEVELS,
+  normalizeScopedRouteVisibility,
+  isWorkspaceVisibility
+};

package/src/shared/support/workspacePathModel.js

@@ -0,0 +1,145 @@
+import {
+  deriveSurfaceRouteBaseFromPagesRoot,
+  normalizeSurfaceId
+} from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
+
+function normalizeWorkspaceBasePath(workspaceBasePath = "/w") {
+  return normalizePathname(workspaceBasePath || "/w");
+}
+
+function normalizeSurfaceSegment(segmentLike = "") {
+  const normalizedPath = normalizePathname(segmentLike || "/");
+  if (normalizedPath === "/") {
+    return "";
+  }
+  return normalizedPath.replace(/^\/+/, "");
+}
+
+function normalizeSurfaceRouteBase(routeBaseLike = "") {
+  const rawRouteBase = String(routeBaseLike || "").trim();
+  if (!rawRouteBase || rawRouteBase === "/") {
+    return "/";
+  }
+  const withoutLeadingSlash = rawRouteBase.startsWith("/") ? rawRouteBase.slice(1) : rawRouteBase;
+  return deriveSurfaceRouteBaseFromPagesRoot(withoutLeadingSlash || "");
+}
+
+function normalizeSurfaceSegmentFromRouteBase(routeBase, { workspaceBasePath = "/w" } = {}) {
+  const normalizedRouteBase = normalizeSurfaceRouteBase(routeBase);
+  if (normalizedRouteBase === "/") {
+    return "";
+  }
+
+  const normalizedWorkspaceBasePath = normalizeWorkspaceBasePath(workspaceBasePath);
+  const workspacePlaceholderRoot = `${normalizedWorkspaceBasePath}/:workspaceSlug`;
+  if (normalizedRouteBase === workspacePlaceholderRoot) {
+    return "";
+  }
+  if (normalizedRouteBase.startsWith(`${workspacePlaceholderRoot}/`)) {
+    const remainder = normalizedRouteBase.slice(`${workspacePlaceholderRoot}/`.length);
+    const firstSegment = remainder.split("/").filter(Boolean)[0] || "";
+    return firstSegment.startsWith(":") ? "" : firstSegment;
+  }
+
+  const firstSegment = normalizedRouteBase.replace(/^\/+/, "").split("/").filter(Boolean)[0] || "";
+  if (!firstSegment || firstSegment.startsWith(":")) {
+    return "";
+  }
+  return firstSegment;
+}
+
+function parseWorkspacePathname(pathname = "", { workspaceBasePath = "/w" } = {}) {
+  const normalizedPathname = normalizePathname(pathname);
+  const normalizedWorkspaceBasePath = normalizeWorkspaceBasePath(workspaceBasePath);
+  if (!normalizedPathname.startsWith(`${normalizedWorkspaceBasePath}/`)) {
+    return null;
+  }
+
+  const trailingPath = normalizedPathname.slice(`${normalizedWorkspaceBasePath}/`.length);
+  const segments = trailingPath.split("/").filter(Boolean);
+  if (segments.length < 1) {
+    return null;
+  }
+
+  const [workspaceSlug, ...suffixSegments] = segments;
+  return {
+    workspaceSlug: String(workspaceSlug || "").trim(),
+    suffixSegments
+  };
+}
+
+function resolveDefaultWorkspaceSurfaceId({
+  defaultSurfaceId = "",
+  workspaceSurfaceIds = [],
+  surfaceRequiresWorkspace = null
+} = {}) {
+  const normalizedDefaultSurfaceId = normalizeSurfaceId(defaultSurfaceId);
+  if (
+    normalizedDefaultSurfaceId &&
+    typeof surfaceRequiresWorkspace === "function" &&
+    surfaceRequiresWorkspace(normalizedDefaultSurfaceId)
+  ) {
+    return normalizedDefaultSurfaceId;
+  }
+
+  for (const workspaceSurfaceId of Array.isArray(workspaceSurfaceIds) ? workspaceSurfaceIds : []) {
+    const normalizedWorkspaceSurfaceId = normalizeSurfaceId(workspaceSurfaceId);
+    if (normalizedWorkspaceSurfaceId) {
+      return normalizedWorkspaceSurfaceId;
+    }
+  }
+
+  return normalizedDefaultSurfaceId;
+}
+
+function resolveWorkspaceSurfaceIdFromSuffixSegments({
+  suffixSegments = [],
+  defaultWorkspaceSurfaceId = "",
+  workspaceSurfaces = []
+} = {}) {
+  const normalizedDefaultWorkspaceSurfaceId = normalizeSurfaceId(defaultWorkspaceSurfaceId);
+  if (!Array.isArray(suffixSegments) || suffixSegments.length < 1) {
+    return normalizedDefaultWorkspaceSurfaceId;
+  }
+
+  const suffixPath = suffixSegments.join("/");
+  const candidates = (Array.isArray(workspaceSurfaces) ? workspaceSurfaces : [])
+    .map((entry) => {
+      const surfaceId = normalizeSurfaceId(entry?.surfaceId || entry?.id);
+      if (!surfaceId || surfaceId === normalizedDefaultWorkspaceSurfaceId) {
+        return null;
+      }
+
+      const segment =
+        normalizeSurfaceSegment(entry?.segment) ||
+        normalizeSurfaceSegmentFromRouteBase(entry?.routeBase || entry?.pagesRoot) ||
+        surfaceId;
+      if (!segment) {
+        return null;
+      }
+
+      return {
+        surfaceId,
+        segment
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) => right.segment.length - left.segment.length);
+
+  for (const candidate of candidates) {
+    if (suffixPath === candidate.segment || suffixPath.startsWith(`${candidate.segment}/`)) {
+      return candidate.surfaceId;
+    }
+  }
+
+  return normalizedDefaultWorkspaceSurfaceId;
+}
+
+export {
+  normalizePathname,
+  normalizeSurfaceSegmentFromRouteBase,
+  parseWorkspacePathname,
+  resolveDefaultWorkspaceSurfaceId,
+  resolveWorkspaceSurfaceIdFromSuffixSegments
+};

package/src/shared/tenancyMode.js

@@ -0,0 +1,35 @@
+const TENANCY_MODE_NONE = "none";
+const TENANCY_MODE_PERSONAL = "personal";
+const TENANCY_MODE_WORKSPACE = "workspace";
+
+const TENANCY_MODES = Object.freeze([
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE
+]);
+
+function normalizeTenancyMode(value = "") {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (!TENANCY_MODES.includes(normalized)) {
+    return TENANCY_MODE_NONE;
+  }
+  return normalized;
+}
+
+function isTenancyMode(value = "") {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase();
+  return TENANCY_MODES.includes(normalized);
+}
+
+export {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  TENANCY_MODES,
+  normalizeTenancyMode,
+  isTenancyMode
+};

package/src/shared/tenancyProfile.js

@@ -0,0 +1,73 @@
+import {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  normalizeTenancyMode
+} from "./tenancyMode.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+
+const WORKSPACE_SLUG_POLICY_NONE = "none";
+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 workspacePolicy = isRecord(tenancyPolicy.workspace) ? tenancyPolicy.workspace : {};
+
+  return Object.freeze({
+    allowSelfCreate: typeof workspacePolicy.allowSelfCreate === "boolean" ? workspacePolicy.allowSelfCreate : null
+  });
+}
+
+function resolveWorkspacePolicy(mode, overrides = {}) {
+  if (mode === TENANCY_MODE_NONE) {
+    return Object.freeze({
+      enabled: false,
+      autoProvision: false,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_NONE
+    });
+  }
+
+  if (mode === TENANCY_MODE_PERSONAL) {
+    return Object.freeze({
+      enabled: true,
+      autoProvision: true,
+      allowSelfCreate: false,
+      slugPolicy: WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME
+    });
+  }
+
+  return Object.freeze({
+    enabled: true,
+    autoProvision: false,
+    allowSelfCreate: overrides.allowSelfCreate === true,
+    slugPolicy: WORKSPACE_SLUG_POLICY_USER_SELECTED
+  });
+}
+
+function resolveTenancyProfile(appConfig = {}) {
+  const mode = normalizeTenancyMode(appConfig?.tenancyMode);
+  const workspacePolicyOverrides = resolveWorkspacePolicyOverrides(appConfig);
+
+  return Object.freeze({
+    mode,
+    workspace: resolveWorkspacePolicy(mode, workspacePolicyOverrides)
+  });
+}
+
+function isWorkspaceTenancyMode(value = "") {
+  return normalizeTenancyMode(value) === TENANCY_MODE_WORKSPACE;
+}
+
+export {
+  TENANCY_MODE_NONE,
+  TENANCY_MODE_PERSONAL,
+  TENANCY_MODE_WORKSPACE,
+  normalizeTenancyMode,
+  WORKSPACE_SLUG_POLICY_NONE,
+  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
+  WORKSPACE_SLUG_POLICY_USER_SELECTED,
+  resolveTenancyProfile,
+  isWorkspaceTenancyMode
+};