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

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

@@ -1,66 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import test from 'node:test';
-import {
-  addressControlValue,
-  addressDisplay,
-  addressStoredValue,
-  deepestAddressPredicate,
-} from '../src/components/platform-fields/address-value';
-
-const path = [
-  { label: '浙江省', value: '330000' },
-  { label: '杭州市', value: '330100' },
-  { label: '西湖区', value: '330106' },
-  { label: '翠苑街道', value: '330106012' },
-];
-
-test('stores a complete administrative snapshot with a stable full address', () => {
-  const value = addressStoredValue(path, '文一路 1 号');
-  assert.deepEqual(value, {
-    country: { label: '中国', value: '100000' },
-    province: path[0],
-    city: path[1],
-    district: path[2],
-    street: path[3],
-    detail: '文一路 1 号',
-    fullAddress: '浙江省杭州市西湖区翠苑街道文一路 1 号',
-  });
-  assert.deepEqual(addressControlValue(value), path.map(item => item.value));
-  assert.equal(addressDisplay(value), '浙江省杭州市西湖区翠苑街道文一路 1 号');
-});
-
-test('deduplicates adjacent municipality labels while retaining both snapshots', () => {
-  const value = addressStoredValue([
-    { label: '上海市', value: '310000' },
-    { label: '上海市', value: '310100' },
-    { label: '浦东新区', value: '310115' },
-  ]);
-  assert.equal(value?.fullAddress, '上海市浦东新区');
-  assert.equal(value?.province?.value, '310000');
-  assert.equal(value?.city?.value, '310100');
-});
-
-test('uses the deepest selected stable code for Data API filtering', () => {
-  assert.deepEqual(
-    deepestAddressPredicate(addressStoredValue(path.slice(0, 3))),
-    { path: 'district.value', value: '330106' }
-  );
-  assert.equal(addressStoredValue([], 'address only'), undefined);
-});
-
-test('address field has lazy desktop and explicit mobile controls', () => {
-  const field = readFileSync(
-    new URL('../src/components/platform-fields/AddressField.tsx', import.meta.url),
-    'utf8'
-  );
-  const client = readFileSync(
-    new URL('../src/platform-client.ts', import.meta.url),
-    'utf8'
-  );
-  assert.match(field, /loadData=/);
-  assert.match(field, /loadChinaDivisions/);
-  assert.match(field, /placement="bottom"/);
-  assert.match(field, /ADDRESS_LEVELS\.map/);
-  assert.match(client, /\/china-divisions\//);
-});

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

@@ -1,68 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import type { DataFieldOption } from 'openxiangda-contracts/browser';
-import {
-  cascadeControlValue,
-  cascadeStoredValue,
-  cascadeTerminalValues,
-} from '../src/components/platform-fields/cascade-value';
-
-const options: DataFieldOption[] = [
-  {
-    value: 'equipment',
-    label: '设备',
-    children: [
-      {
-        value: 'optical',
-        label: '光学设备',
-        children: [{ value: 'microscope', label: '显微镜' }],
-      },
-      { value: 'electrical', label: '电气设备' },
-    ],
-  },
-];
-
-test('stores every labeled node for a cascade single path', () => {
-  const value = cascadeStoredValue(
-    options,
-    ['equipment', 'optical', 'microscope'],
-    false
-  );
-  assert.deepEqual(value, [
-    { value: 'equipment', label: '设备' },
-    { value: 'optical', label: '光学设备' },
-    { value: 'microscope', label: '显微镜' },
-  ]);
-  assert.deepEqual(cascadeControlValue(value, false), [
-    'equipment',
-    'optical',
-    'microscope',
-  ]);
-  assert.deepEqual(cascadeTerminalValues(value, false), ['microscope']);
-});
-
-test('stores independent complete paths for cascade multiple', () => {
-  const value = cascadeStoredValue(
-    options,
-    [
-      ['equipment', 'optical', 'microscope'],
-      ['equipment', 'electrical'],
-    ],
-    true
-  );
-  assert.deepEqual(cascadeTerminalValues(value, true), [
-    'microscope',
-    'electrical',
-  ]);
-  assert.deepEqual(cascadeControlValue(value, true), [
-    ['equipment', 'optical', 'microscope'],
-    ['equipment', 'electrical'],
-  ]);
-});
-
-test('drops forged paths that do not exist in declared options', () => {
-  assert.equal(
-    cascadeStoredValue(options, ['equipment', 'missing'], false),
-    undefined
-  );
-});

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

@@ -1,55 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,143 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import type { DataResourceSurface } from 'openxiangda-contracts/browser';
-import { parseResourceImportMatrix } from '../src/components/resource/resource-import';
-
-const surface = {
-  generated: true,
-  fields: {
-    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: '来访日期', type: 'date', widget: 'date' },
-    attachments: { label: '附件', type: 'file', widget: 'attachment' },
-  },
-} as unknown as DataResourceSurface;
-
-test('maps exact labels and codes into one canonical create transaction', () => {
-  const preview = parseResourceImportMatrix(
-    '访客.xlsx',
-    [
-      ['访客姓名', 'visitorCount', '是否通过', '状态'],
-      ['张三', 2, '是', '待审核'],
-      ['李四', '3', '否', 'approved'],
-    ],
-    'visitor-reservations',
-    surface,
-    ['visitorName', 'visitorCount', 'approved', 'status']
-  );
-
-  assert.deepEqual(preview.errors, []);
-  assert.deepEqual(preview.operations, [
-    {
-      operation: 'create',
-      resourceCode: 'visitor-reservations',
-      data: {
-        visitorName: '张三',
-        visitorCount: 2,
-        approved: true,
-        status: { label: '待审核', value: 'pending' },
-      },
-    },
-    {
-      operation: 'create',
-      resourceCode: 'visitor-reservations',
-      data: {
-        visitorName: '李四',
-        visitorCount: 3,
-        approved: false,
-        status: { label: '已通过', value: 'approved' },
-      },
-    },
-  ]);
-});
-
-test('preserves exact dates and rejects impossible calendar dates', () => {
-  const valid = parseResourceImportMatrix(
-    '日期.csv',
-    [
-      ['访客姓名', '来访日期'],
-      ['张三', '2026-08-23'],
-    ],
-    'visitor-reservations',
-    surface,
-    ['visitorName', 'visitDate']
-  );
-  assert.deepEqual(valid.errors, []);
-  assert.deepEqual(valid.operations[0], {
-    operation: 'create',
-    resourceCode: 'visitor-reservations',
-    data: { visitorName: '张三', visitDate: '2026-08-23' },
-  });
-
-  const invalid = parseResourceImportMatrix(
-    '错误日期.csv',
-    [
-      ['访客姓名', '来访日期'],
-      ['张三', '2026-02-30'],
-    ],
-    'visitor-reservations',
-    surface,
-    ['visitorName', 'visitDate']
-  );
-  assert.equal(invalid.operations.length, 0);
-  assert.ok(invalid.errors.some((error) => error.includes('日期格式无效')));
-});
-
-test('rejects values in a column without a header', () => {
-  const preview = parseResourceImportMatrix(
-    '空表头.csv',
-    [
-      ['访客姓名', ''],
-      ['张三', '未声明的数据'],
-    ],
-    'visitor-reservations',
-    surface,
-    ['visitorName']
-  );
-
-  assert.equal(preview.operations.length, 0);
-  assert.ok(preview.errors.some((error) => error.includes('缺少表头')));
-});
-
-test('rejects unknown, managed-file and invalid cells before submission', () => {
-  const preview = parseResourceImportMatrix(
-    '错误.csv',
-    [
-      ['访客姓名', '是否通过', '附件', '任意列'],
-      ['', '不确定', 'https://untrusted.example/file', 'value'],
-    ],
-    'visitor-reservations',
-    surface,
-    ['visitorName', 'approved', 'attachments']
-  );
-
-  assert.equal(preview.operations.length, 0);
-  assert.ok(preview.errors.some((error) => error.includes('不是已声明字段')));
-  assert.ok(preview.errors.some((error) => error.includes('必须通过平台上传组件')));
-  assert.ok(preview.errors.some((error) => error.includes('请填写是或否')));
-  assert.ok(preview.errors.some((error) => error.includes('访客姓名为必填项')));
-});
-
-test('keeps the atomic import boundary at one hundred rows', () => {
-  const preview = parseResourceImportMatrix(
-    '过大.csv',
-    [['访客姓名'], ...Array.from({ length: 101 }, (_, index) => [`访客 ${index + 1}`])],
-    'visitor-reservations',
-    surface,
-    ['visitorName']
-  );
-
-  assert.equal(preview.rows.length, 100);
-  assert.equal(preview.operations.length, 0);
-  assert.ok(preview.errors.some((error) => error.includes('单次最多导入 100 行')));
-});

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

@@ -1,144 +0,0 @@
-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 },
-      }],
-    }
-  );
-});