openxiangda-cli 2.0.0-alpha.86 → 2.0.0-alpha.90

package/template/apps/web/src/platform-client.ts

@@ -1,708 +0,0 @@
-import {
-  SCHEMA_VERSIONS,
-  type DataAuditPage,
-  type DataFilePreview,
-  type DataFileRef,
-  type DataFileUploadPlan,
-  type DataFieldSourcePage,
-  type DataFieldSourceQuery,
-  type DataExportRequest,
-  type DataPage,
-  type DataQuery,
-  type DataWhere,
-  type DataRecord,
-  type DataResourceSurface,
-  type DataTransactionOperation,
-  type DataTransactionRequest,
-  type DataTransactionResult,
-  type DirectoryEntryPage,
-  type DirectoryResolveRequest,
-  type RoleSessionContext,
-  type RoleSubjectChoice,
-  type RoleSubjectChoicePage,
-  type ResourceReferenceValue,
-} from 'openxiangda-contracts/browser';
-import { useSyncExternalStore } from 'react';
-import {
-  buildResourceWhere,
-  type GenericResourceQuery,
-} from './components/platform-fields/resource-query';
-export type { GenericResourceQuery } from './components/platform-fields/resource-query';
-import {
-  applicationApiPath,
-  applicationCode,
-  runtimeMount,
-} from './runtime-meta';
-
-interface PlatformEnvelope<T> {
-  code: number | string;
-  message?: string;
-  errorCode?: string;
-  requestId?: string;
-  data: T;
-}
-
-let globalRequestCount = 0;
-const globalRequestListeners = new Set<() => void>();
-
-function beginGlobalRequest() {
-  globalRequestCount += 1;
-  globalRequestListeners.forEach((listener) => listener());
-}
-
-function endGlobalRequest() {
-  globalRequestCount = Math.max(0, globalRequestCount - 1);
-  globalRequestListeners.forEach((listener) => listener());
-}
-
-export function useGlobalRequestLoading() {
-  return useSyncExternalStore(
-    (listener) => {
-      globalRequestListeners.add(listener);
-      return () => globalRequestListeners.delete(listener);
-    },
-    () => globalRequestCount > 0,
-    () => false
-  );
-}
-
-async function request<T>(path: string, init?: RequestInit): Promise<T> {
-  beginGlobalRequest();
-  try {
-    const headers = new Headers(init?.headers);
-    if (!headers.has('accept')) headers.set('accept', 'application/json');
-    if (init?.body && !headers.has('content-type')) {
-      headers.set('content-type', 'application/json');
-    }
-    if (activeRoleSessionId && roleSessionBoundPath(path)) {
-      headers.set('x-openxiangda-role-session-id', activeRoleSessionId);
-    }
-    const response = await fetch(path, {
-      credentials: 'include',
-      ...init,
-      headers,
-    });
-    const payload = (await response.json().catch(() => null)) as PlatformEnvelope<T> | T | null;
-    const envelope = payload && typeof payload === 'object' && 'code' in payload ? (payload as PlatformEnvelope<T>) : null;
-    if (!response.ok || (envelope && envelope.code !== 200)) {
-      const requestId = envelope?.requestId ? ` (requestId: ${envelope.requestId})` : '';
-      throw Object.assign(
-        new Error(`${envelope?.errorCode || `HTTP_${response.status}`}: ${envelope?.message || '平台请求失败'}${requestId}`),
-        {
-          code: envelope?.errorCode || `HTTP_${response.status}`,
-          status: response.status,
-          data: envelope?.data ?? null,
-        }
-      );
-    }
-    return envelope ? envelope.data : (payload as T);
-  } finally {
-    endGlobalRequest();
-  }
-}
-
-async function requestBlob(path: string, init?: RequestInit) {
-  beginGlobalRequest();
-  try {
-    const headers = new Headers(init?.headers);
-    headers.set('accept', 'text/csv');
-    if (init?.body && !headers.has('content-type')) {
-      headers.set('content-type', 'application/json');
-    }
-    if (activeRoleSessionId && roleSessionBoundPath(path)) {
-      headers.set('x-openxiangda-role-session-id', activeRoleSessionId);
-    }
-    const response = await fetch(path, {
-      credentials: 'include',
-      ...init,
-      headers,
-    });
-    if (!response.ok) {
-      const payload = (await response.json().catch(() => null)) as PlatformEnvelope<unknown> | null;
-      const requestId = payload?.requestId ? ` (requestId: ${payload.requestId})` : '';
-      throw Object.assign(
-        new Error(`${payload?.errorCode || `HTTP_${response.status}`}: ${payload?.message || '平台导出失败'}${requestId}`),
-        {
-          code: payload?.errorCode || `HTTP_${response.status}`,
-          status: response.status,
-          data: payload?.data ?? null,
-        }
-      );
-    }
-    const disposition = response.headers.get('content-disposition') || '';
-    const encodedName = /filename\*=UTF-8''([^;]+)/i.exec(disposition)?.[1];
-    return {
-      blob: await response.blob(),
-      fileName: encodedName ? decodeURIComponent(encodedName) : undefined,
-      rowLimit: Number(response.headers.get('x-openxiangda-export-row-limit') || 10_000),
-    };
-  } finally {
-    endGlobalRequest();
-  }
-}
-
-function roleSessionBoundPath(path: string) {
-  if (path.startsWith(applicationServiceBase())) return true;
-  const mount = runtimeMount();
-  return Boolean(
-    mount &&
-      path.startsWith(
-        `/service/openxiangda-app-api/v2/${encodeURIComponent(mount.appCode)}/${encodeURIComponent(mount.environmentKey)}/`
-      )
-  );
-}
-
-export async function requestApplicationApi<T>(
-  path: string,
-  init?: RequestInit
-) {
-  return await request<T>(applicationApiPath(path), init);
-}
-
-export interface RuntimeIdentity {
-  userId: string;
-  roleCodes: string[];
-  capabilityCodes: string[];
-  isAppSuperAdmin: boolean;
-  identityScope: string;
-  subjectProfile: RoleSessionContext['subjectProfile'] | null;
-  currentRoleSubject: RoleSubjectChoice | null;
-  roleSubjectPage: RoleSubjectChoicePage | null;
-  roleSwitchingAvailable: boolean;
-  environment: {
-    id: string;
-    key: 'preproduction' | 'production';
-    activeAppVersionId?: string;
-    headRevision?: number;
-    authzRevisionId?: string;
-    authzVersion?: number;
-    scopeDataVersion?: string;
-  };
-}
-
-interface ConnectedCurrent {
-  environment: RuntimeIdentity['environment'];
-  principal: Pick<RuntimeIdentity, 'userId' | 'roleCodes' | 'capabilityCodes' | 'isAppSuperAdmin'>;
-}
-
-export interface RuntimeAuthorization {
-  state: RoleSessionContext['state'];
-  identity: RuntimeIdentity | null;
-  roleContext: RoleSessionContext | null;
-}
-
-let activeIdentity: RuntimeIdentity | undefined;
-let activeRoleSessionId: string | undefined;
-
-function applicationServiceBase() {
-  return `/service/openxiangda-api/v2/applications/${applicationCode()}`;
-}
-
-function validateRoleContext(context: RoleSessionContext): RuntimeAuthorization {
-  const mount = runtimeMount();
-  if (
-    !mount ||
-    context.schemaVersion !== SCHEMA_VERSIONS.roleSessionContext ||
-    context.environment.key !== mount.environmentKey
-  ) {
-    throw new Error('OPENXIANGDA_ROLE_SESSION_CONTEXT_INVALID');
-  }
-  if (context.state !== 'active') {
-    if (context.roleSession || context.principal || context.currentRoleSubject) {
-      throw new Error('OPENXIANGDA_ROLE_SESSION_CONTEXT_INACTIVE_INVALID');
-    }
-    activeIdentity = undefined;
-    activeRoleSessionId = undefined;
-    return { state: context.state, identity: null, roleContext: context };
-  }
-  if (
-    !context.roleSession ||
-    !context.principal ||
-    !context.currentRoleSubject ||
-    !context.identityScope ||
-    !context.principal.activeRoleCode ||
-    context.principal.appCode !== mount.appCode ||
-    context.principal.roleSessionId !== context.roleSession.id ||
-    context.principal.activeRoleCode !== context.currentRoleSubject.role.code
-  ) {
-    throw new Error('OPENXIANGDA_ROLE_SESSION_CONTEXT_ACTIVE_INVALID');
-  }
-  activeRoleSessionId = context.roleSession.id;
-  activeIdentity = {
-    userId: context.principal.userId,
-    roleCodes: [context.principal.activeRoleCode],
-    capabilityCodes: context.principal.capabilities,
-    isAppSuperAdmin: context.principal.isAppSuperAdmin,
-    identityScope: context.identityScope,
-    subjectProfile: context.subjectProfile,
-    currentRoleSubject: context.currentRoleSubject,
-    roleSubjectPage: context.roleSubjectPage,
-    roleSwitchingAvailable: true,
-    environment: {
-      id: context.environment.id,
-      key: context.environment.key,
-      activeAppVersionId: context.environment.activeAppVersionId,
-      headRevision: context.environment.headRevision,
-      authzRevisionId: context.principal.authzRevisionId,
-      authzVersion: context.principal.authzVersion,
-      scopeDataVersion: context.principal.scopeDataVersion,
-    },
-  };
-  return { state: context.state, identity: activeIdentity, roleContext: context };
-}
-
-export async function loadRuntimeAuthorization(): Promise<RuntimeAuthorization> {
-  const mount = runtimeMount();
-  if (mount) {
-    const context = await request<RoleSessionContext>(
-      `${nativeBase()}/authz/role-session/context?environmentKey=${encodeURIComponent(mount.environmentKey)}`
-    );
-    return validateRoleContext(context);
-  }
-  const current = await request<ConnectedCurrent>(
-    `${applicationServiceBase()}/dev-sessions/current`
-  );
-  activeRoleSessionId = undefined;
-  activeIdentity = {
-    ...current.principal,
-    identityScope: `connected-dev:${applicationCode()}:${current.environment.key}:${current.principal.userId}`,
-    subjectProfile: null,
-    currentRoleSubject: null,
-    roleSubjectPage: null,
-    roleSwitchingAvailable: false,
-    environment: current.environment,
-  };
-  return { state: 'active', identity: activeIdentity, roleContext: null };
-}
-
-export async function loadRoleSubjects(input: {
-  keyword?: string;
-  cursor?: string;
-  limit?: number;
-} = {}) {
-  const query = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    limit: String(Math.min(Math.max(input.limit || 20, 1), 50)),
-  });
-  if (input.keyword?.trim()) query.set('keyword', input.keyword.trim());
-  if (input.cursor) query.set('cursor', input.cursor);
-  return request<RoleSubjectChoicePage>(
-    `${nativeBase()}/authz/role-session/context/role-subjects?${query}`
-  );
-}
-
-export async function switchRuntimeRole(
-  targetRoleSubjectKey: string,
-  expectedRoleSessionId: string | null
-) {
-  const context = await request<RoleSessionContext>(
-    `${nativeBase()}/authz/role-session/context/switch`,
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        targetRoleSubjectKey,
-        expectedRoleSessionId,
-        environmentKey: currentEnvironmentKey(),
-      }),
-    }
-  );
-  const authorization = validateRoleContext(context);
-  if (!authorization.identity) {
-    throw new Error('OPENXIANGDA_ROLE_SESSION_SWITCH_INACTIVE');
-  }
-  publishRoleSessionInvalidation();
-  return authorization;
-}
-
-const ROLE_SESSION_CHANNEL = 'openxiangda.role-session-context/v2';
-const ROLE_SESSION_STORAGE_KEY =
-  'openxiangda.role-session-context-invalidated/v2';
-
-type RoleSessionInvalidation = {
-  type: 'role-session-context-invalidated';
-  appCode: string;
-  environmentKey: 'preproduction' | 'production';
-  recordedAt: number;
-};
-
-function validRoleSessionInvalidation(
-  value: unknown
-): value is RoleSessionInvalidation {
-  if (!value || typeof value !== 'object') return false;
-  const candidate = value as Partial<RoleSessionInvalidation>;
-  return (
-    candidate.type === 'role-session-context-invalidated' &&
-    typeof candidate.appCode === 'string' &&
-    (candidate.environmentKey === 'preproduction' ||
-      candidate.environmentKey === 'production') &&
-    typeof candidate.recordedAt === 'number'
-  );
-}
-
-function publishRoleSessionInvalidation() {
-  const mount = runtimeMount();
-  if (!mount || typeof window === 'undefined') return;
-  const event: RoleSessionInvalidation = {
-    type: 'role-session-context-invalidated',
-    appCode: mount.appCode,
-    environmentKey: mount.environmentKey,
-    recordedAt: Date.now(),
-  };
-  try {
-    const channel = new BroadcastChannel(ROLE_SESSION_CHANNEL);
-    channel.postMessage(event);
-    channel.close();
-  } catch {
-    // Storage below is the cross-tab fallback.
-  }
-  try {
-    window.localStorage.setItem(ROLE_SESSION_STORAGE_KEY, JSON.stringify(event));
-  } catch {
-    // The active tab has already updated from the server response.
-  }
-}
-
-export function subscribeRoleSessionInvalidation(listener: () => void) {
-  const mount = runtimeMount();
-  if (!mount || typeof window === 'undefined') return () => undefined;
-  const receive = (value: unknown) => {
-    if (
-      validRoleSessionInvalidation(value) &&
-      value.appCode === mount.appCode &&
-      value.environmentKey === mount.environmentKey
-    ) {
-      activeIdentity = undefined;
-      activeRoleSessionId = undefined;
-      listener();
-    }
-  };
-  let channel: BroadcastChannel | undefined;
-  try {
-    channel = new BroadcastChannel(ROLE_SESSION_CHANNEL);
-    channel.onmessage = event => receive(event.data);
-  } catch {
-    channel = undefined;
-  }
-  const onStorage = (event: StorageEvent) => {
-    if (event.key !== ROLE_SESSION_STORAGE_KEY || !event.newValue) return;
-    try {
-      receive(JSON.parse(event.newValue));
-    } catch {
-      // Invalid browser signals never alter the server-owned identity.
-    }
-  };
-  window.addEventListener('storage', onStorage);
-  return () => {
-    channel?.close();
-    window.removeEventListener('storage', onStorage);
-  };
-}
-
-export async function logoutCurrentUser() {
-  await request<null>('/api/auth/logout', {
-    method: 'POST',
-  });
-  activeIdentity = undefined;
-  activeRoleSessionId = undefined;
-}
-
-function currentEnvironmentKey() {
-  const key = activeIdentity?.environment.key || runtimeMount()?.environmentKey;
-  if (!key) throw new Error('OPENXIANGDA_CURRENT_ENVIRONMENT_REQUIRED');
-  return key;
-}
-
-export type DirectoryKind = 'user' | 'department';
-
-export interface ChinaDivisionListItem {
-  adcode: string;
-  citycode?: string;
-  name: string;
-  level?: string;
-  center?: string;
-  parentAdcode?: string;
-  hasChildren: boolean;
-}
-
-export async function loadChinaDivisions(parentAdcode?: string) {
-  const params = new URLSearchParams();
-  if (parentAdcode) params.set('parentAdcode', parentAdcode);
-  const suffix = params.size ? `?${params}` : '';
-  return await request<ChinaDivisionListItem[]>(`/china-divisions/${suffix}`);
-}
-
-export async function searchDirectory(kind: DirectoryKind, options: { keyword: string; cursor?: string }) {
-  const params = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    keyword: options.keyword.trim(),
-    limit: '20',
-  });
-  if (options.cursor) params.set('cursor', options.cursor);
-  return request<DirectoryEntryPage>(`${nativeBase().replace(/\/native$/, '')}/directory/${kind}s?${params}`);
-}
-
-export async function browseDepartmentTree(options: { parentId?: string; cursor?: string }) {
-  const params = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    limit: '100',
-  });
-  if (options.parentId) params.set('parentId', options.parentId);
-  if (options.cursor) params.set('offset', options.cursor);
-  return request<DirectoryEntryPage>(`${nativeBase().replace(/\/native$/, '')}/directory/departments/tree?${params}`);
-}
-
-export async function browseDepartmentUsers(departmentId: string, page = 1) {
-  const params = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    page: String(page),
-    limit: '20',
-  });
-  return request<DirectoryEntryPage>(
-    `${nativeBase().replace(/\/native$/, '')}/directory/departments/${encodeURIComponent(departmentId)}/users?${params}`
-  );
-}
-
-export async function resolveDirectory(kind: DirectoryKind, ids: string[]) {
-  const uniqueIds = [...new Set(ids)];
-  if (uniqueIds.length === 0) throw new Error('OPENXIANGDA_DIRECTORY_RESOLVE_IDS_REQUIRED');
-  if (uniqueIds.length > 50) throw new Error('OPENXIANGDA_DIRECTORY_RESOLVE_IDS_EXCEEDED');
-  const body: DirectoryResolveRequest = {
-    schemaVersion: SCHEMA_VERSIONS.directoryResolveRequest,
-    kind,
-    ids: uniqueIds,
-  };
-  return request<DirectoryEntryPage>(
-    `${nativeBase().replace(/\/native$/, '')}/directory/resolve?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`,
-    { method: 'POST', body: JSON.stringify(body) }
-  );
-}
-
-export async function searchResource(
-  resourceCode: string,
-  fieldCode: string,
-  options: {
-    operation: 'create' | 'update';
-    keyword: string;
-    cursor?: string;
-    bindings?: Record<string, unknown>;
-  }
-) {
-  const query: DataFieldSourceQuery = {
-    schemaVersion: SCHEMA_VERSIONS.dataFieldSourceQuery,
-    operation: options.operation,
-    ...(options.keyword.trim() ? { keyword: options.keyword.trim() } : {}),
-    ...(options.cursor ? { cursor: options.cursor } : {}),
-    ...(options.bindings && Object.keys(options.bindings).length
-      ? { bindings: options.bindings }
-      : {}),
-  };
-  return await request<DataFieldSourcePage>(
-    `${nativeBase()}/data-resources/${encodeURIComponent(
-      resourceCode
-    )}/fields/${encodeURIComponent(fieldCode)}/source/query`,
-    {
-    method: 'POST',
-    body: JSON.stringify({
-      ...query,
-      environmentKey: currentEnvironmentKey(),
-    }),
-    }
-  );
-}
-
-export function createNativeResourceClient(code: string, surface: DataResourceSurface) {
-  const base = dataBase(code);
-  const declaredFields = new Set(Object.keys(surface.fields));
-  const assertField = (field: string) => {
-    if (!declaredFields.has(field)) throw new Error(`OPENXIANGDA_RESOURCE_QUERY_FIELD_NOT_DECLARED:${code}:${field}`);
-    return field;
-  };
-  return {
-    async list(query: GenericResourceQuery) {
-      const fallbackSort = surface.list?.defaultSort || {
-        field: Object.keys(surface.fields)[0] || 'id',
-        order: 'asc' as const,
-      };
-      const requestedSort = query.sort || fallbackSort;
-      const sort = declaredFields.has(requestedSort.field) ? requestedSort : fallbackSort;
-      const where = buildResourceWhere(code, surface, query);
-      const body: DataQuery = {
-        schemaVersion: SCHEMA_VERSIONS.dataQuery,
-        ...(where ? { where } : {}),
-        order: [{ field: sort.field, direction: sort.order || 'asc' }],
-        limit: query.pageSize,
-        offset: (query.page - 1) * query.pageSize,
-      };
-      const page = await request<DataPage<Record<string, unknown>>>(`${base}/query`, {
-        method: 'POST',
-        body: JSON.stringify({
-          ...body,
-          environmentKey: currentEnvironmentKey(),
-        }),
-      });
-      return { rows: page.items, total: page.total };
-    },
-    async exportCsv(query: GenericResourceQuery, select: string[]) {
-      const fallbackSort = surface.list?.defaultSort || {
-        field: Object.keys(surface.fields)[0] || 'id',
-        order: 'asc' as const,
-      };
-      const requestedSort = query.sort || fallbackSort;
-      const sort = declaredFields.has(requestedSort.field) ? requestedSort : fallbackSort;
-      const where = buildResourceWhere(code, surface, query);
-      const body: DataExportRequest = {
-        schemaVersion: SCHEMA_VERSIONS.dataExportRequest,
-        select: select.map(assertField),
-        ...(where ? { where } : {}),
-        order: [{ field: sort.field, direction: sort.order || 'asc' }],
-      };
-      return await requestBlob(`${base}/export`, {
-        method: 'POST',
-        body: JSON.stringify({
-          ...body,
-          environmentKey: currentEnvironmentKey(),
-        }),
-      });
-    },
-    async get(id: string) {
-      const record = await request<DataRecord<Record<string, unknown>>>(
-        `${base}/records/${encodeURIComponent(id)}?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`
-      );
-      return record.data;
-    },
-    async audit(id: string) {
-      return request<DataAuditPage>(
-        `${base}/records/${encodeURIComponent(id)}/audit?limit=10&offset=0&environmentKey=${encodeURIComponent(currentEnvironmentKey())}`
-      );
-    },
-    async create(data: Record<string, unknown>) {
-      const record = await request<DataRecord<Record<string, unknown>>>(`${base}/records`, {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          data,
-        }),
-      });
-      return record.data;
-    },
-    async update(id: string, expectedRevision: number, data: Record<string, unknown>) {
-      const record = await request<DataRecord<Record<string, unknown>>>(`${base}/records/${encodeURIComponent(id)}/update`, {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          expectedRevision,
-          data,
-        }),
-      });
-      return record.data;
-    },
-    async remove(id: string, expectedRevision: number) {
-      const record = await request<DataRecord<Record<string, unknown>>>(`${base}/records/${encodeURIComponent(id)}/delete`, {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          expectedRevision,
-        }),
-      });
-      return record.data;
-    },
-    async upload(fieldCode: string, file: File, recordId?: string) {
-      assertField(fieldCode);
-      const plan = await request<DataFileUploadPlan>(`${base}/files/uploads/initiate`, {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          fieldCode,
-          fileName: file.name,
-          fileSize: file.size,
-          contentType: file.type || 'application/octet-stream',
-          ...(recordId ? { recordId } : {}),
-        }),
-      });
-      const uploaded = await fetch(plan.uploadUrl, {
-        method: plan.uploadMethod,
-        headers: plan.headers,
-        body: file,
-      });
-      if (!uploaded.ok) throw new Error(`FILE_UPLOAD_FAILED: HTTP_${uploaded.status}`);
-      return request<DataFileRef>(`${base}/files/${encodeURIComponent(plan.file.id)}/complete`, {
-        method: 'POST',
-        body: JSON.stringify({ environmentKey: currentEnvironmentKey() }),
-      });
-    },
-  };
-}
-
-export async function transactNativeData(operations: DataTransactionOperation[], idempotencyKey: string = crypto.randomUUID()) {
-  const transaction: DataTransactionRequest = {
-    schemaVersion: SCHEMA_VERSIONS.dataTransactionRequest,
-    idempotencyKey,
-    operations,
-  };
-  return request<DataTransactionResult>(`${nativeBase()}/data/transactions`, {
-    method: 'POST',
-    body: JSON.stringify({
-      ...transaction,
-      environmentKey: currentEnvironmentKey(),
-    }),
-  });
-}
-
-function nativeBase() {
-  return `/service/openxiangda-api/v2/applications/${applicationCode()}/native`;
-}
-
-function dataBase(code: string) {
-  return `${nativeBase()}/data/${encodeURIComponent(code)}`;
-}
-
-export function dataFileContentUrl(resource: string, fileId: string, disposition: 'attachment' | 'inline' = 'attachment') {
-  const query = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    disposition,
-  });
-  return `${dataBase(resource)}/files/${encodeURIComponent(fileId)}/content?${query}`;
-}
-
-export function dataRichTextImageSource(resource: string, fileId: string) {
-  return `${dataBase(resource)}/files/${encodeURIComponent(fileId)}/content?disposition=inline`;
-}
-
-export async function loadDataFilePreview(resource: string, fileId: string) {
-  return request<DataFilePreview>(
-    `${dataBase(resource)}/files/${encodeURIComponent(fileId)}/preview?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`
-  );
-}
-
-export async function fetchDataFileBlob(resource: string, fileId: string) {
-  const headers = new Headers({ accept: 'application/octet-stream,*/*' });
-  if (activeRoleSessionId) {
-    headers.set('x-openxiangda-role-session-id', activeRoleSessionId);
-  }
-  const response = await fetch(dataFileContentUrl(resource, fileId, 'inline'), {
-    credentials: 'include',
-    headers,
-  });
-  if (!response.ok) throw new Error(`FILE_CONTENT_READ_FAILED: HTTP_${response.status}`);
-  return response.blob();
-}
-
-export async function downloadDataFile(
-  resource: string,
-  fileId: string,
-  fileName: string
-) {
-  const blob = await fetchDataFileBlob(resource, fileId);
-  const url = URL.createObjectURL(blob);
-  try {
-    const anchor = document.createElement('a');
-    anchor.href = url;
-    anchor.download = fileName;
-    anchor.rel = 'noopener';
-    document.body.append(anchor);
-    anchor.click();
-    anchor.remove();
-  } finally {
-    window.setTimeout(() => URL.revokeObjectURL(url), 0);
-  }
-}