@csntgao/uni-base 0.1.0

package/packages/web-components/src/uniplat-base-account-context-transport.ts

@@ -0,0 +1,625 @@
+import type {
+  AccountContextOrganization,
+  AccountContextEmployeeInfo,
+  AccountContextProjection,
+  AccountContextUser,
+} from './account-context'
+import { normalizeSafeImageUrl } from './safe-image-url'
+import {
+  createApplicationTicketLaunchResult,
+  resolveUniplatBaseApplicationEntryUrl,
+} from './uniplat-base-application-ticket'
+import type { ApplicationLaunchResult } from './application-switcher-transport'
+
+export type AccountContextApplicationScope = 'open' | 'organization'
+
+export type UniplatBaseAccountContextTransportErrorCode =
+  | 'AUTH_REQUIRED'
+  | 'INVALID_RESPONSE'
+  | 'ORGANIZATION_UNAVAILABLE'
+  | 'ORGANIZATION_SWITCH_UNSUPPORTED'
+  | 'REQUEST_FAILED'
+  | 'TOKEN_PERSIST_FAILED'
+
+export interface UniplatBaseAccountContextIdentity {
+  xid: string
+  oid: string
+  eid: string
+  mid: string
+  applicationName: string
+  applicationScope: AccountContextApplicationScope
+}
+
+export interface UniplatBaseAccountContextProjection extends AccountContextProjection {
+  applicationName: string
+  applicationScope: AccountContextApplicationScope
+  user: AccountContextUser
+  currentIdentity: UniplatBaseAccountContextIdentity
+  currentOrganization: AccountContextOrganization | null
+  currentOrganizationId: string | null
+  organizations: readonly AccountContextOrganization[]
+}
+
+export interface UniplatBaseAccountContextTransport {
+  load(applicationName: string): Promise<UniplatBaseAccountContextProjection>
+  loadCurrentEmployeeInfo(): Promise<AccountContextEmployeeInfo>
+  switchOrganization(
+    applicationName: string,
+    organizationId: string,
+  ): Promise<UniplatBaseAccountContextProjection>
+  launchAccountSettings(applicationName?: string): Promise<ApplicationLaunchResult>
+}
+
+export interface UniplatBaseAccountContextTransportOptions {
+  serviceBaseUrl: string
+  getAccessToken(): string | Promise<string>
+  setAccessToken(
+    accessToken: string,
+    metadata: UniplatBaseAccountContextProjection,
+  ): void | Promise<void>
+  fetch?: typeof fetch
+}
+
+interface ApplicationTarget {
+  xid: string
+  oid: string
+  applicationName: string
+  applicationScope: AccountContextApplicationScope
+}
+
+interface LoadedContext {
+  projection: UniplatBaseAccountContextProjection
+  targets: readonly ApplicationTarget[]
+}
+
+const LIST_PATH = 'application.identity/list_available_applications'
+const ORGANIZATIONS_PATH = 'application.identity/list_available_organizations'
+const SWITCH_PATH = 'application.identity/switch_current_application'
+const CURRENT_EMPLOYEE_INFO_PATH = 'system.employee_profile/get_current_employee_info'
+const PERSONAL_CENTER_ENTRY_URL = '/personal'
+
+export class UniplatBaseAccountContextTransportError extends Error {
+  readonly code: UniplatBaseAccountContextTransportErrorCode
+
+  constructor(code: UniplatBaseAccountContextTransportErrorCode, message: string) {
+    super(message)
+    this.name = 'UniplatBaseAccountContextTransportError'
+    this.code = code
+  }
+}
+
+export function createUniplatBaseAccountContextTransport(
+  options: UniplatBaseAccountContextTransportOptions,
+): UniplatBaseAccountContextTransport {
+  if (!options || typeof options.getAccessToken !== 'function') {
+    throw new TypeError('UniplatBase account context transport requires getAccessToken()')
+  }
+  if (typeof options.setAccessToken !== 'function') {
+    throw new TypeError('UniplatBase account context transport requires setAccessToken()')
+  }
+  const serviceBaseUrl = validateServiceBaseUrl(options.serviceBaseUrl)
+  const listEndpoint = `${serviceBaseUrl}/${LIST_PATH}`
+  const organizationsEndpoint = `${serviceBaseUrl}/${ORGANIZATIONS_PATH}`
+  const switchEndpoint = `${serviceBaseUrl}/${SWITCH_PATH}`
+  const currentEmployeeInfoEndpoint = `${serviceBaseUrl}/${CURRENT_EMPLOYEE_INFO_PATH}`
+  const fetchImplementation = options.fetch ?? globalThis.fetch
+
+  const loadContext = async (
+    applicationName: string,
+    accessToken: string,
+  ): Promise<LoadedContext> => {
+    const [applicationsData, organizationsData] = await Promise.all([
+      requestData(fetchImplementation, listEndpoint, accessToken, {}, false),
+      requestData(
+        fetchImplementation,
+        organizationsEndpoint,
+        accessToken,
+        { application_name: applicationName },
+        false,
+      ),
+    ])
+    return parseLoadedContext(applicationsData, organizationsData, applicationName, serviceBaseUrl)
+  }
+
+  return {
+    async load(applicationName) {
+      const normalizedApplicationName = requiredText(applicationName, 'applicationName', 255)
+      const accessToken = await resolveAccessToken(options.getAccessToken)
+      return (await loadContext(normalizedApplicationName, accessToken)).projection
+    },
+
+    async loadCurrentEmployeeInfo() {
+      const accessToken = await resolveAccessToken(options.getAccessToken)
+      const data = await requestData(
+        fetchImplementation,
+        currentEmployeeInfoEndpoint,
+        accessToken,
+        {},
+        false,
+      )
+      return parseCurrentEmployeeInfo(data)
+    },
+
+    async switchOrganization(applicationName, organizationId) {
+      const normalizedApplicationName = requiredText(applicationName, 'applicationName', 255)
+      const normalizedOrganizationId = positiveIdentifier(organizationId)
+      if (!normalizedOrganizationId) {
+        throw new UniplatBaseAccountContextTransportError(
+          'ORGANIZATION_UNAVAILABLE',
+          'Organization is unavailable',
+        )
+      }
+
+      const accessToken = await resolveAccessToken(options.getAccessToken)
+      const current = await loadContext(normalizedApplicationName, accessToken)
+      if (
+        !current.projection.organizations.some(
+          (organization) => organization.id === normalizedOrganizationId,
+        )
+      ) {
+        throw new UniplatBaseAccountContextTransportError(
+          'ORGANIZATION_UNAVAILABLE',
+          'Organization is unavailable',
+        )
+      }
+
+      const body = switchRequestBody(current, normalizedOrganizationId)
+      const switchedData = await requestData(
+        fetchImplementation,
+        switchEndpoint,
+        accessToken,
+        body,
+        true,
+      )
+      const nextAccessToken = accessTokenFromResponse(switchedData)
+      const projection = (await loadContext(normalizedApplicationName, nextAccessToken)).projection
+      if (projection.currentOrganizationId !== normalizedOrganizationId) {
+        throw invalidResponse()
+      }
+      try {
+        await options.setAccessToken(nextAccessToken, projection)
+      } catch {
+        throw new UniplatBaseAccountContextTransportError(
+          'TOKEN_PERSIST_FAILED',
+          'Account context token could not be saved',
+        )
+      }
+      return projection
+    },
+
+    async launchAccountSettings(applicationName) {
+      const accessToken = await resolveAccessToken(options.getAccessToken)
+      const targetApplicationName = requiredText(applicationName, 'applicationName', 255)
+      const entryUrl = resolveUniplatBaseApplicationEntryUrl(PERSONAL_CENTER_ENTRY_URL)
+      try {
+        const data = await requestData(
+          fetchImplementation,
+          switchEndpoint,
+          accessToken,
+          {
+            application_name: targetApplicationName,
+            response_type: 'ticket',
+            entry_url: entryUrl,
+          },
+          false,
+        )
+        return createApplicationTicketLaunchResult(entryUrl, data.ticket, data.expires_in)
+      } catch (error) {
+        if (error instanceof UniplatBaseAccountContextTransportError) throw error
+        throw new UniplatBaseAccountContextTransportError(
+          'REQUEST_FAILED',
+          'Account settings request failed',
+        )
+      }
+    },
+  }
+}
+
+function switchRequestBody(
+  context: LoadedContext,
+  organizationId: string,
+): Record<string, unknown> {
+  const { applicationName, applicationScope } = context.projection
+  if (applicationScope === 'open') {
+    const target = context.targets.find(
+      (candidate) =>
+        candidate.applicationName === applicationName && candidate.applicationScope === 'open',
+    )
+    if (!target) throw invalidResponse()
+    return {
+      application_name: applicationName,
+      xid: target.xid,
+      organization_oid: organizationId,
+    }
+  }
+
+  const target = context.targets.find(
+    (candidate) =>
+      candidate.applicationName === applicationName &&
+      candidate.applicationScope === 'organization' &&
+      candidate.oid === organizationId,
+  )
+  if (!target) {
+    throw new UniplatBaseAccountContextTransportError(
+      'ORGANIZATION_SWITCH_UNSUPPORTED',
+      'Organization switch is unavailable for this application',
+    )
+  }
+  return { application_name: applicationName, xid: target.xid }
+}
+
+async function resolveAccessToken(
+  getAccessToken: UniplatBaseAccountContextTransportOptions['getAccessToken'],
+): Promise<string> {
+  let accessToken: string
+  try {
+    accessToken = await getAccessToken()
+  } catch {
+    throw new UniplatBaseAccountContextTransportError(
+      'AUTH_REQUIRED',
+      'Account context authentication is required',
+    )
+  }
+  const normalized = typeof accessToken === 'string' ? accessToken.trim() : ''
+  if (!normalized) {
+    throw new UniplatBaseAccountContextTransportError(
+      'AUTH_REQUIRED',
+      'Account context authentication is required',
+    )
+  }
+  return normalized
+}
+
+async function requestData(
+  fetchImplementation: typeof fetch | undefined,
+  endpoint: string,
+  accessToken: string,
+  body: Record<string, unknown>,
+  containsToken: boolean,
+): Promise<Record<string, unknown>> {
+  if (!fetchImplementation) {
+    throw new UniplatBaseAccountContextTransportError(
+      'REQUEST_FAILED',
+      'Account context request failed',
+    )
+  }
+  let response: Response
+  let payload: unknown
+  try {
+    response = await fetchImplementation(endpoint, {
+      method: 'POST',
+      credentials: 'include',
+      headers: {
+        accept: 'application/json',
+        authorization: `Bearer ${accessToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+    payload = await response.json()
+  } catch {
+    throw new UniplatBaseAccountContextTransportError(
+      'REQUEST_FAILED',
+      'Account context request failed',
+    )
+  }
+  const envelope = record(payload)
+  if (!response.ok || integer(envelope.rescode) !== 0) {
+    throw new UniplatBaseAccountContextTransportError(
+      'REQUEST_FAILED',
+      'Account context request failed',
+    )
+  }
+  const data = record(envelope.data)
+  if (Object.keys(data).length === 0 || (containsToken && !text(data.token).trim())) {
+    throw invalidResponse()
+  }
+  return data
+}
+
+function parseLoadedContext(
+  applicationsData: Record<string, unknown>,
+  organizationsData: Record<string, unknown>,
+  applicationName: string,
+  serviceBaseUrl: string,
+): LoadedContext {
+  try {
+    const projection = parseProjection(
+      applicationsData,
+      organizationsData,
+      applicationName,
+      serviceBaseUrl,
+    )
+    if (!Array.isArray(applicationsData.available_applications)) throw invalidResponse()
+    const targets = applicationsData.available_applications.map(parseApplicationTarget)
+    if (targets.length === 0) throw invalidResponse()
+    return { projection, targets: Object.freeze(targets) }
+  } catch (error) {
+    if (error instanceof UniplatBaseAccountContextTransportError) throw error
+    throw invalidResponse()
+  }
+}
+
+function parseProjection(
+  applicationsData: Record<string, unknown>,
+  organizationsData: Record<string, unknown>,
+  expectedApplicationName: string,
+  serviceBaseUrl: string,
+): UniplatBaseAccountContextProjection {
+  try {
+    const applicationName = requiredText(
+      organizationsData.application_name,
+      'application_name',
+      255,
+    )
+    const applicationScope = parseApplicationScope(organizationsData.application_scope)
+    if (applicationName !== expectedApplicationName) throw invalidResponse()
+    const currentIdentity = parseCurrentIdentity(applicationsData.current_identity)
+    if (
+      currentIdentity.applicationName !== applicationName ||
+      currentIdentity.applicationScope !== applicationScope
+    ) {
+      throw invalidResponse()
+    }
+    if (
+      !Array.isArray(organizationsData.organizations) ||
+      !Array.isArray(applicationsData.available_applications)
+    ) {
+      throw invalidResponse()
+    }
+    applicationsData.available_applications.forEach(parseApplicationTarget)
+    const organizations = Object.freeze(
+      organizationsData.organizations.map((organization) =>
+        parseOrganization(organization, serviceBaseUrl),
+      ),
+    )
+    const organizationIds = new Set(organizations.map((organization) => organization.id))
+    if (organizationIds.size !== organizations.length) throw invalidResponse()
+    const currentOrganizationId = currentIdentity.oid === '0' ? null : currentIdentity.oid
+    const currentOrganization = currentOrganizationId
+      ? (organizations.find((organization) => organization.id === currentOrganizationId) ?? null)
+      : null
+    if (currentOrganizationId && !currentOrganization) throw invalidResponse()
+    const user = parseUser(organizationsData, currentOrganization)
+    return Object.freeze({
+      applicationName,
+      applicationScope,
+      user,
+      currentIdentity,
+      currentOrganization,
+      currentOrganizationId,
+      organizations,
+    })
+  } catch (error) {
+    if (error instanceof UniplatBaseAccountContextTransportError) throw error
+    throw invalidResponse()
+  }
+}
+
+function parseUser(
+  data: Record<string, unknown>,
+  currentOrganization: AccountContextOrganization | null,
+): AccountContextUser {
+  const displayName =
+    text(data.display_name).trim().slice(0, 80) ||
+    currentOrganization?.employeeDisplayName ||
+    '用户'
+  const maskedMobile = text(data.mobile_masked).trim()
+  const result: AccountContextUser = { displayName }
+  if (maskedMobile && !/^1[3-9]\d{9}$/.test(maskedMobile)) result.maskedMobile = maskedMobile
+  try {
+    const avatarUrl = normalizeSafeImageUrl(data.avatar_url, 'account-context avatar URL')
+    if (avatarUrl) result.avatarUrl = avatarUrl
+  } catch {
+    // User avatars are cosmetic.  A legacy file locator or a malformed URL
+    // must not prevent account and organization context from loading.
+  }
+  return Object.freeze(result)
+}
+
+function parseCurrentIdentity(value: unknown): UniplatBaseAccountContextIdentity {
+  const identity = record(value)
+  const applicationScope = parseApplicationScope(identity.application_scope)
+  const xid = nonNegativeIdentifier(identity.xid)
+  const oid = nonNegativeIdentifier(identity.oid)
+  const eid = nonNegativeIdentifier(identity.eid)
+  const mid = nonNegativeIdentifier(identity.mid)
+  if (
+    xid === '' ||
+    (applicationScope === 'organization' && xid === '0') ||
+    oid === '' ||
+    eid === '' ||
+    mid === ''
+  ) {
+    throw invalidResponse()
+  }
+  return Object.freeze({
+    xid,
+    oid,
+    eid,
+    mid,
+    applicationName: requiredText(identity.application_name, 'application_name', 255),
+    applicationScope,
+  })
+}
+
+function parseApplicationTarget(value: unknown): ApplicationTarget {
+  const target = record(value)
+  const applicationScope = parseApplicationScope(target.application_scope)
+  const xid = nonNegativeIdentifier(target.xid)
+  const oid = nonNegativeIdentifier(target.oid)
+  if (xid === '' || (applicationScope === 'organization' && xid === '0') || oid === '') {
+    throw invalidResponse()
+  }
+  return Object.freeze({
+    xid,
+    oid,
+    applicationName: requiredText(target.application_name, 'application_name', 255),
+    applicationScope,
+  })
+}
+
+function parseOrganization(value: unknown, serviceBaseUrl: string): AccountContextOrganization {
+  const organization = record(value)
+  const id = positiveIdentifier(organization.oid)
+  const employeeId = positiveIdentifier(organization.eid)
+  if (!id || !employeeId) throw invalidResponse()
+  const type = text(organization.organization_type).trim()
+  if (type !== 'enterprise' && type !== 'team') throw invalidResponse()
+  const name = text(organization.team_name).trim() || `组织 ${id}`
+  const companyName = text(organization.customer_name).trim()
+  const employeeDisplayName = text(organization.employee_display_name).trim()
+  const employeeAvatarUrl = employeeDisplayName
+    ? normalizeEmployeeAvatarUrl(organization.employee_avatar_url, employeeId, serviceBaseUrl)
+    : ''
+  const role = roleLabel(text(organization.role).trim())
+  const memberCount = nonNegativeInteger(organization.member_count)
+  const result: AccountContextOrganization = {
+    id,
+    name,
+    type,
+    role,
+    memberCount,
+  }
+  if (employeeDisplayName) result.employeeDisplayName = employeeDisplayName
+  if (employeeAvatarUrl) result.employeeAvatarUrl = employeeAvatarUrl
+  if (companyName) result.companyName = companyName
+  if (type === 'enterprise') {
+    result.verificationStatus = parseVerificationStatus(organization.verification_status)
+  }
+  return Object.freeze(result)
+}
+
+function parseCurrentEmployeeInfo(value: Record<string, unknown>): AccountContextEmployeeInfo {
+  const primaryDepartment = record(value.primary_department)
+  const departmentName = text(primaryDepartment.name).trim()
+  return Object.freeze({ departmentName: departmentName || null })
+}
+
+function normalizeEmployeeAvatarUrl(
+  value: unknown,
+  employeeId: string,
+  serviceBaseUrl: string,
+): string {
+  const rawValue = text(value).trim()
+  if (!rawValue) return ''
+  const managedPath = rawValue.match(
+    /^(\d+)\/\.root\/\.avatars\/(\d+)\/avatar-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.(?:jpg|png|webp)$/,
+  )
+  if (!managedPath) {
+    return normalizeSafeImageUrl(rawValue, 'account-context employee avatar URL')
+  }
+  const xid = positiveIdentifier(managedPath[1])
+  const pathEmployeeId = positiveIdentifier(managedPath[2])
+  const fileId = managedPath[3]
+  if (!xid || pathEmployeeId !== employeeId || !fileId) throw invalidResponse()
+  const avatarUrl = new URL(`${serviceBaseUrl}/anonymous/system.employee_profile/get_avatar`)
+  avatarUrl.searchParams.set('xid', xid)
+  avatarUrl.searchParams.set('eid', employeeId)
+  avatarUrl.searchParams.set('file_id', fileId)
+  return normalizeSafeImageUrl(avatarUrl.href, 'account-context employee avatar URL')
+}
+
+function parseApplicationScope(value: unknown): AccountContextApplicationScope {
+  if (value === 'open' || value === 'organization') return value
+  throw invalidResponse()
+}
+
+function parseVerificationStatus(
+  value: unknown,
+): 'unverified' | 'pending' | 'rejected' | 'verified' | 'expired' {
+  if (['unverified', 'pending', 'rejected', 'verified', 'expired'].includes(String(value))) {
+    return value as 'unverified' | 'pending' | 'rejected' | 'verified' | 'expired'
+  }
+  throw invalidResponse()
+}
+
+function roleLabel(value: string): string {
+  if (value === 'owner') return '所有者'
+  if (value === 'admin') return '管理员'
+  if (value === 'member') return '成员'
+  return ''
+}
+
+function accessTokenFromResponse(data: Record<string, unknown>): string {
+  const accessToken = text(data.token).trim()
+  if (!accessToken) throw invalidResponse()
+  return accessToken
+}
+
+function validateServiceBaseUrl(rawValue: string): string {
+  const value = typeof rawValue === 'string' ? rawValue.trim() : ''
+  if (!value) throw new TypeError('UniplatBase serviceBaseUrl is required')
+  const documentBase = typeof document === 'undefined' ? 'https://localhost/' : document.baseURI
+  let url: URL
+  try {
+    url = new URL(value, documentBase)
+  } catch {
+    throw new TypeError('UniplatBase serviceBaseUrl is invalid')
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+    throw new TypeError('UniplatBase serviceBaseUrl must use HTTP(S) without user credentials')
+  }
+  if (url.search || url.hash) {
+    throw new TypeError('UniplatBase serviceBaseUrl must not contain query or hash')
+  }
+  return url.href.replace(/\/+$/, '')
+}
+
+function requiredText(value: unknown, label: string, maxLength: number): string {
+  const normalized = text(value).trim()
+  if (!normalized || normalized.length > maxLength) {
+    throw new TypeError(`${label} is invalid`)
+  }
+  return normalized
+}
+
+function positiveIdentifier(value: unknown): string {
+  const normalized = nonNegativeIdentifier(value)
+  return normalized && normalized !== '0' ? normalized : ''
+}
+
+function nonNegativeIdentifier(value: unknown): string {
+  if (typeof value === 'number') {
+    return Number.isSafeInteger(value) && value >= 0 ? String(value) : ''
+  }
+  if (typeof value !== 'string') return ''
+  const normalized = value.trim()
+  return /^\d+$/.test(normalized) ? normalized.replace(/^0+(?=\d)/, '') : ''
+}
+
+function nonNegativeInteger(value: unknown): number {
+  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return value
+  if (typeof value === 'string' && /^\d+$/.test(value.trim())) {
+    const parsed = Number(value)
+    if (Number.isSafeInteger(parsed)) return parsed
+  }
+  throw invalidResponse()
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
+}
+
+function text(value: unknown): string {
+  return typeof value === 'string'
+    ? value
+    : typeof value === 'number' && Number.isFinite(value)
+      ? String(value)
+      : ''
+}
+
+function integer(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isSafeInteger(value)) return value
+  if (typeof value === 'string' && /^-?\d+$/.test(value.trim())) return Number(value)
+  return null
+}
+
+function invalidResponse(): UniplatBaseAccountContextTransportError {
+  return new UniplatBaseAccountContextTransportError(
+    'INVALID_RESPONSE',
+    'Account context response is invalid',
+  )
+}