@jskit-ai/users-core 0.1.48 → 0.1.50

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -1,82 +0,0 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { createOperationMessages } from "../operationMessages.js";
-import { normalizeObjectInput, recordIdSchema } from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-
-function normalizePendingInvite(invite) {
-  const id = normalizeRecordId(invite?.id, { fallback: null });
-  const workspaceId = normalizeRecordId(invite?.workspaceId, { fallback: null });
-  const tokenHash = normalizeText(invite?.tokenHash);
-
-  if (!id || !workspaceId || !tokenHash) {
-    return null;
-  }
-
-  return {
-    id,
-    workspaceId,
-    workspaceSlug: normalizeText(invite?.workspaceSlug),
-    workspaceName: normalizeText(invite?.workspaceName || invite?.workspaceSlug),
-    workspaceAvatarUrl: normalizeText(invite?.workspaceAvatarUrl),
-    roleSid: normalizeLowerText(invite?.roleSid || "member") || "member",
-    status: normalizeLowerText(invite?.status || "pending") || "pending",
-    expiresAt: invite?.expiresAt || null,
-    token: encodeInviteTokenHash(tokenHash)
-  };
-}
-
-function normalizePendingInviteList(invites) {
-  return (Array.isArray(invites) ? invites : []).map((invite) => normalizePendingInvite(invite)).filter(Boolean);
-}
-
-const pendingInviteRecordValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      id: recordIdSchema,
-      workspaceId: recordIdSchema,
-      workspaceSlug: Type.String({ minLength: 1 }),
-      workspaceName: Type.String({ minLength: 1 }),
-      workspaceAvatarUrl: Type.String(),
-      roleSid: Type.String({ minLength: 1 }),
-      status: Type.String({ minLength: 1 }),
-      expiresAt: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
-      token: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizePendingInvite
-});
-
-const pendingInvitationsListOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      pendingInvites: Type.Array(pendingInviteRecordValidator.schema)
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      pendingInvites: normalizePendingInviteList(source.pendingInvites)
-    };
-  }
-});
-
-const WORKSPACE_PENDING_INVITATIONS_MESSAGES = createOperationMessages();
-
-const workspacePendingInvitationsResource = Object.freeze({
-  resource: "workspacePendingInvitations",
-  messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
-  operations: Object.freeze({
-    list: Object.freeze({
-      method: "GET",
-      messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
-      outputValidator: pendingInvitationsListOutputValidator
-    })
-  })
-});
-
-export { workspacePendingInvitationsResource };

package/src/shared/resources/workspaceResource.js

