@csntgao/uni-base 0.1.0

package/packages/web-components/src/uniplat-base-organization-multi-employee-selector-transport.ts

@@ -0,0 +1,394 @@
+import {
+  OrganizationMultiEmployeeSelectorTransportError,
+  type OrganizationDepartmentNode,
+  type OrganizationEmployeeEmploymentStatus,
+  type OrganizationEmployeePage,
+  type OrganizationEmployeeSelectionItem,
+  type UniplatOrganizationMultiEmployeeSelectorTransport,
+} from './organization-multi-employee-selector'
+
+export interface UniplatBaseOrganizationMultiEmployeeSelectorTransportOptions {
+  serviceBaseUrl: string
+  getAccessToken(): string | Promise<string>
+  fetch?: typeof fetch
+}
+
+const DIRECTORY_SERVICE = 'system.org_directory'
+const TREE_ACTION = 'tree_full'
+const NODE_CONTACTS_ACTION = 'node_contacts'
+const SEARCH_ACTION = 'contact_search'
+const CONTACT_GET_ACTION = 'contact_get'
+const REQUEST_TIMEOUT_MS = 15_000
+const RESOLVE_CONCURRENCY = 4
+
+export function createUniplatBaseOrganizationMultiEmployeeSelectorTransport(
+  options: UniplatBaseOrganizationMultiEmployeeSelectorTransportOptions,
+): UniplatOrganizationMultiEmployeeSelectorTransport {
+  if (!options || typeof options.getAccessToken !== 'function') {
+    throw new TypeError('Organization employee selector transport requires getAccessToken()')
+  }
+  const serviceBaseUrl = validateServiceBaseUrl(options.serviceBaseUrl)
+  const fetchImplementation = options.fetch ?? globalThis.fetch
+
+  const request = async (action: string, payload: Record<string, unknown>): Promise<unknown> => {
+    let accessToken = ''
+    try {
+      accessToken = await resolveAccessToken(options.getAccessToken)
+      return await requestData(
+        fetchImplementation,
+        `${serviceBaseUrl}/${DIRECTORY_SERVICE}/${action}`,
+        accessToken,
+        { payload: { directory_scope: 'organization', ...payload } },
+      )
+    } finally {
+      accessToken = ''
+    }
+  }
+
+  return {
+    async loadDepartmentTree(): Promise<OrganizationDepartmentNode[]> {
+      const data = record(await request(TREE_ACTION, {}))
+      if (!Array.isArray(data.nodes)) throw invalidResponse()
+      return data.nodes.map(parseDepartment)
+    },
+
+    async listDepartmentEmployees(input): Promise<OrganizationEmployeePage> {
+      const departmentId = positiveIdentifier(input.departmentId)
+      if (!departmentId) throw new TypeError('departmentId is invalid')
+      const page = positiveInteger(input.page, 'page')
+      const pageSize = boundedPageSize(input.pageSize)
+      validateEmploymentStatuses(input.employmentStatuses)
+      const data = record(
+        await request(NODE_CONTACTS_ACTION, {
+          node_id: departmentId,
+          page,
+          page_size: pageSize,
+        }),
+      )
+      return parseEmployeePage(data, page, pageSize)
+    },
+
+    async searchEmployees(input): Promise<OrganizationEmployeePage> {
+      const page = positiveInteger(input.page, 'page')
+      const pageSize = boundedPageSize(input.pageSize)
+      validateEmploymentStatuses(input.employmentStatuses)
+      const keyword = optionalText(input.keyword, 80)
+      const data = record(
+        await request(SEARCH_ACTION, {
+          keyword,
+          status: 1,
+          employment_status: 'active',
+          page,
+          page_size: pageSize,
+        }),
+      )
+      return parseEmployeePage(data, page, pageSize)
+    },
+
+    async resolveEmployees(input): Promise<OrganizationEmployeeSelectionItem[]> {
+      const employeeIds = uniqueEmployeeIds(input.employeeIds)
+      const employees: OrganizationEmployeeSelectionItem[] = []
+      for (let index = 0; index < employeeIds.length; index += RESOLVE_CONCURRENCY) {
+        const batch = employeeIds.slice(index, index + RESOLVE_CONCURRENCY)
+        const results = await Promise.all(
+          batch.map(async (employeeId) => {
+            const data = record(await request(CONTACT_GET_ACTION, { employee_id: employeeId }))
+            return isSelectableEmployeeRecord(data) ? parseEmployee(data) : null
+          }),
+        )
+        employees.push(
+          ...results.filter(
+            (employee): employee is OrganizationEmployeeSelectionItem => employee !== null,
+          ),
+        )
+      }
+      return employees
+    },
+  }
+}
+
+async function requestData(
+  fetchImplementation: typeof fetch | undefined,
+  endpoint: string,
+  accessToken: string,
+  body: Record<string, unknown>,
+): Promise<unknown> {
+  if (!fetchImplementation) throw requestFailed('REQUEST_FAILED', true)
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
+  let response: Response
+  let payload: unknown
+  try {
+    response = await fetchImplementation(endpoint, {
+      method: 'POST',
+      credentials: 'include',
+      cache: 'no-store',
+      signal: controller.signal,
+      headers: {
+        accept: 'application/json',
+        authorization: `Bearer ${accessToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+    payload = await response.json()
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      throw requestFailed('TIMEOUT', true)
+    }
+    throw requestFailed('REQUEST_FAILED', true)
+  } finally {
+    clearTimeout(timeout)
+  }
+  if (response.status === 401) throw requestFailed('AUTH_REQUIRED', false)
+  if (response.status === 403) throw requestFailed('FORBIDDEN', false)
+  const envelope = record(payload)
+  if (!response.ok || ('rescode' in envelope && integer(envelope.rescode) !== 0)) {
+    const code = optionalText(envelope.error_code, 80)
+    if (code === 'UNAUTHORIZED' || code === 'AUTH_REQUIRED') {
+      throw requestFailed('AUTH_REQUIRED', false)
+    }
+    if (code === 'FORBIDDEN' || code.endsWith('_FORBIDDEN')) {
+      throw requestFailed('FORBIDDEN', false)
+    }
+    throw requestFailed('SERVICE_ERROR', true)
+  }
+  return 'rescode' in envelope ? envelope.data : payload
+}
+
+function parseDepartment(value: unknown): OrganizationDepartmentNode {
+  const data = record(value)
+  const id = positiveIdentifier(data.id)
+  const name = requiredText(data.name, 100)
+  if (!id) throw invalidResponse()
+  const parentId = positiveIdentifier(data.parent_id)
+  const result: OrganizationDepartmentNode = {
+    id,
+    name,
+    depth: nonNegativeInteger(data.depth),
+  }
+  if (parentId) result.parentId = parentId
+  if (data.member_count !== undefined) result.memberCount = nonNegativeInteger(data.member_count)
+  return Object.freeze(result)
+}
+
+function parseEmployeePage(
+  data: Record<string, unknown>,
+  fallbackPage: number,
+  fallbackPageSize: number,
+): OrganizationEmployeePage {
+  if (!Array.isArray(data.items)) throw invalidResponse()
+  const page = positiveIntegerOr(data.page, fallbackPage)
+  const pageSize = positiveIntegerOr(data.page_size, fallbackPageSize)
+  const total = nonNegativeInteger(data.total)
+  const items = dedupeEmployees(data.items.filter(isSelectableEmployeeRecord).map(parseEmployee))
+  return Object.freeze({
+    items,
+    page,
+    pageSize,
+    total,
+    hasMore: page * pageSize < total,
+  })
+}
+
+function isSelectableEmployeeRecord(value: unknown): boolean {
+  const data = record(value)
+  if ('enable' in data && integer(data.enable) !== 1) return false
+  if ('active' in data && integer(data.active) !== 1) return false
+  if ('status' in data && integer(data.status) !== 1) return false
+  return employmentStatus(data.employment_status, data.status) === 'active'
+}
+
+function parseEmployee(value: unknown): OrganizationEmployeeSelectionItem {
+  const data = record(value)
+  const employeeId = positiveIdentifier(data.employee_id ?? data.eid)
+  const displayName = requiredText(data.display_name ?? data.nickname ?? data.name, 80)
+  if (!employeeId) throw invalidResponse()
+  const departments = parseDepartments(data)
+  const primary = parsePrimaryDepartment(data, departments)
+  const maskedMobile = safeMaskedMobile(data.mobile_masked ?? data.mobile)
+  const avatarFileId = optionalText(data.avatar_file_id, 128)
+  const avatarColor = optionalText(data.avatar_color, 32)
+  const result: OrganizationEmployeeSelectionItem = {
+    employeeId,
+    displayName,
+    departmentIds: departments.map(({ id }) => id),
+    departmentNames: departments.map(({ name }) => name),
+    employmentStatus: employmentStatus(data.employment_status, data.status),
+  }
+  if (maskedMobile) result.maskedMobile = maskedMobile
+  if (primary?.id) result.primaryDepartmentId = primary.id
+  if (primary?.name) result.primaryDepartmentName = primary.name
+  if (avatarFileId) result.avatar = Object.freeze({ kind: 'file', fileId: avatarFileId })
+  else if (/^#[0-9a-fA-F]{6}$/.test(avatarColor)) {
+    result.avatar = Object.freeze({ kind: 'color', color: avatarColor })
+  } else result.avatar = Object.freeze({ kind: 'none' })
+  return Object.freeze(result)
+}
+
+function parseDepartments(data: Record<string, unknown>): Array<{ id: string; name: string }> {
+  const departments: Array<{ id: string; name: string }> = []
+  const values = Array.isArray(data.nodes)
+    ? data.nodes
+    : Array.isArray(data.assignments)
+      ? data.assignments
+      : []
+  for (const value of values) {
+    const node = record(value)
+    const id = positiveIdentifier(node.id ?? node.node_id)
+    const name = optionalText(node.name ?? node.node_name, 100)
+    if (id && name && !departments.some((department) => department.id === id)) {
+      departments.push({ id, name })
+    }
+  }
+  const nodeId = positiveIdentifier(data.node_id)
+  const nodeName = optionalText(data.node_name, 100)
+  if (nodeId && nodeName && !departments.some((department) => department.id === nodeId)) {
+    departments.push({ id: nodeId, name: nodeName })
+  }
+  return departments
+}
+
+function parsePrimaryDepartment(
+  data: Record<string, unknown>,
+  departments: readonly { id: string; name: string }[],
+): { id: string; name: string } | null {
+  const primary = record(data.primary_node)
+  const primaryId = positiveIdentifier(primary.id ?? primary.node_id)
+  const primaryName = optionalText(primary.name ?? primary.node_name, 100)
+  if (primaryId && primaryName) return { id: primaryId, name: primaryName }
+  if (data.is_primary === true) {
+    const nodeId = positiveIdentifier(data.node_id)
+    const nodeName = optionalText(data.node_name, 100)
+    if (nodeId && nodeName) return { id: nodeId, name: nodeName }
+  }
+  return departments[0] ?? null
+}
+
+function employmentStatus(value: unknown, status: unknown): OrganizationEmployeeEmploymentStatus {
+  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : ''
+  if (normalized === 'active') return 'active'
+  if (normalized === 'pending') return 'pending'
+  if (normalized === 'rejected') return 'rejected'
+  if (normalized === 'left' || normalized === 'departed') return 'left'
+  if (!normalized && integer(status) === 1) return 'active'
+  return 'unknown'
+}
+
+function dedupeEmployees(
+  employees: readonly OrganizationEmployeeSelectionItem[],
+): OrganizationEmployeeSelectionItem[] {
+  return [...new Map(employees.map((employee) => [employee.employeeId, employee])).values()]
+}
+
+function uniqueEmployeeIds(values: readonly string[]): string[] {
+  if (!Array.isArray(values)) throw new TypeError('employeeIds must be an array')
+  const result: string[] = []
+  for (const value of values) {
+    const employeeId = positiveIdentifier(value)
+    if (!employeeId) throw new TypeError('employeeId is invalid')
+    if (!result.includes(employeeId)) result.push(employeeId)
+  }
+  return result
+}
+
+function validateEmploymentStatuses(value: readonly string[]): void {
+  if (!Array.isArray(value) || value.length !== 1 || value[0] !== 'active') {
+    throw new TypeError('Only active employment status is supported')
+  }
+}
+
+function safeMaskedMobile(value: unknown): string {
+  const mobile = optionalText(value, 32)
+  return mobile && !/^1[3-9]\d{9}$/.test(mobile) ? mobile : ''
+}
+
+function positiveInteger(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(`${field} must be a positive integer`)
+  }
+  return value
+}
+
+function boundedPageSize(value: unknown): number {
+  const pageSize = positiveInteger(value, 'pageSize')
+  if (pageSize > 200) throw new TypeError('pageSize must not exceed 200')
+  return pageSize
+}
+
+function positiveIntegerOr(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : fallback
+}
+
+function nonNegativeInteger(value: unknown): number {
+  const normalized = Number(value)
+  return Number.isSafeInteger(normalized) && normalized >= 0 ? normalized : 0
+}
+
+function positiveIdentifier(value: unknown): string {
+  const normalized =
+    typeof value === 'string' || typeof value === 'number' ? String(value).trim() : ''
+  return /^[1-9]\d{0,19}$/.test(normalized) ? normalized : ''
+}
+
+function requiredText(value: unknown, maximumLength: number): string {
+  const normalized = optionalText(value, maximumLength)
+  if (!normalized) throw invalidResponse()
+  return normalized
+}
+
+function optionalText(value: unknown, maximumLength: number): string {
+  return typeof value === 'string' ? value.trim().slice(0, maximumLength) : ''
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
+}
+
+function integer(value: unknown): number {
+  const normalized = Number(value)
+  return Number.isFinite(normalized) ? Math.trunc(normalized) : -1
+}
+
+async function resolveAccessToken(provider: () => string | Promise<string>): Promise<string> {
+  let token = ''
+  try {
+    const value = await provider()
+    token = typeof value === 'string' ? value.trim() : ''
+  } catch {
+    // Provider errors can contain credentials and are intentionally discarded.
+  }
+  if (!token) throw requestFailed('AUTH_REQUIRED', false)
+  return token
+}
+
+function validateServiceBaseUrl(value: string): string {
+  const raw = typeof value === 'string' ? value.trim() : ''
+  if (!raw) throw new TypeError('Organization employee selector serviceBaseUrl is required')
+  const base = typeof document === 'undefined' ? 'https://localhost/' : document.baseURI
+  let parsed: URL
+  try {
+    parsed = new URL(raw, base)
+  } catch {
+    throw new TypeError('Organization employee selector serviceBaseUrl is invalid')
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password) {
+    throw new TypeError('Organization employee selector serviceBaseUrl must use safe HTTP(S)')
+  }
+  if (parsed.search || parsed.hash) {
+    throw new TypeError(
+      'Organization employee selector serviceBaseUrl must not contain query or hash',
+    )
+  }
+  return parsed.href.replace(/\/$/, '')
+}
+
+function requestFailed(code: string, retryable: boolean) {
+  return new OrganizationMultiEmployeeSelectorTransportError(code, retryable)
+}
+
+function invalidResponse() {
+  return requestFailed('INVALID_RESPONSE', false)
+}

package/packages/web-components/src/uniplat-base-organization-onboarding-transport.ts

@@ -0,0 +1,183 @@
+import {
+  OrganizationOnboardingTransportError,
+  type CreatedOnboardingOrganization,
+  type OnboardingOrganizationType,
+  type OrganizationOnboardingTransport,
+  type OrganizationOnboardingTransportErrorCode,
+} from './organization-onboarding-transport'
+
+export interface UniplatBaseOrganizationOnboardingTransportOptions {
+  serviceBaseUrl: string
+  getAccessToken(): string | Promise<string>
+  fetch?: typeof fetch
+}
+
+const CREATE_PATH = 'system.org/create_organization'
+
+export function createUniplatBaseOrganizationOnboardingTransport(
+  options: UniplatBaseOrganizationOnboardingTransportOptions,
+): OrganizationOnboardingTransport {
+  if (!options || typeof options.getAccessToken !== 'function') {
+    throw new TypeError('UniplatBase organization onboarding transport requires getAccessToken()')
+  }
+  const serviceBaseUrl = validateServiceBaseUrl(options.serviceBaseUrl)
+  const createEndpoint = `${serviceBaseUrl}/${CREATE_PATH}`
+  const fetchImplementation = options.fetch ?? globalThis.fetch
+
+  const createOrganization = async (
+    body: Record<string, unknown>,
+    expectedType: OnboardingOrganizationType,
+  ): Promise<CreatedOnboardingOrganization> => {
+    let accessToken = ''
+    try {
+      accessToken = requireAccessToken(await options.getAccessToken())
+      const data = await requestData(fetchImplementation, createEndpoint, accessToken, body)
+      return parseCreatedOrganization(data, expectedType)
+    } catch (error) {
+      if (error instanceof OrganizationOnboardingTransportError) throw error
+      throw new OrganizationOnboardingTransportError('UNKNOWN')
+    } finally {
+      accessToken = ''
+    }
+  }
+
+  return {
+    async createEnterprise(request) {
+      return createOrganization(
+        {
+          organization_type: 'enterprise',
+          team_name: requireText(request.organizationName),
+          customer_name: requireText(request.enterpriseName),
+          credit_code: requireText(request.unifiedSocialCreditCode).toUpperCase(),
+        },
+        'enterprise',
+      )
+    },
+    async createTeam(request) {
+      return createOrganization(
+        {
+          organization_type: 'team',
+          team_name: requireText(request.teamName),
+        },
+        'team',
+      )
+    },
+  }
+}
+
+async function requestData(
+  fetchImplementation: typeof fetch | undefined,
+  endpoint: string,
+  accessToken: string,
+  body: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  if (!fetchImplementation) throw new OrganizationOnboardingTransportError('UNKNOWN')
+
+  let response: Response
+  try {
+    response = await fetchImplementation(endpoint, {
+      method: 'POST',
+      credentials: 'include',
+      cache: 'no-store',
+      headers: {
+        accept: 'application/json',
+        authorization: `Bearer ${accessToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+  } catch {
+    throw new OrganizationOnboardingTransportError('UNKNOWN')
+  }
+  if (!response.ok) throw new OrganizationOnboardingTransportError('UNKNOWN')
+
+  let envelope: Record<string, unknown>
+  try {
+    envelope = asRecord(await response.json())
+  } catch {
+    throw new OrganizationOnboardingTransportError('UNKNOWN')
+  }
+  if (number(envelope.rescode) !== 0) {
+    throw new OrganizationOnboardingTransportError(normalizeTransportErrorCode(envelope.error_code))
+  }
+  return asRecord(envelope.data)
+}
+
+function parseCreatedOrganization(
+  data: Record<string, unknown>,
+  expectedType: OnboardingOrganizationType,
+): CreatedOnboardingOrganization {
+  const id = positiveIdentifier(data.oid)
+  const type = data.organization_type
+  const name = text(expectedType === 'enterprise' ? data.customer_name : data.team_name).trim()
+  if (!id || type !== expectedType || !name) {
+    throw new OrganizationOnboardingTransportError('UNKNOWN')
+  }
+  return { id, name, type: expectedType }
+}
+
+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 requireAccessToken(rawValue: unknown): string {
+  const token = typeof rawValue === 'string' ? rawValue.trim() : ''
+  if (!token) throw new OrganizationOnboardingTransportError('UNKNOWN')
+  return token
+}
+
+function requireText(rawValue: unknown): string {
+  const value = typeof rawValue === 'string' ? rawValue.trim() : ''
+  if (!value) throw new OrganizationOnboardingTransportError('UNKNOWN')
+  return value
+}
+
+function positiveIdentifier(value: unknown): string {
+  const normalized =
+    typeof value === 'string'
+      ? value.trim()
+      : typeof value === 'number' && Number.isSafeInteger(value)
+        ? String(value)
+        : ''
+  return /^\d+$/.test(normalized) && normalized !== '0' ? normalized : ''
+}
+
+function asRecord(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 : ''
+}
+
+function number(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : Number.NaN
+}
+
+function normalizeTransportErrorCode(value: unknown): OrganizationOnboardingTransportErrorCode {
+  if (
+    value === 'ENTERPRISE_NAME_CONFLICT' ||
+    value === 'CREDIT_CODE_CONFLICT' ||
+    value === 'TEAM_NAME_CONFLICT'
+  ) {
+    return value
+  }
+  return 'UNKNOWN'
+}

package/packages/web-components/src/uniplat-base-organization-single-employee-selector-transport.ts

@@ -0,0 +1,14 @@
+import {
+  createUniplatBaseOrganizationMultiEmployeeSelectorTransport,
+  type UniplatBaseOrganizationMultiEmployeeSelectorTransportOptions,
+} from './uniplat-base-organization-multi-employee-selector-transport'
+import type { UniplatOrganizationSingleEmployeeSelectorTransport } from './organization-single-employee-selector'
+
+export type UniplatBaseOrganizationSingleEmployeeSelectorTransportOptions =
+  UniplatBaseOrganizationMultiEmployeeSelectorTransportOptions
+
+export function createUniplatBaseOrganizationSingleEmployeeSelectorTransport(
+  options: UniplatBaseOrganizationSingleEmployeeSelectorTransportOptions,
+): UniplatOrganizationSingleEmployeeSelectorTransport {
+  return createUniplatBaseOrganizationMultiEmployeeSelectorTransport(options)
+}