openxiangda-cli 2.0.0-alpha.60 → 2.0.0-alpha.62

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

@@ -1,26 +1,18 @@
 import {
   SCHEMA_VERSIONS,
+  type DataAuditPage,
   type DataFilePreview,
   type DataFileRef,
   type DataFileUploadPlan,
-  type DataAuditPage,
   type DataPage,
   type DataQuery,
   type DataRecord,
+  type DataResourceSurface,
   type DirectoryEntryPage,
   type DirectoryResolveRequest,
-  type NativeScopeValuePage,
-  type NativeScopeValueResolveRequest,
 } from 'openxiangda-contracts/browser';
-import type { InstrumentListQuery, InstrumentRecord } from './instrument';
-import { isInstrumentResourceField } from './fields';
 import { applicationCode, runtimeMount } from './runtime-meta';
 
-const resourceCode = 'instruments';
-const nativeBase = () =>
-  `/service/openxiangda-api/v2/applications/${applicationCode()}/native`;
-const dataBase = (code = resourceCode) => `${nativeBase()}/data/${code}`;
-
 interface PlatformEnvelope<T> {
   code: number;
   message?: string;
@@ -38,19 +30,12 @@ async function request<T>(path: string, init?: RequestInit): Promise<T> {
       ...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;
+  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 code = envelope?.errorCode || `HTTP_${response.status}`;
-    throw new Error(`${code}: ${envelope?.message || '平台请求失败'}`);
+    throw new Error(`${envelope?.errorCode || `HTTP_${response.status}`}: ${envelope?.message || '平台请求失败'}`);
   }
-  return envelope ? envelope.data : (payload as T);
+  return envelope ? envelope.data : payload as T;
 }
 
 export interface RuntimeIdentity {
@@ -71,33 +56,14 @@ export interface RuntimeIdentity {
 
 interface ConnectedCurrent {
   environment: RuntimeIdentity['environment'];
-  principal: {
-    userId: string;
-    roleCodes: string[];
-    capabilityCodes: string[];
-    isAppSuperAdmin: boolean;
-  };
+  principal: Pick<RuntimeIdentity, 'userId' | 'roleCodes' | 'capabilityCodes' | 'isAppSuperAdmin'>;
 }
 
 interface DeployedCurrent {
   schemaVersion: 'openxiangda.current-user/v2';
   appCode: string;
-  environment: {
-    id: string;
-    key: 'preproduction' | 'production';
-    activeAppVersionId: string;
-    headRevision: number;
-    authzRevisionId: string;
-    authzVersion: number;
-    scopeDataVersion: string;
-  };
-  principal: {
-    type: 'user';
-    userId: string;
-    roleCodes: string[];
-    capabilityCodes: string[];
-    isAppSuperAdmin: boolean;
-  };
+  environment: RuntimeIdentity['environment'];
+  principal: { type: 'user' } & Pick<RuntimeIdentity, 'userId' | 'roleCodes' | 'capabilityCodes' | 'isAppSuperAdmin'>;
 }
 
 let activeIdentity: RuntimeIdentity | undefined;
@@ -105,35 +71,16 @@ let activeIdentity: RuntimeIdentity | undefined;
 export async function loadCurrentIdentity(): Promise<RuntimeIdentity> {
   const mount = runtimeMount();
   if (mount) {
-    const current = await request<DeployedCurrent>(
-      `${nativeBase()}/current-user?environmentKey=${encodeURIComponent(
-        mount.environmentKey
-      )}`
-    );
-    if (
-      current.schemaVersion !== 'openxiangda.current-user/v2' ||
-      current.appCode !== mount.appCode ||
-      current.environment.key !== mount.environmentKey ||
-      current.principal.type !== 'user' ||
-      !Array.isArray(current.principal.roleCodes) ||
-      !Array.isArray(current.principal.capabilityCodes)
-    ) {
+    const current = await request<DeployedCurrent>(`${nativeBase()}/current-user?environmentKey=${encodeURIComponent(mount.environmentKey)}`);
+    if (current.schemaVersion !== 'openxiangda.current-user/v2' || current.appCode !== mount.appCode || current.environment.key !== mount.environmentKey || current.principal.type !== 'user') {
       throw new Error('OPENXIANGDA_DEPLOYED_CURRENT_USER_INVALID');
     }
     activeIdentity = { ...current.principal, environment: current.environment };
     return activeIdentity;
   }
-  const connectedPath =
-    `/service/openxiangda-api/v2/applications/${applicationCode()}/dev-sessions/current`;
-  try {
-    const current = await request<ConnectedCurrent>(connectedPath);
-    activeIdentity = { ...current.principal, environment: current.environment };
-    return activeIdentity;
-  } catch (error) {
-    throw new Error(
-      `OPENXIANGDA_CONNECTED_CURRENT_USER_FAILED: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
+  const current = await request<ConnectedCurrent>(`/service/openxiangda-api/v2/applications/${applicationCode()}/dev-sessions/current`);
+  activeIdentity = { ...current.principal, environment: current.environment };
+  return activeIdentity;
 }
 
 function currentEnvironmentKey() {
@@ -144,349 +91,151 @@ function currentEnvironmentKey() {
 
 export type DirectoryKind = 'user' | 'department';
 
-export async function searchDirectory(
-  kind: DirectoryKind,
-  options: { keyword: string; cursor?: string }
-) {
-  const params = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    keyword: options.keyword.trim(),
-    limit: '20',
-  });
+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}`
-  );
+  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',
-  });
+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}`
-  );
+  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 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[]
-) {
+export async function resolveDirectory(kind: DirectoryKind, ids: string[]) {
   const uniqueIds = [...new Set(ids)];
-  const body: DirectoryResolveRequest = {
-    schemaVersion: SCHEMA_VERSIONS.directoryResolveRequest,
-    kind,
-    ids: uniqueIds,
+  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, labelField: string, options: { keyword: string; cursor?: string }) {
+  const pageSize = 20;
+  const offset = options.cursor ? Number(options.cursor) : 0;
+  const query: DataQuery = {
+    schemaVersion: SCHEMA_VERSIONS.dataQuery,
+    filters: options.keyword.trim() ? [{ field: labelField, operator: 'ilike', value: `%${options.keyword.trim()}%` }] : [],
+    order: [{ field: labelField, direction: 'asc' }],
+    limit: pageSize,
+    offset: Number.isSafeInteger(offset) && offset >= 0 ? offset : 0,
+  };
+  const page = await request<DataPage<Record<string, unknown>>>(`${dataBase(resourceCode)}/query`, { method: 'POST', body: JSON.stringify({ ...query, environmentKey: currentEnvironmentKey() }) });
+  return {
+    items: page.items.map(item => ({ id: String(item.id), label: String(item[labelField] ?? item.id), selectable: true })),
+    nextCursor: page.items.length >= pageSize ? String(page.offset + page.items.length) : null,
   };
-  if (body.ids.length === 0) {
-    throw new Error('OPENXIANGDA_DIRECTORY_RESOLVE_IDS_REQUIRED');
-  }
-  if (body.ids.length > 50) {
-    throw new Error('OPENXIANGDA_DIRECTORY_RESOLVE_IDS_EXCEEDED');
-  }
-  return request<DirectoryEntryPage>(
-    `${nativeBase().replace(/\/native$/, '')}/directory/resolve?environmentKey=${encodeURIComponent(
-      currentEnvironmentKey()
-    )}`,
-    { method: 'POST', body: JSON.stringify(body) }
-  );
-}
-
-const scopeValuesBase = () =>
-  `${nativeBase()}/data-resources/${resourceCode}/fields/collegeId/scope-values`;
-
-export async function searchCollegeScope(
-  operation: 'create' | 'update',
-  options: { keyword: string; cursor?: string }
-) {
-  const params = new URLSearchParams({
-    environmentKey: currentEnvironmentKey(),
-    dimensionCode: 'college',
-    operation,
-    keyword: options.keyword.trim(),
-    limit: '20',
-  });
-  if (options.cursor) params.set('cursor', options.cursor);
-  return request<NativeScopeValuePage>(`${scopeValuesBase()}?${params}`);
 }
 
-export async function resolveCollegeScope(
-  operation: 'create' | 'update',
-  values: string[]
-) {
-  const uniqueValues = [...new Set(values)];
-  const body: NativeScopeValueResolveRequest = {
-    schemaVersion: SCHEMA_VERSIONS.nativeScopeValueResolveRequest,
-    dimensionCode: 'college',
-    operation,
-    values: uniqueValues,
-  };
-  if (body.values.length === 0) {
-    throw new Error('OPENXIANGDA_SCOPE_RESOLVE_VALUES_REQUIRED');
-  }
-  if (body.values.length > 50) {
-    throw new Error('OPENXIANGDA_SCOPE_RESOLVE_VALUES_EXCEEDED');
-  }
-  return request<NativeScopeValuePage>(
-    `${scopeValuesBase()}/resolve?environmentKey=${encodeURIComponent(
-      currentEnvironmentKey()
-    )}`,
-    { method: 'POST', body: JSON.stringify(body) }
-  );
+export async function resolveResource(resourceCode: string, ids: string[], labelField: string) {
+  if (ids.length === 0) throw new Error('OPENXIANGDA_RESOURCE_RESOLVE_IDS_REQUIRED');
+  if (ids.length > 50) throw new Error('OPENXIANGDA_RESOURCE_RESOLVE_IDS_EXCEEDED');
+  const items = await Promise.all(ids.map(async id => {
+    const record = await request<DataRecord<Record<string, unknown>>>(`${dataBase(resourceCode)}/records/${encodeURIComponent(id)}?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`);
+    return { id, label: String(record.data[labelField] ?? id), selectable: true };
+  }));
+  return { items, nextCursor: null };
 }
 
-export interface InstrumentDataApiAdapter {
-  list(query: InstrumentListQuery): Promise<{ rows: InstrumentRecord[]; total: number }>;
-  get(id: string): Promise<InstrumentRecord>;
-  audit(id: string): Promise<DataAuditPage>;
-  create(data: Partial<InstrumentRecord>): Promise<InstrumentRecord>;
-  update(id: string, expectedRevision: number, data: Partial<InstrumentRecord>): Promise<InstrumentRecord>;
-  remove(id: string, expectedRevision: number): Promise<InstrumentRecord>;
-  upload(fieldCode: 'image' | 'attachments', file: File, recordId?: string): Promise<DataFileRef>;
+export interface GenericResourceQuery {
+  page: number;
+  pageSize: number;
+  keyword?: string;
+  searchField?: string;
+  filters?: Record<string, unknown>;
+  sort?: { field: string; order: 'asc' | 'desc' };
 }
 
-export const instrumentDataApi: InstrumentDataApiAdapter = {
-  async list(query) {
+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;
+  };
+  const filtersFor = (query: GenericResourceQuery) => {
     const filters: NonNullable<DataQuery['filters']> = [];
-    // The current DataQuery contract has AND filters but no grouped OR. Keep
-    // this honest single-field search until the platform adds a native OR AST.
     if (query.keyword?.trim()) {
-      filters.push({ field: 'chineseName', operator: 'ilike', value: `%${query.keyword.trim()}%` });
-    }
-    if (query.collegeId) filters.push({ field: 'collegeId', operator: 'eq', value: query.collegeId });
-    if (query.instrumentAdminId) filters.push({ field: 'instrumentAdminIds', operator: 'cs', value: [query.instrumentAdminId] });
-    if (query.instrumentStatus) filters.push({ field: 'instrumentStatus', operator: 'eq', value: query.instrumentStatus });
-    if (query.openToOutside !== undefined) filters.push({ field: 'openToOutside', operator: 'eq', value: query.openToOutside });
-    if (query.enabledDate) {
-      filters.push({ field: 'enabledDate', operator: 'gte', value: query.enabledDate[0] });
-      filters.push({ field: 'enabledDate', operator: 'lte', value: query.enabledDate[1] });
+      const searchable = surface.list?.searchableFields || [];
+      const field = searchable.includes(query.searchField || '') ? query.searchField! : searchable[0];
+      if (field) filters.push({ field: assertField(field), operator: 'ilike', value: `%${query.keyword.trim()}%` });
     }
-    if (query.assetValue?.[0] !== undefined) filters.push({ field: 'assetValue', operator: 'gte', value: query.assetValue[0] });
-    if (query.assetValue?.[1] !== undefined) filters.push({ field: 'assetValue', operator: 'lte', value: query.assetValue[1] });
-    const body: DataQuery = {
-      schemaVersion: SCHEMA_VERSIONS.dataQuery,
-      filters,
-      order: [{ field: String(query.sort?.field || 'instrumentCode'), direction: query.sort?.order || 'asc' }],
-      limit: query.pageSize,
-      offset: (query.page - 1) * query.pageSize,
-    };
-    assertInstrumentQueryFields(body);
-    const page = await request<DataPage<InstrumentRecord>>(`${dataBase()}/query`, {
-      method: 'POST',
-      body: JSON.stringify({ ...body, environmentKey: currentEnvironmentKey() }),
-    });
-    return { rows: page.items, total: page.total };
-  },
-  async get(id) {
-    const record = await request<DataRecord<InstrumentRecord>>(
-      `${dataBase()}/records/${encodeURIComponent(
-        id
-      )}?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`
-    );
-    return record.data;
-  },
-  async audit(id) {
-    return await request<DataAuditPage>(
-      `${dataBase()}/records/${encodeURIComponent(
-        id
-      )}/audit?limit=10&offset=0&environmentKey=${encodeURIComponent(
-        currentEnvironmentKey()
-      )}`
-    );
-  },
-  async create(data) {
-    const record = await request<DataRecord<InstrumentRecord>>(`${dataBase()}/records`, {
-      method: 'POST',
-      body: JSON.stringify({ environmentKey: currentEnvironmentKey(), data }),
-    });
-    return record.data;
-  },
-  async update(id, expectedRevision, data) {
-    const record = await request<DataRecord<InstrumentRecord>>(
-      `${dataBase()}/records/${encodeURIComponent(id)}/update`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          expectedRevision,
-          data,
-        }),
-      }
-    );
-    return record.data;
-  },
-  async remove(id, expectedRevision) {
-    const record = await request<DataRecord<InstrumentRecord>>(
-      `${dataBase()}/records/${encodeURIComponent(id)}/delete`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          expectedRevision,
-        }),
-      }
-    );
-    return record.data;
-  },
-  async upload(fieldCode, file, recordId) {
-    const plan = await request<DataFileUploadPlan>(`${dataBase()}/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 await request<DataFileRef>(
-      `${dataBase()}/files/${encodeURIComponent(plan.file.id)}/complete`,
-      {
-        method: 'POST',
-        body: JSON.stringify({ environmentKey: currentEnvironmentKey() }),
+    for (const [fieldCode, value] of Object.entries(query.filters || {})) {
+      if (value === undefined || value === null || value === '') continue;
+      const field = surface.fields[assertField(fieldCode)];
+      if (Array.isArray(value) && value.length === 2 && ['date', 'datetime', 'number', 'money', 'percent'].includes(field?.widget || '')) {
+        if (value[0] !== undefined && value[0] !== null && value[0] !== '') filters.push({ field: fieldCode, operator: 'gte', value: value[0] });
+        if (value[1] !== undefined && value[1] !== null && value[1] !== '') filters.push({ field: fieldCode, operator: 'lte', value: value[1] });
+      } else if (Array.isArray(value) && ['multi', 'directory-user', 'directory-department', 'resource'].includes(field?.widget || '')) {
+        filters.push({ field: fieldCode, operator: 'cs', value });
+      } else {
+        filters.push({ field: fieldCode, operator: 'eq', value });
       }
-    );
-  },
-};
-
-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.toString()}`;
+    }
+    return filters;
+  };
+  return {
+    async list(query: GenericResourceQuery) {
+      const sort = query.sort || surface.list?.defaultSort || { field: Object.keys(surface.fields)[0] || 'id', order: 'asc' as const };
+      const body: DataQuery = { schemaVersion: SCHEMA_VERSIONS.dataQuery, filters: filtersFor(query), order: [{ field: assertField(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 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 loadDataFilePreview(
-  resource: string,
-  fileId: string
-) {
-  return await request<DataFilePreview>(
-    `${dataBase(resource)}/files/${encodeURIComponent(
-      fileId
-    )}/preview?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`
-  );
+function nativeBase() {
+  return `/service/openxiangda-api/v2/applications/${applicationCode()}/native`;
 }
 
-export async function fetchDataFileBlob(resource: string, fileId: string) {
-  const response = await fetch(dataFileContentUrl(resource, fileId, 'inline'), {
-    credentials: 'include',
-    headers: { accept: 'application/octet-stream,*/*' },
-  });
-  if (!response.ok) {
-    const payload = (await response.json().catch(() => null)) as
-      | PlatformEnvelope<null>
-      | null;
-    const code = payload?.errorCode || `HTTP_${response.status}`;
-    throw new Error(`${code}: ${payload?.message || '文件内容读取失败'}`);
-  }
-  return await response.blob();
+function dataBase(code: string) {
+  return `${nativeBase()}/data/${encodeURIComponent(code)}`;
 }
 
-export interface CollegeRecord extends Record<string, unknown> {
-  id: string;
-  revision: number;
-  name: string;
-  enabled: boolean;
+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 const collegeDataApi = {
-  async list(page = 1, pageSize = 20) {
-    const body: DataQuery = {
-      schemaVersion: SCHEMA_VERSIONS.dataQuery,
-      order: [{ field: 'name', direction: 'asc' }],
-      limit: pageSize,
-      offset: (page - 1) * pageSize,
-    };
-    const result = await request<DataPage<CollegeRecord>>(
-      `${dataBase('colleges')}/query`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          ...body,
-          environmentKey: currentEnvironmentKey(),
-        }),
-      }
-    );
-    return { rows: result.items, total: result.total };
-  },
-  async create(data: Pick<CollegeRecord, 'name' | 'enabled'>) {
-    const record = await request<DataRecord<CollegeRecord>>(
-      `${dataBase('colleges')}/records`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          data,
-        }),
-      }
-    );
-    return record.data;
-  },
-  async update(
-    id: string,
-    expectedRevision: number,
-    data: Pick<CollegeRecord, 'name' | 'enabled'>
-  ) {
-    const record = await request<DataRecord<CollegeRecord>>(
-      `${dataBase('colleges')}/records/${encodeURIComponent(id)}/update`,
-      {
-        method: 'POST',
-        body: JSON.stringify({
-          environmentKey: currentEnvironmentKey(),
-          expectedRevision,
-          data,
-        }),
-      }
-    );
-    return record.data;
-  },
-};
+export async function loadDataFilePreview(resource: string, fileId: string) {
+  return request<DataFilePreview>(`${dataBase(resource)}/files/${encodeURIComponent(fileId)}/preview?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`);
+}
 
-function assertInstrumentQueryFields(query: DataQuery) {
-  for (const field of [
-    ...(query.filters || []).map(filter => filter.field),
-    ...(query.order || []).map(order => order.field),
-  ]) {
-    if (!isInstrumentResourceField(field)) {
-      throw new Error(
-        `OPENXIANGDA_INSTRUMENT_QUERY_FIELD_NOT_DECLARED:${field}`
-      );
-    }
-  }
+export async function fetchDataFileBlob(resource: string, fileId: string) {
+  const response = await fetch(dataFileContentUrl(resource, fileId, 'inline'), { credentials: 'include', headers: { accept: 'application/octet-stream,*/*' } });
+  if (!response.ok) throw new Error(`FILE_CONTENT_READ_FAILED: HTTP_${response.status}`);
+  return response.blob();
 }

package/template/apps/web/src/runtime-meta.ts

@@ -31,7 +31,7 @@ export function runtimeMount() {
 }
 
 export function applicationCode() {
-  return runtimeMount()?.appCode || 'instrument-center';
+  return runtimeMount()?.appCode || 'openxiangda-application';
 }
 
 export function resolveApplicationBasename(mount: RuntimeMount | null) {