@@ -1,176 +0,0 @@
-import { Type } from "typebox";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  createCursorListValidator,
-  recordIdSchema,
-  recordIdInputSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-
-function normalizeWorkspaceAvatarUrl(value) {
-  const avatarUrl = normalizeText(value);
-  if (!avatarUrl) {
-    return "";
-  }
-  if (!avatarUrl.startsWith("http://") && !avatarUrl.startsWith("https://")) {
-    return null;
-  }
-  try {
-    return new URL(avatarUrl).toString();
-  } catch {
-    return null;
-  }
-}
-
-function normalizeWorkspaceInput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "slug")) {
-    normalized.slug = normalizeLowerText(source.slug);
-  }
-  if (Object.hasOwn(source, "name")) {
-    normalized.name = normalizeText(source.name);
-  }
-  if (Object.hasOwn(source, "ownerUserId")) {
-    normalized.ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: "" });
-  }
-  if (Object.hasOwn(source, "avatarUrl")) {
-    normalized.avatarUrl = normalizeWorkspaceAvatarUrl(source.avatarUrl);
-  }
-  if (Object.hasOwn(source, "isPersonal")) {
-    normalized.isPersonal = source.isPersonal === true;
-  }
-
-  return normalized;
-}
-
-function normalizeWorkspaceOutput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeLowerText(source.slug),
-    name: normalizeText(source.name),
-    ownerUserId: normalizeRecordId(source.ownerUserId, { fallback: "" }),
-    avatarUrl: normalizeText(source.avatarUrl)
-  };
-}
-
-function normalizeWorkspaceListItemOutput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeLowerText(source.slug),
-    name: normalizeText(source.name),
-    avatarUrl: normalizeText(source.avatarUrl),
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    isAccessible: source.isAccessible !== false
-  };
-}
-
-const responseRecordSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    ownerUserId: recordIdSchema,
-    avatarUrl: Type.String()
-  },
-  { additionalProperties: false }
-);
-
-const listItemSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    avatarUrl: Type.String(),
-    roleSid: Type.String({ minLength: 1 }),
-    isAccessible: Type.Boolean()
-  },
-  { additionalProperties: false }
-);
-
-const createRequestBodySchema = Type.Object(
-  {
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    slug: Type.Optional(Type.String({ minLength: 1, maxLength: 120 })),
-    ownerUserId: Type.Optional(recordIdInputSchema)
-  },
-  { additionalProperties: false }
-);
-
-const patchRequestBodySchema = Type.Object(
-  {
-    name: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
-    avatarUrl: Type.Optional(
-      Type.String({
-        pattern: "^(https?://.+)?$",
-        messages: {
-          pattern: "Workspace avatar URL must be a valid absolute URL (http:// or https://).",
-          default: "Workspace avatar URL must be a valid absolute URL (http:// or https://)."
-        }
-      })
-    )
-  },
-  { additionalProperties: false }
-);
-
-const responseRecordValidator = Object.freeze({
-  schema: responseRecordSchema,
-  normalize: normalizeWorkspaceOutput
-});
-
-const workspaceSummaryOutputValidator = Object.freeze({
-  schema: listItemSchema,
-  normalize: normalizeWorkspaceListItemOutput
-});
-
-const resource = {
-  resource: "workspace",
-  messages: {
-    validation: "Fix invalid workspace values and try again.",
-    saveSuccess: "Workspace updated.",
-    saveError: "Unable to update workspace.",
-    apiValidation: "Validation failed."
-  },
-  operations: {
-    view: {
-      method: "GET",
-      outputValidator: responseRecordValidator
-    },
-    list: {
-      method: "GET",
-      outputValidator: createCursorListValidator(workspaceSummaryOutputValidator)
-    },
-    create: {
-      method: "POST",
-      bodyValidator: {
-        schema: createRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
-    },
-    replace: {
-      method: "PUT",
-      bodyValidator: {
-        schema: createRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
-    },
-    patch: {
-      method: "PATCH",
-      bodyValidator: {
-        schema: patchRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
-    }
-  }
-};
-
-export { resource as workspaceResource };

package/src/shared/resources/workspaceSettingsFields.js

@@ -1,59 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
-
-const workspaceSettingsFields = resolveGlobalArrayRegistry("jskit.users-core.workspaceSettingsFields");
-
-function defineField(field = {}) {
-  const key = normalizeText(field.key);
-  if (!key) {
-    throw new TypeError("workspaceSettingsFields.defineField requires field.key.");
-  }
-  if (workspaceSettingsFields.some((entry) => entry.key === key)) {
-    throw new Error(`workspaceSettingsFields.defineField duplicate key: ${key}`);
-  }
-  if (!field.inputSchema || typeof field.inputSchema !== "object") {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires inputSchema.`);
-  }
-  if (!field.outputSchema || typeof field.outputSchema !== "object") {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires outputSchema.`);
-  }
-  const dbColumn = normalizeText(field.dbColumn);
-  if (!dbColumn) {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires dbColumn.`);
-  }
-  if (typeof field.normalizeInput !== "function") {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires normalizeInput.`);
-  }
-  if (typeof field.normalizeOutput !== "function") {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires normalizeOutput.`);
-  }
-  if (typeof field.resolveDefault !== "function") {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires resolveDefault.`);
-  }
-
-  workspaceSettingsFields.push({
-    key,
-    dbColumn,
-    required: field.required !== false,
-    inputSchema: field.inputSchema,
-    outputSchema: field.outputSchema,
-    normalizeInput: field.normalizeInput,
-    normalizeOutput: field.normalizeOutput,
-    resolveDefault: field.resolveDefault
-  });
-}
-
-function resetWorkspaceSettingsFields() {
-  workspaceSettingsFields.splice(0, workspaceSettingsFields.length);
-}
-
-function resolveWorkspaceSettingsFieldKeys() {
-  return workspaceSettingsFields.map((field) => field.key);
-}
-
-export {
-  defineField,
-  resetWorkspaceSettingsFields,
-  resolveWorkspaceSettingsFieldKeys,
-  workspaceSettingsFields
-};

package/src/shared/resources/workspaceSettingsResource.js

@@ -1,169 +0,0 @@
-import { Type } from "typebox";
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  createCursorListValidator,
-  normalizeSettingsFieldInput,
-  recordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-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: recordIdSchema,
-          slug: Type.String({ minLength: 1 }),
-          ownerUserId: recordIdSchema
-        },
-        { 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 = {}) {
-  return normalizeSettingsFieldInput(payload, workspaceSettingsFields);
-}
-
-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: normalizeRecordId(workspace.id, { fallback: "" }),
-      slug: normalizeText(workspace.slug),
-      ownerUserId: normalizeRecordId(workspace.ownerUserId, { fallback: "" })
-    },
-    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

