openxiangda-cli 2.0.0-alpha.85 → 2.0.0-alpha.89

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

@@ -17,30 +17,53 @@ test('clean template is resource-driven and contains no HGY fixture', () => {
 test('standard surfaces keep authoritative directory/resource selectors and mobile routes', () => {
   const surface = readFileSync(new URL('../src/components/resource/SurfaceFields.tsx', import.meta.url), 'utf8');
   const selector = readFileSync(new URL('../src/AuthoritativeSelector.tsx', import.meta.url), 'utf8');
+  const directoryPicker = readFileSync(new URL('../src/components/platform-fields/PlatformDirectoryPicker.tsx', import.meta.url), 'utf8');
+  const directoryValue = readFileSync(new URL('../src/components/platform-fields/directory-value.ts', import.meta.url), 'utf8');
+  const resourceSelector = readFileSync(new URL('../src/components/platform-fields/ResourceReferenceField.tsx', import.meta.url), 'utf8');
   const crud = readFileSync(new URL('../src/components/resource/GeneratedResourceCrud.tsx', import.meta.url), 'utf8');
   assert.match(surface, /PlatformDirectoryPicker/);
-  assert.match(surface, /source="resource"/);
-  assert.match(surface, /MobileAuthoritativeSelector/);
+  assert.match(resourceSelector, /source="resource"/);
+  assert.match(resourceSelector, /MobileAuthoritativeSelector/);
   assert.match(surface, /oxa-mobile-file-field/);
   assert.match(surface, /mobilePending/);
   assert.match(surface, /上传中/);
   assert.match(surface, /重试/);
   assert.match(surface, /AttachmentFileList files=\{refs\}/);
-  assert.match(selector, /searchResource|resolveResource/);
+  assert.match(selector, /searchResource/);
+  assert.doesNotMatch(selector, /resolveResource/);
+  assert.match(selector, /business fields never use this path/);
+  assert.match(selector, /storedReferenceOptions/);
+  assert.doesNotMatch(directoryPicker, /resolveDirectory/);
+  assert.match(directoryValue, /entry\.snapshot/);
+  assert.match(selector, /ResourceReferenceValue/);
   assert.match(selector, /role="dialog"/);
   assert.match(selector, /oxa-mobile-reference-sheet/);
   assert.match(crud, /MobileResourceListPage/);
   assert.match(crud, /fieldWritable/);
   assert.match(crud, /exportResourceRows/);
-  assert.match(crud, /text\/csv;charset=utf-8/);
+  assert.doesNotMatch(crud, /rows\.push|pageSize = 500|csvCell/);
   assert.match(crud, /数据读取失败/);
   assert.match(crud, /state\.list\.query\.refetch/);
   assert.match(crud, /key=\{pageKey\}/);
   assert.match(crud, /setQuery\(\{\}\)/);
   const client = readFileSync(new URL('../src/platform-client.ts', import.meta.url), 'utf8');
+  const resourceQuery = readFileSync(new URL('../src/components/platform-fields/resource-query.ts', import.meta.url), 'utf8');
   assert.match(client, /declaredFields\.has\(requestedSort\.field\)/);
-  assert.match(client, /if \(!declaredFields\.has\(fieldCode\)\) continue/);
+  assert.match(client, /SCHEMA_VERSIONS\.dataFieldSourceQuery/);
+  assert.match(client, /SCHEMA_VERSIONS\.dataExportRequest/);
+  assert.match(client, /`\$\{base\}\/export`/);
+  assert.match(client, /accept', 'text\/csv'/);
+  assert.match(client, /\/source\/query/);
+  assert.doesNotMatch(client, /operator:\s*'ilike'|operator:\s*'cs'|filters:/);
+  assert.match(resourceQuery, /if \(!declaredFields\.has\(fieldCode\)\) continue/);
   assert.match(client, /\/api\/auth\/logout/);
+  assert.match(client, /x-openxiangda-role-session-id/);
+  assert.match(client, /requestApplicationApi/);
+  assert.doesNotMatch(client, /\/native\/current-user/);
+  const runtime = readFileSync(new URL('../src/runtime.tsx', import.meta.url), 'utf8');
+  assert.match(runtime, /selection_required/);
+  assert.match(runtime, /identityEpoch/);
+  assert.doesNotMatch(runtime, /focused_role|authorization-mode/);
 });
 
 test('admin appearance is a bounded Ant Design theme with compact route chrome', () => {
@@ -60,6 +83,7 @@ test('admin appearance is a bounded Ant Design theme with compact route chrome',
   assert.match(shell, /<Segmented/);
   assert.match(shell, /跟随系统/);
   assert.match(shell, /退出登录/);
+  assert.match(shell, /切换应用角色/);
   assert.match(shell, /<Header className="oxa-topbar">\s*<Breadcrumb/);
   assert.doesNotMatch(shell, /oxa-topbar-page/);
 });

package/template/apps/web/test/directory-value.test.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type {
+  DepartmentReferenceValue,
+  DirectoryEntry,
+  UserReferenceValue,
+} from 'openxiangda-contracts/browser';
+import {
+  directoryEntryFromStored,
+  directoryStoredValueFromEntries,
+} from '../src/components/platform-fields/directory-value';
+
+test('preserves complete user snapshots through directory selection', () => {
+  const user: UserReferenceValue = {
+    value: 'user-1',
+    label: '张老师',
+    avatarUrl: 'https://cdn.example/avatar.png',
+    employeeNo: 'T001',
+    mobile: '13800000000',
+    email: 'teacher@example.test',
+    departments: [{
+      value: 'department-1',
+      label: '理学院',
+      fullPath: '学校 / 理学院',
+    }],
+  };
+  const entry = directoryEntryFromStored('user', user);
+  assert.equal(entry.description, 'T001 · 理学院');
+  assert.equal(directoryStoredValueFromEntries([entry], false), user);
+});
+
+test('preserves department path and parent snapshots without resolving again', () => {
+  const department: DepartmentReferenceValue = {
+    value: 'department-2',
+    label: '实验中心',
+    fullPath: '学校 / 理学院 / 实验中心',
+    path: [
+      { value: 'root', label: '学校' },
+      { value: 'department-1', label: '理学院' },
+      { value: 'department-2', label: '实验中心' },
+    ],
+    parent: { value: 'department-1', label: '理学院' },
+  };
+  const entry = directoryEntryFromStored('department', department);
+  assert.equal(entry.parentId, 'department-1');
+  assert.deepEqual(entry.path?.map(item => item.id), [
+    'root',
+    'department-1',
+    'department-2',
+  ]);
+  assert.deepEqual(
+    directoryStoredValueFromEntries([entry, entry] as DirectoryEntry[], true),
+    [department, department]
+  );
+});

package/template/apps/web/test/field-bounds.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+test('standard controls honor declared numeric, text, and file bounds', () => {
+  const source = readFileSync(
+    new URL('../src/components/resource/SurfaceFields.tsx', import.meta.url),
+    'utf8'
+  );
+  assert.match(source, /field\.type === 'number\.integer' \? 0 : field\.scale/);
+  assert.match(source, /10 \*\* -scale/);
+  assert.match(source, /field\.widget === 'money'/);
+  assert.match(source, /field\.widget === 'percent'/);
+  assert.match(source, /maxLength: field\.maxLength/);
+  assert.match(source, /file\.size > maxSizeMb \* 1024 \* 1024/);
+  assert.doesNotMatch(source, /<InputNumber min=\{0\}/);
+});

package/template/apps/web/test/field-form-codec.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { DataFieldSurface, DataResourceSurface } from 'openxiangda-contracts/browser';
+import {
+  fieldValueForData,
+  fieldValueForForm,
+} from '../src/components/platform-fields/field-form-codec';
+
+function field(
+  type: DataFieldSurface['type'],
+  widget: DataFieldSurface['widget'],
+  input: Partial<DataFieldSurface> = {}
+): DataFieldSurface {
+  return {
+    label: type,
+    type,
+    widget,
+    readCapabilities: [],
+    createCapabilities: [],
+    updateCapabilities: [],
+    ...input,
+  };
+}
+
+test('round-trips date, time and datetime values through form controls', () => {
+  const date = field('date', 'date');
+  const minute = field('time', 'time', { timePrecision: 'minute' });
+  const second = field('time', 'time', { timePrecision: 'second' });
+  const datetime = field('datetime', 'datetime');
+  assert.equal(fieldValueForData(date, fieldValueForForm(date, '2026-08-24')), '2026-08-24');
+  assert.equal(fieldValueForData(minute, fieldValueForForm(minute, '09:30:00')), '09:30');
+  assert.equal(fieldValueForData(second, fieldValueForForm(second, '09:30:45')), '09:30:45');
+  assert.equal(
+    fieldValueForData(datetime, fieldValueForForm(datetime, '2026-08-24T08:30:45.000Z')),
+    '2026-08-24T08:30:45.000Z'
+  );
+});
+
+test('round-trips date and datetime ranges as closed objects', () => {
+  const dateRange = field('date-range', 'date-range');
+  const datetimeRange = field('datetime-range', 'datetime-range');
+  assert.deepEqual(
+    fieldValueForData(
+      dateRange,
+      fieldValueForForm(dateRange, { start: '2026-08-01', end: '2026-08-31' })
+    ),
+    { start: '2026-08-01', end: '2026-08-31' }
+  );
+  assert.deepEqual(
+    fieldValueForData(
+      datetimeRange,
+      fieldValueForForm(datetimeRange, {
+        start: '2026-08-01T00:00:00.000Z',
+        end: '2026-08-31T00:00:00.000Z',
+      })
+    ),
+    {
+      start: '2026-08-01T00:00:00.000Z',
+      end: '2026-08-31T00:00:00.000Z',
+    }
+  );
+});
+
+test('preserves explicit empty values for nullable fields', () => {
+  const surface = {
+    fields: { observedAt: field('datetime', 'datetime') },
+  } satisfies DataResourceSurface;
+  assert.equal(fieldValueForData(surface.fields.observedAt, null), null);
+  assert.equal(fieldValueForForm(surface.fields.observedAt, null), undefined);
+});
+
+test('keeps query-facing date values free of Dayjs transport objects', () => {
+  const date = field('date', 'date');
+  const range = field('datetime-range', 'datetime-range');
+  const dateValue = fieldValueForData(date, fieldValueForForm(date, '2026-08-24'));
+  const rangeValue = fieldValueForData(
+    range,
+    fieldValueForForm(range, {
+      start: '2026-08-01T00:00:00.000Z',
+      end: '2026-08-31T00:00:00.000Z',
+    })
+  );
+  assert.equal(typeof dateValue, 'string');
+  assert.deepEqual(JSON.parse(JSON.stringify(rangeValue)), rangeValue);
+});

package/template/apps/web/test/location-field.test.ts

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import {
+  browserLocationValue,
+  dingTalkLocationValue,
+} from '../src/components/platform-fields/location-value';
+
+test('normalizes browser coordinates into an exact snapshot', () => {
+  assert.deepEqual(
+    browserLocationValue({
+      longitude: 120.1234567,
+      latitude: 30.7654321,
+      accuracy: 8.5,
+      timestamp: Date.parse('2026-08-24T08:00:00.000Z'),
+    }),
+    {
+      source: 'browser',
+      longitude: 120.1234567,
+      latitude: 30.7654321,
+      accuracy: 8.5,
+      capturedAt: '2026-08-24T08:00:00.000Z',
+    }
+  );
+});
+
+test('normalizes DingTalk coordinates and optional reverse-geocoded display data', () => {
+  assert.deepEqual(
+    dingTalkLocationValue(
+      {
+        longitude: '120.1234567',
+        latitude: '30.7654321',
+        accuracy: '12',
+        address: ' 浙江省杭州市西湖区 ',
+        poiName: '测试大楼',
+        province: '浙江省',
+        city: '杭州市',
+        district: '西湖区',
+      },
+      Date.parse('2026-08-24T08:00:00.000Z')
+    ),
+    {
+      source: 'dingTalk',
+      longitude: 120.1234567,
+      latitude: 30.7654321,
+      accuracy: 12,
+      address: '浙江省杭州市西湖区',
+      name: '测试大楼',
+      province: '浙江省',
+      city: '杭州市',
+      district: '西湖区',
+      capturedAt: '2026-08-24T08:00:00.000Z',
+    }
+  );
+});
+
+test('rejects missing and out-of-range coordinates', () => {
+  assert.throws(
+    () => dingTalkLocationValue({ latitude: 30 }),
+    /有效经度/
+  );
+  assert.throws(
+    () => browserLocationValue({ longitude: 181, latitude: 30 }),
+    /有效经度/
+  );
+  assert.throws(
+    () => browserLocationValue({ longitude: 120, latitude: -91 }),
+    /有效纬度/
+  );
+});
+
+test('location control captures coordinates without a manual address input', () => {
+  const source = readFileSync(
+    new URL('../src/components/platform-fields/LocationField.tsx', import.meta.url),
+    'utf8'
+  );
+  assert.match(source, /coordinate: 0/);
+  assert.match(source, /withReGeocode: true/);
+  assert.match(source, /browserLocationValue/);
+  assert.match(source, /dingTalkLocationValue/);
+  assert.match(source, /LocationValueDisplay/);
+  assert.doesNotMatch(source, /<Input|<textarea|contentEditable/);
+});

package/template/apps/web/test/resource-import.test.ts

@@ -6,19 +6,20 @@ import { parseResourceImportMatrix } from '../src/components/resource/resource-i
 const surface = {
   generated: true,
   fields: {
-    visitorName: { label: '访客姓名', widget: 'text', requiredHint: true },
-    visitorCount: { label: '来访人数', widget: 'number' },
-    approved: { label: '是否通过', widget: 'boolean' },
+    visitorName: { label: '访客姓名', type: 'text.short', widget: 'text', requiredHint: true },
+    visitorCount: { label: '来访人数', type: 'number.integer', widget: 'number' },
+    approved: { label: '是否通过', type: 'boolean', widget: 'switch' },
     status: {
       label: '状态',
+      type: 'option.single',
       widget: 'select',
       options: [
         { label: '待审核', value: 'pending' },
         { label: '已通过', value: 'approved' },
       ],
     },
-    visitDate: { label: '来访日期', widget: 'date' },
-    attachments: { label: '附件', widget: 'file' },
+    visitDate: { label: '来访日期', type: 'date', widget: 'date' },
+    attachments: { label: '附件', type: 'file', widget: 'attachment' },
   },
 } as unknown as DataResourceSurface;
 
@@ -44,7 +45,7 @@ test('maps exact labels and codes into one canonical create transaction', () =>
         visitorName: '张三',
         visitorCount: 2,
         approved: true,
-        status: 'pending',
+        status: { label: '待审核', value: 'pending' },
       },
     },
     {
@@ -54,7 +55,7 @@ test('maps exact labels and codes into one canonical create transaction', () =>
         visitorName: '李四',
         visitorCount: 3,
         approved: false,
-        status: 'approved',
+        status: { label: '已通过', value: 'approved' },
       },
     },
   ]);

package/template/apps/web/test/resource-query.test.ts

@@ -0,0 +1,144 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { DataFieldSurface, DataResourceSurface } from 'openxiangda-contracts/browser';
+import { buildResourceWhere } from '../src/components/platform-fields/resource-query';
+
+function field(
+  type: DataFieldSurface['type'],
+  widget: DataFieldSurface['widget']
+): DataFieldSurface {
+  return {
+    label: type,
+    type,
+    widget,
+    readCapabilities: [],
+    createCapabilities: [],
+    updateCapabilities: [],
+  };
+}
+
+const surface = {
+  fields: {
+    name: field('text.short', 'text'),
+    status: field('option.single', 'select'),
+    tags: field('option.multiple', 'multi-select'),
+    category: field('cascade.single', 'cascade'),
+    categories: field('cascade.multiple', 'cascade'),
+    address: field('address', 'address'),
+    metadata: field('json', 'json'),
+    period: field('date-range', 'date-range'),
+  },
+  list: { searchableFields: ['name'] },
+} satisfies DataResourceSurface;
+
+test('builds canonical snapshot and text predicates', () => {
+  assert.deepEqual(
+    buildResourceWhere('records', surface, {
+      page: 1,
+      pageSize: 20,
+      keyword: ' 显微镜 ',
+      filters: {
+        status: { value: 'enabled', label: '启用' },
+        tags: [
+          { value: 'precision', label: '精密' },
+          { value: 'shared', label: '共享' },
+        ],
+      },
+    }),
+    {
+      and: [
+        { field: 'name', operator: 'contains', value: '显微镜' },
+        { field: 'status', operator: 'eq', value: 'enabled' },
+        { field: 'tags', operator: 'hasAny', value: ['precision', 'shared'] },
+      ],
+    }
+  );
+});
+
+test('builds cascade membership and semantic range predicates', () => {
+  assert.deepEqual(
+    buildResourceWhere('records', surface, {
+      page: 1,
+      pageSize: 20,
+      filters: {
+        category: [
+          { value: 'equipment', label: '设备' },
+          { value: 'microscope', label: '显微镜' },
+        ],
+        categories: [
+          [
+            { value: 'equipment', label: '设备' },
+            { value: 'microscope', label: '显微镜' },
+          ],
+          [{ value: 'rooms', label: '场地' }],
+        ],
+        period: { start: '2026-08-01', end: '2026-08-31' },
+      },
+    }),
+    {
+      and: [
+        { field: 'category', operator: 'has', value: 'microscope' },
+        { field: 'categories', operator: 'hasAny', value: ['microscope', 'rooms'] },
+        {
+          field: 'period',
+          operator: 'overlaps',
+          value: { start: '2026-08-01', end: '2026-08-31' },
+        },
+      ],
+    }
+  );
+});
+
+test('ignores stale-route and empty filters without emitting legacy operators', () => {
+  assert.equal(
+    buildResourceWhere('records', surface, {
+      page: 1,
+      pageSize: 20,
+      filters: { stale: 'value', tags: [] },
+    }),
+    undefined
+  );
+});
+
+test('filters an address by its deepest stable administrative code', () => {
+  assert.deepEqual(
+    buildResourceWhere('records', surface, {
+      page: 1,
+      pageSize: 20,
+      filters: {
+        address: {
+          country: { label: '中国', value: '100000' },
+          province: { label: '浙江省', value: '330000' },
+          city: { label: '杭州市', value: '330100' },
+          district: { label: '西湖区', value: '330106' },
+          fullAddress: '浙江省杭州市西湖区',
+        },
+      },
+    }),
+    {
+      and: [{
+        field: 'address',
+        operator: 'jsonContains',
+        path: 'district.value',
+        value: '330106',
+      }],
+    }
+  );
+});
+
+test('filters bounded JSON with canonical containment', () => {
+  assert.deepEqual(
+    buildResourceWhere('records', surface, {
+      page: 1,
+      pageSize: 20,
+      filters: { metadata: { enabled: true, level: 2 } },
+    }),
+    {
+      and: [{
+        field: 'metadata',
+        operator: 'jsonContains',
+        value: { enabled: true, level: 2 },
+      }],
+    }
+  );
+});

package/template/apps/web/test/rich-json-field.test.ts

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import { parseJsonEditorValue } from '../src/components/platform-fields/JsonField';
+import { richTextPlainText } from '../src/components/platform-fields/rich-text-value';
+
+test('JSON editor submits structured values and rejects invalid text', () => {
+  assert.deepEqual(parseJsonEditorValue('{"enabled":true,"items":[1,2]}'), {
+    enabled: true,
+    items: [1, 2],
+  });
+  assert.equal(parseJsonEditorValue('  '), undefined);
+  assert.throws(() => parseJsonEditorValue('{broken'), SyntaxError);
+});
+
+test('rich text plain fallback does not expose markup in compact contexts', () => {
+  assert.equal(
+    richTextPlainText('<h2>Heading</h2><p>Body <strong>text</strong></p>'),
+    'Heading Body text'
+  );
+});
+
+test('rich text editor mirrors the platform allowlist and JSON has readonly formatting', () => {
+  const richValue = readFileSync(
+    new URL('../src/components/platform-fields/rich-text-value.ts', import.meta.url),
+    'utf8'
+  );
+  const richField = readFileSync(
+    new URL('../src/components/platform-fields/RichTextField.tsx', import.meta.url),
+    'utf8'
+  );
+  const jsonField = readFileSync(
+    new URL('../src/components/platform-fields/JsonField.tsx', import.meta.url),
+    'utf8'
+  );
+  const attachmentList = readFileSync(
+    new URL('../src/components/platform-fields/AttachmentFileList.tsx', import.meta.url),
+    'utf8'
+  );
+  assert.match(richValue, /MANAGED_IMAGE/);
+  assert.match(richValue, /disposition=inline/);
+  assert.match(richValue, /noopener noreferrer/);
+  assert.match(richField, /contentEditable/);
+  assert.match(richField, /dangerouslySetInnerHTML/);
+  assert.match(richField, /FileImageOutlined/);
+  assert.match(richField, /dataRichTextImageSource/);
+  assert.match(richField, /10 \* 1024 \* 1024/);
+  assert.match(richField, /INLINE_IMAGE_MAX_COUNT = 20/);
+  assert.match(attachmentList, /file\.thumbnailUrl/);
+  assert.match(attachmentList, /oxa-file-thumbnail/);
+  assert.match(jsonField, /JSON\.stringify\(value, null, 2\)/);
+  assert.match(jsonField, /JSON 格式无效/);
+});

package/template/apps/web/test/signature-serial-field.test.ts

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+test('signature canvas emits managed PNG, SHA-256 and business metadata', () => {
+  const field = readFileSync(
+    new URL('../src/components/platform-fields/SignatureField.tsx', import.meta.url),
+    'utf8'
+  );
+  assert.match(field, /toBlob\(resolve, 'image\/png'\)/);
+  assert.match(field, /digest\('SHA-256'/);
+  assert.match(field, /signedAt: new Date\(\)\.toISOString\(\)/);
+  assert.match(field, /points: points\.current\.slice\(\)/);
+  assert.match(field, /file: managedFile\(uploaded\)/);
+  assert.doesNotMatch(field, /dataURL|base64/);
+});
+
+test('signature has separate desktop/mobile dialogs and serial stays server-owned', () => {
+  const signature = readFileSync(
+    new URL('../src/components/platform-fields/SignatureField.tsx', import.meta.url),
+    'utf8'
+  );
+  const surface = readFileSync(
+    new URL('../src/components/resource/SurfaceFields.tsx', import.meta.url),
+    'utf8'
+  );
+  const crud = readFileSync(
+    new URL('../src/components/resource/GeneratedResourceCrud.tsx', import.meta.url),
+    'utf8'
+  );
+  assert.match(signature, /<Drawer/);
+  assert.match(signature, /<Modal/);
+  assert.match(surface, /保存后由系统自动生成/);
+  assert.match(
+    crud,
+    /field\.widget !== 'readonly' && fieldWriteAuthorized\(field, mode/
+  );
+  assert.match(crud, /canWrite: \(fieldCode, childField, childOperation\) =>\s+fieldWriteAuthorized\(/);
+  assert.match(crud, /signatureSigner\(identity\.subjectProfile\)/);
+});