openxiangda-cli 2.0.0-alpha.49 → 2.0.0-alpha.56

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

@@ -0,0 +1,246 @@
+import {
+  SCHEMA_VERSIONS,
+  type DataFileRef,
+  type DataFileUploadPlan,
+  type DataPage,
+  type DataQuery,
+  type DataRecord,
+} from 'openxiangda-contracts/browser';
+import type { InstrumentListQuery, InstrumentRecord } from './instrument';
+import { applicationCode, runtimeMount } from './runtime-meta';
+
+const resourceCode = 'instruments';
+const nativeBase = () =>
+  `/service/openxiangda-api/v2/applications/${applicationCode()}/native`;
+const dataBase = () => `${nativeBase()}/data/${resourceCode}`;
+
+interface PlatformEnvelope<T> {
+  code: number;
+  message?: string;
+  errorCode?: string;
+  data: T;
+}
+
+async function request<T>(path: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(path, {
+    credentials: 'include',
+    ...init,
+    headers: {
+      accept: 'application/json',
+      ...(init?.body ? { 'content-type': 'application/json' } : {}),
+      ...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 code = envelope?.errorCode || `HTTP_${response.status}`;
+    throw new Error(`${code}: ${envelope?.message || '平台请求失败'}`);
+  }
+  return envelope ? envelope.data : (payload as T);
+}
+
+export interface RuntimeIdentity {
+  userId: string;
+  roleCodes: string[];
+  capabilityCodes: string[];
+  isAppSuperAdmin: boolean;
+  environment: {
+    id: string;
+    key: 'preproduction' | 'production';
+    activeAppVersionId?: string;
+    headRevision?: number;
+    authzRevisionId?: string;
+    authzVersion?: number;
+    scopeDataVersion?: string;
+  };
+}
+
+interface ConnectedCurrent {
+  environment: RuntimeIdentity['environment'];
+  principal: {
+    userId: string;
+    roleCodes: string[];
+    capabilityCodes: string[];
+    isAppSuperAdmin: boolean;
+  };
+}
+
+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;
+  };
+}
+
+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)
+    ) {
+      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)}`
+    );
+  }
+}
+
+function currentEnvironmentKey() {
+  const key = activeIdentity?.environment.key || runtimeMount()?.environmentKey;
+  if (!key) throw new Error('OPENXIANGDA_CURRENT_ENVIRONMENT_REQUIRED');
+  return key;
+}
+
+export interface InstrumentDataApiAdapter {
+  list(query: InstrumentListQuery): Promise<{ rows: InstrumentRecord[]; total: number }>;
+  get(id: string): Promise<InstrumentRecord>;
+  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 const instrumentDataApi: InstrumentDataApiAdapter = {
+  async list(query) {
+    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] });
+    }
+    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 || 'updatedAt'), direction: query.sort?.order || 'desc' }],
+      limit: query.pageSize,
+      offset: (query.page - 1) * query.pageSize,
+    };
+    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 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() }),
+      }
+    );
+  },
+};

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

@@ -0,0 +1,60 @@
+export interface RuntimeMount {
+  runtimeBase: string;
+  appCode: string;
+  environmentKey: 'preproduction' | 'production';
+}
+
+export function readRuntimeMount(
+  read: (name: string) => string | undefined
+): RuntimeMount | null {
+  const runtimeBase = read('openxiangda-runtime-base')?.trim();
+  const appCode = read('openxiangda-app-code')?.trim();
+  const environment = read('openxiangda-environment')?.trim();
+  if (!runtimeBase && !appCode && !environment) return null;
+  if (
+    !runtimeBase ||
+    !appCode ||
+    (environment !== 'preproduction' && environment !== 'production')
+  ) {
+    throw new Error('OPENXIANGDA_RUNTIME_META_INVALID');
+  }
+  return { runtimeBase, appCode, environmentKey: environment };
+}
+
+export function runtimeMount() {
+  if (typeof document === 'undefined') return null;
+  return readRuntimeMount(name =>
+    document
+      .querySelector<HTMLMetaElement>(`meta[name="${name}"]`)
+      ?.content.trim()
+  );
+}
+
+export function applicationCode() {
+  return runtimeMount()?.appCode || 'instrument-center';
+}
+
+export function resolveApplicationBasename(mount: RuntimeMount | null) {
+  if (!mount) return undefined;
+  const pathname = new URL(mount.runtimeBase, 'https://runtime.local').pathname;
+  const normalized = pathname.replace(/\/+$/, '');
+  return normalized || '/';
+}
+
+export function applicationBasename() {
+  return resolveApplicationBasename(runtimeMount());
+}
+
+export function resolveApplicationApiPath(
+  mount: RuntimeMount | null,
+  path: string
+) {
+  if (!mount) return `/${path.replace(/^\/+/, '')}`;
+  return `/service/openxiangda-app-api/v2/${encodeURIComponent(
+    mount.appCode
+  )}/${encodeURIComponent(mount.environmentKey)}/${path.replace(/^\/+/, '')}`;
+}
+
+export function applicationApiPath(path: string) {
+  return resolveApplicationApiPath(runtimeMount(), path);
+}

package/template/apps/web/src/runtime.tsx

@@ -0,0 +1,73 @@
+import { Alert, Button, Result, Spin } from 'antd';
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { loadCurrentIdentity, type RuntimeIdentity } from './platform-client';
+import { runtimeMount } from './runtime-meta';
+
+interface RuntimeValue {
+  identity: RuntimeIdentity;
+  hasCapability(code: string): boolean;
+}
+
+const RuntimeContext = createContext<RuntimeValue | null>(null);
+
+export function RuntimeBoundary({ children }: { children: React.ReactNode }) {
+  const [identity, setIdentity] = useState<RuntimeIdentity>();
+  const [error, setError] = useState<Error>();
+  const [attempt, setAttempt] = useState(0);
+  useEffect(() => {
+    let active = true;
+    setError(undefined);
+    void loadCurrentIdentity().then(
+      value => active && setIdentity(value),
+      reason => active && setError(reason instanceof Error ? reason : new Error(String(reason)))
+    );
+    return () => {
+      active = false;
+    };
+  }, [attempt]);
+  const value = useMemo<RuntimeValue | null>(
+    () =>
+      identity
+        ? {
+            identity,
+            hasCapability: code =>
+              identity.isAppSuperAdmin || identity.capabilityCodes.includes(code),
+          }
+        : null,
+    [identity]
+  );
+  const production =
+    identity?.environment.key === 'production' ||
+    runtimeMount()?.environmentKey === 'production';
+  return (
+    <>
+      {production && (
+        <Alert
+          banner
+          showIcon
+          type="error"
+          data-testid="production-data-warning"
+          message="正在使用正式数据：所有新增、编辑和删除都会影响生产环境"
+        />
+      )}
+      {error ? (
+        <Result
+          status="error"
+          title="无法读取平台当前用户"
+          subTitle={error.message}
+          extra={<Button onClick={() => setAttempt(value => value + 1)}>重试</Button>}
+        />
+      ) : value ? (
+        <RuntimeContext.Provider value={value}>{children}</RuntimeContext.Provider>
+      ) : (
+        <div className="oxa-loading"><Spin tip="正在读取平台身份与权限并集" /></div>
+      )}
+    </>
+  );
+}
+
+export function useRuntime() {
+  const value = useContext(RuntimeContext);
+  if (!value) throw new Error('OPENXIANGDA_RUNTIME_NOT_READY');
+  return value;
+}

package/template/apps/web/src/styles.css

@@ -0,0 +1,84 @@
+html,
+body,
+#root {
+  min-height: 100%;
+  margin: 0;
+  background: #f5f7fa;
+}
+* {
+  box-sizing: border-box;
+}
+.oxa-loading {
+  display: grid;
+  min-height: 70vh;
+  place-items: center;
+}
+.oxa-shell {
+  min-height: 100vh;
+}
+.oxa-header {
+  position: sticky;
+  top: 0;
+  z-index: 10;
+  min-height: 56px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 10px 24px;
+  background: #102a43;
+  color: white;
+  box-shadow: 0 2px 8px #0002;
+}
+.oxa-header-roles {
+  color: #cbd5e1;
+}
+.oxa-main {
+  max-width: 1680px;
+  margin: auto;
+  padding: 20px 24px 40px;
+}
+.oxa-title {
+  margin: 0;
+  font-size: 20px;
+}
+.oxa-muted {
+  color: #667085;
+}
+.oxa-page-heading {
+  width: 100%;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 16px;
+}
+.oxa-sections {
+  display: grid;
+  gap: 16px;
+}
+.oxa-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0 20px;
+}
+.oxa-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 20px;
+}
+.oxa-filter-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(160px, 1fr));
+  gap: 12px;
+}
+@media (max-width: 900px) {
+  .oxa-grid,
+  .oxa-filter-grid {
+    grid-template-columns: 1fr;
+  }
+  .oxa-header {
+    align-items: flex-start;
+  }
+}

package/template/apps/web/test/contracts.test.ts

@@ -0,0 +1,234 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  instrumentFieldAllowed,
+  sanitizeInstrumentValues,
+} from '../src/InstrumentForm';
+import { instrumentFields } from '../src/fields';
+import {
+  instrumentDataApi,
+  loadCurrentIdentity,
+} from '../src/platform-client';
+import {
+  applicationApiPath,
+  readRuntimeMount,
+  resolveApplicationApiPath,
+  resolveApplicationBasename,
+} from '../src/runtime-meta';
+
+test('the golden module exposes exactly 30 fields and five restricted fields', () => {
+  assert.equal(instrumentFields.length, 30);
+  assert.deepEqual(
+    instrumentFields
+      .filter(field => field.createCapability && field.updateCapability)
+      .map(field => field.key),
+    [
+      'instrumentCode',
+      'assetCode',
+      'assetValue',
+      'collegeId',
+      'instrumentAdminIds',
+    ]
+  );
+  assert.deepEqual(
+    instrumentFields.filter(field => field.system).map(field => field.key),
+    ['id', 'revision']
+  );
+});
+
+test('college create restores five fields while update omits college reassignment', () => {
+  const protectedFields = instrumentFields.filter(
+    field => field.createCapability && field.updateCapability
+  );
+  const collegeCapabilities = new Set<string>([
+    ...protectedFields.map(field => field.createCapability!),
+    ...protectedFields
+      .filter(field => field.key !== 'collegeId')
+      .map(field => field.updateCapability!),
+  ]);
+  const hasCapability = (capability: string) =>
+    collegeCapabilities.has(capability);
+  const values = {
+    instrumentCode: 'INS-001',
+    chineseName: '电子显微镜',
+    assetCode: 'ASSET-001',
+    assetValue: 100,
+    collegeId: 'college-am',
+    instrumentAdminIds: ['user-wang'],
+    revision: 7,
+  };
+  assert.equal(
+    instrumentFieldAllowed(
+      instrumentFields.find(field => field.key === 'collegeId')!,
+      'create',
+      hasCapability
+    ),
+    true
+  );
+  assert.equal(
+    instrumentFieldAllowed(
+      instrumentFields.find(field => field.key === 'collegeId')!,
+      'edit',
+      hasCapability
+    ),
+    false
+  );
+  assert.deepEqual(sanitizeInstrumentValues(values, 'create', hasCapability), {
+    instrumentCode: 'INS-001',
+    chineseName: '电子显微镜',
+    assetCode: 'ASSET-001',
+    assetValue: 100,
+    collegeId: 'college-am',
+    instrumentAdminIds: ['user-wang'],
+  });
+  assert.deepEqual(sanitizeInstrumentValues(values, 'edit', hasCapability), {
+    instrumentCode: 'INS-001',
+    chineseName: '电子显微镜',
+    assetCode: 'ASSET-001',
+    assetValue: 100,
+    instrumentAdminIds: ['user-wang'],
+  });
+});
+
+test('instrument admin update payload omits every protected field', () => {
+  const values = Object.fromEntries(
+    instrumentFields
+      .filter(field => !field.system)
+      .map(field => [field.key, `value:${field.key}`])
+  );
+  const sanitized = sanitizeInstrumentValues(values, 'edit', () => false);
+  assert.equal(sanitized.chineseName, 'value:chineseName');
+  for (const field of instrumentFields.filter(
+    item => item.createCapability && item.updateCapability
+  )) {
+    assert.equal(
+      Object.prototype.hasOwnProperty.call(sanitized, field.key),
+      false
+    );
+  }
+});
+
+test('school admin keeps every protected field in create and update payloads', () => {
+  const values = Object.fromEntries(
+    instrumentFields
+      .filter(field => !field.system)
+      .map(field => [field.key, `value:${field.key}`])
+  );
+  for (const mode of ['create', 'edit'] as const) {
+    const sanitized = sanitizeInstrumentValues(values, mode, () => true);
+    for (const field of instrumentFields.filter(
+      item => item.createCapability && item.updateCapability
+    )) {
+      assert.equal(sanitized[field.key], `value:${field.key}`);
+    }
+  }
+});
+
+test('deployed app/environment come only from platform-injected runtime meta', () => {
+  const values = new Map([
+    ['openxiangda-runtime-base', '/view/instrument-center/'],
+    ['openxiangda-app-code', 'instrument-center'],
+    ['openxiangda-environment', 'production'],
+  ]);
+  const mount = readRuntimeMount(name => values.get(name));
+  assert.deepEqual(mount, {
+    runtimeBase:
+      '/view/instrument-center/',
+    appCode: 'instrument-center',
+    environmentKey: 'production',
+  });
+  assert.equal(readRuntimeMount(() => undefined), null);
+  assert.throws(
+    () =>
+      readRuntimeMount(name =>
+        name === 'openxiangda-environment' ? 'production' : undefined
+      ),
+    /OPENXIANGDA_RUNTIME_META_INVALID/
+  );
+  assert.equal(
+    applicationApiPath('api/instruments/context'),
+    '/api/instruments/context'
+  );
+  assert.equal(resolveApplicationBasename(mount), '/view/instrument-center');
+  assert.equal(
+    resolveApplicationBasename({
+      ...mount!,
+      runtimeBase: '/dev/instrument-center/',
+      environmentKey: 'preproduction',
+    }),
+    '/dev/instrument-center'
+  );
+  assert.equal(
+    resolveApplicationApiPath(mount, 'api/instruments/context'),
+    '/service/openxiangda-app-api/v2/instrument-center/production/api/instruments/context'
+  );
+});
+
+test('list uses the native Data API with server paging, filters, and sorting', async () => {
+  const calls: Array<{ path: string; init?: RequestInit }> = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input, init) => {
+    calls.push({ path: String(input), init });
+    if (String(input).endsWith('/dev-sessions/current')) {
+      return new Response(
+        JSON.stringify({
+          code: 200,
+          data: {
+            environment: { id: 'test-id', key: 'preproduction' },
+            principal: {
+              userId: 'user-test',
+              roleCodes: ['college_admin'],
+              capabilityCodes: [],
+              isAppSuperAdmin: false,
+            },
+          },
+        }),
+        { status: 200, headers: { 'content-type': 'application/json' } }
+      );
+    }
+    return new Response(
+      JSON.stringify({
+        code: 200,
+        data: {
+          schemaVersion: 'openxiangda.data-page/v2',
+          resourceCode: 'instruments',
+          items: [],
+          total: 0,
+          limit: 20,
+          offset: 20,
+        },
+      }),
+      { status: 200, headers: { 'content-type': 'application/json' } }
+    );
+  };
+  try {
+    await loadCurrentIdentity();
+    await instrumentDataApi.list({
+      page: 2,
+      pageSize: 20,
+      collegeId: 'college-am',
+      instrumentAdminId: 'user-wang',
+      sort: { field: 'assetValue', order: 'asc' },
+    });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+  assert.equal(calls.length, 2);
+  assert.match(
+    calls[1]!.path,
+    /\/native\/data\/instruments\/query$/
+  );
+  const body = JSON.parse(String(calls[1]!.init?.body));
+  assert.equal(body.environmentKey, 'preproduction');
+  assert.equal(body.limit, 20);
+  assert.equal(body.offset, 20);
+  assert.deepEqual(body.order, [{ field: 'assetValue', direction: 'asc' }]);
+  assert.deepEqual(body.filters, [
+    { field: 'collegeId', operator: 'eq', value: 'college-am' },
+    {
+      field: 'instrumentAdminIds',
+      operator: 'cs',
+      value: ['user-wang'],
+    },
+  ]);
+});