@@ -1,161 +0,0 @@
-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 resolveInheritedRolePermissions(roleSid, configuredRoles = {}, seenRoleIds = new Set()) {
-  if (seenRoleIds.has(roleSid)) {
-    throw new TypeError(`roleCatalog role "${roleSid}" has circular inheritance.`);
-  }
-
-  const source = asRecord(configuredRoles[roleSid]);
-  const inheritedRoleId = normalizeRoleId(source.inherits);
-  const directPermissions = normalizePermissionList(source.permissions);
-  if (!inheritedRoleId) {
-    return directPermissions;
-  }
-
-  if (!Object.hasOwn(configuredRoles, inheritedRoleId)) {
-    throw new TypeError(`roleCatalog role "${roleSid}" inherits unknown role "${inheritedRoleId}".`);
-  }
-
-  const nextSeenRoleIds = new Set(seenRoleIds);
-  nextSeenRoleIds.add(roleSid);
-
-  return normalizePermissionList([
-    ...resolveInheritedRolePermissions(inheritedRoleId, configuredRoles, nextSeenRoleIds),
-    ...directPermissions
-  ]);
-}
-
-function createRoleDescriptor(roleSid, configuredDefinition, configuredRoles = {}) {
-  const source = asRecord(configuredDefinition);
-  const assignable = roleSid === OWNER_ROLE_ID ? false : source.assignable === true;
-  const permissions = resolveInheritedRolePermissions(roleSid, configuredRoles);
-
-  return Object.freeze({
-    id: roleSid,
-    assignable,
-    permissions: Object.freeze([...permissions])
-  });
-}
-
-function listConfiguredRoleIds(appConfig = {}) {
-  const configuredRoles = normalizeConfiguredRoles(appConfig);
-  return Object.freeze(Object.keys(configuredRoles));
-}
-
-function resolveConfiguredDefaultInviteRole(appConfig = {}) {
-  return normalizeRoleId(appConfig?.roleCatalog?.workspace?.defaultInviteRole);
-}
-
-function normalizeConfiguredRoles(appConfig = {}) {
-  const roleCatalog = asRecord(appConfig?.roleCatalog);
-  const configuredRoles = asRecord(roleCatalog.roles);
-  const normalizedRoles = {};
-
-  for (const [roleSid, roleDefinition] of Object.entries(configuredRoles)) {
-    const normalizedRoleId = normalizeRoleId(roleSid);
-    if (!normalizedRoleId) {
-      continue;
-    }
-    normalizedRoles[normalizedRoleId] = roleDefinition;
-  }
-
-  return normalizedRoles;
-}
-
-function createWorkspaceRoleCatalog(appConfig = {}) {
-  const configuredRoles = normalizeConfiguredRoles(appConfig);
-  const roleIds = listConfiguredRoleIds(appConfig);
-  const roles = roleIds.map((roleSid) => createRoleDescriptor(roleSid, configuredRoles[roleSid], configuredRoles));
-  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(roleSid, appConfig = {}) {
-  const normalizedRoleId = normalizeRoleId(roleSid);
-  if (!normalizedRoleId) {
-    return [];
-  }
-
-  const roleCatalog = createWorkspaceRoleCatalog(appConfig);
-  const role = roleCatalog.roles.find((entry) => entry.id === normalizedRoleId);
-  if (!role) {
-    return [];
-  }
-
-  return [...role.permissions];
-}
-
-export {
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  createWorkspaceRoleCatalog,
-  cloneWorkspaceRoleCatalog,
-  hasPermission
-};

package/src/shared/support/usersApiPaths.js

@@ -1,43 +0,0 @@
-import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
-import { splitPathQueryAndHash } from "@jskit-ai/kernel/shared/support";
-
-const USERS_PUBLIC_API_BASE_PATH = "/api";
-const USERS_WORKSPACE_API_BASE_PATH = "/api/w/:workspaceSlug";
-
-function normalizeApiRelativePath(relativePath = "/") {
-  const { pathname, queryString, hash } = splitPathQueryAndHash(relativePath);
-  const normalizedPath = normalizePathname(pathname || "/") || "/";
-  const normalizedQueryString = String(queryString || "").trim().replace(/^\?+/, "");
-  const normalizedHash = String(hash || "").trim();
-  const querySuffix = normalizedQueryString ? `?${normalizedQueryString}` : "";
-  return `${normalizedPath}${querySuffix}${normalizedHash}`;
-}
-
-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;
-  }
-
-  if (normalizedRelativePath.startsWith("/?") || normalizedRelativePath.startsWith("/#")) {
-    return `${basePath}${normalizedRelativePath.slice(1)}`;
-  }
-
-  return `${basePath}${normalizedRelativePath}`;
-}
-
-export {
-  USERS_PUBLIC_API_BASE_PATH,
-  USERS_WORKSPACE_API_BASE_PATH,
-  normalizeApiRelativePath,
-  normalizeSurfaceWorkspaceRequirement,
-  resolveApiBasePath
-};