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

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

@@ -0,0 +1,144 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { DataResourceSurface } from 'openxiangda-contracts/browser';
+import {
+  buildSubtableOperations,
+  type SubtableDraftRow,
+} from '../src/components/platform-fields/subtable-value';
+
+const childSurface: DataResourceSurface = {
+  fields: {
+    parent_id: field('uuid'),
+    display_order: field('number.integer'),
+    description: field('text.short'),
+    private_note: {
+      ...field('text.long'),
+      createCapabilities: [],
+      updateCapabilities: [],
+    },
+  },
+};
+
+test('plans parent references, updates, deletes and deterministic reorder', () => {
+  const rows: SubtableDraftRow[] = [
+    {
+      key: 'new',
+      state: 'created',
+      data: { description: 'New', private_note: 'forbidden' },
+    },
+    {
+      key: 'existing',
+      state: 'persisted',
+      id: 'child-1',
+      revision: 3,
+      originalOrder: 0,
+      originalData: { description: 'Old' },
+      data: { description: 'Changed' },
+    },
+    {
+      key: 'deleted',
+      state: 'deleted',
+      id: 'child-2',
+      revision: 2,
+      data: {},
+    },
+  ];
+  const operations = buildSubtableOperations({
+    rows,
+    childResourceCode: 'children',
+    childSurface,
+    foreignKey: 'parent_id',
+    orderField: 'display_order',
+    parent: { operation: 'create', operationIndex: 0 },
+    canWrite: (_code, field, operation) =>
+      (operation === 'create'
+        ? field.createCapabilities
+        : field.updateCapabilities
+      ).length > 0,
+    canDelete: true,
+  });
+  assert.deepEqual(operations, [
+    {
+      operation: 'delete',
+      resourceCode: 'children',
+      id: 'child-2',
+      expectedRevision: 2,
+    },
+    {
+      operation: 'create',
+      resourceCode: 'children',
+      data: {
+        description: 'New',
+        parent_id: { operationIndex: 0, field: 'id' },
+        display_order: 0,
+      },
+    },
+    {
+      operation: 'update',
+      resourceCode: 'children',
+      id: 'child-1',
+      expectedRevision: 3,
+      data: { description: 'Changed', display_order: 1 },
+    },
+  ]);
+});
+
+test('omits unchanged persisted rows and enforces the transaction-derived row bound', () => {
+  const unchanged: SubtableDraftRow = {
+    key: 'existing',
+    state: 'persisted',
+    id: 'child-1',
+    revision: 1,
+    originalOrder: 0,
+    originalData: { description: 'Same' },
+    data: { description: 'Same' },
+  };
+  assert.deepEqual(
+    buildSubtableOperations({
+      rows: [unchanged],
+      childResourceCode: 'children',
+      childSurface,
+      foreignKey: 'parent_id',
+      orderField: 'display_order',
+      parent: { operation: 'update', id: 'parent-1' },
+      canWrite: () => true,
+      canDelete: true,
+    }),
+    []
+  );
+  assert.throws(
+    () =>
+      buildSubtableOperations({
+        rows: Array.from({ length: 50 }, (_, index) => ({
+          key: String(index),
+          state: 'created' as const,
+          data: { description: String(index) },
+        })),
+        childResourceCode: 'children',
+        childSurface,
+        foreignKey: 'parent_id',
+        orderField: 'display_order',
+        maxRows: 49,
+        parent: { operation: 'update', id: 'parent-1' },
+        canWrite: () => true,
+        canDelete: true,
+      }),
+    /OPENXIANGDA_SUBTABLE_MAX_ROWS_EXCEEDED/
+  );
+});
+
+function field(type: string) {
+  return {
+    label: type,
+    type,
+    widget:
+      type === 'uuid'
+        ? 'readonly'
+        : type === 'number.integer'
+          ? 'number'
+          : 'text',
+    readCapabilities: ['read'],
+    createCapabilities: ['create'],
+    updateCapabilities: ['update'],
+  } as any;
+}

package/template/openxiangda.config.ts

@@ -25,6 +25,6 @@ export default defineOpenXiangdaApp({
     authorizationTransitions: [],
   },
   data: { resources: [] },
-  events: { subscriptions: [], timers: [] },
+  events: { schemas: [], subscriptions: [], timers: [], dateTriggers: [] },
   workflows: { definitions: [], bindings: [], activations: [], providers: [], editableParameters: [] },
 });

package/template/package.json

@@ -22,9 +22,9 @@
     "build": "pnpm --recursive build"
   },
   "devDependencies": {
-    "openxiangda-cli": "2.0.0-alpha.85",
-    "openxiangda-contracts": "2.0.0-alpha.39",
-    "openxiangda-devkit-core": "2.0.0-alpha.52",
+    "openxiangda-cli": "2.0.0-alpha.89",
+    "openxiangda-contracts": "2.0.0-alpha.43",
+    "openxiangda-devkit-core": "2.0.0-alpha.56",
     "typescript": "5.9.3"
   }
 }

package/template/packages/contracts/src/generated.ts

@@ -17,6 +17,13 @@ export const appOperations = {} as const;
 export const appRoutes = {} as const;
 export const eventTypes = [] as const;
 export const eventSubscriptionCodes = [] as const;
+export const eventHandlerManifest = {
+  "schemaVersion": "openxiangda.event-handler-manifest/v2",
+  "appCode": "openxiangda-application",
+  "handlers": []
+} as const;
+export const eventHandlers = {} as const;
+export const eventSchemas = [] as const;
 export const workflowCodes = [] as const;
 
 export type ResourceCode = (typeof resourceCodes)[number];
@@ -25,4 +32,92 @@ export type AppOperation = (typeof appOperations)[keyof typeof appOperations];
 export type AppRoute = (typeof appRoutes)[keyof typeof appRoutes];
 export type EventType = (typeof eventTypes)[number];
 export type EventSubscriptionCode = (typeof eventSubscriptionCodes)[number];
+export type EventTypesForSubscription<TCode extends EventSubscriptionCode> = never;
 export type WorkflowCode = (typeof workflowCodes)[number];
+
+export interface OpenXiangdaCloudEvent<TType extends EventType = EventType, TData extends Record<string, unknown> = Record<string, unknown>> {
+  specversion: "1.0";
+  id: string;
+  source: string;
+  type: TType;
+  subject?: string;
+  time: string;
+  datacontenttype: "application/json";
+  dataschema?: string;
+  data: TData;
+  tenantid: string;
+  appcode: typeof appCode;
+  environment: string;
+  traceid?: string;
+  schemaversion: string;
+}
+export type EventHandlerInput<TCode extends EventSubscriptionCode> = OpenXiangdaCloudEvent<EventTypesForSubscription<TCode>>;
+
+export interface LabeledValue {
+  label: string;
+  value: string;
+  description?: string;
+  color?: string;
+}
+export interface ResourceReferenceValue extends LabeledValue {
+  resourceCode: string;
+  snapshot?: Record<string, unknown>;
+}
+export interface DepartmentReferenceValue extends LabeledValue {
+  fullPath?: string;
+  path?: LabeledValue[];
+  parent?: LabeledValue;
+}
+export interface UserReferenceValue extends LabeledValue {
+  avatarUrl?: string;
+  employeeNo?: string;
+  title?: string;
+  mobile?: string;
+  email?: string;
+  departments?: DepartmentReferenceValue[];
+}
+export interface DateRangeValue { start: string; end: string; }
+export type CascadePathValue = LabeledValue[];
+export interface DataFileRef {
+  schemaVersion: 'openxiangda.data-file-ref/v2';
+  id: string;
+  name: string;
+  size: number;
+  contentType: string;
+}
+export interface DataImageRef extends DataFileRef {
+  width: number;
+  height: number;
+  thumbnailUrl: string;
+  previewUrl: string;
+}
+export interface StableSignatureValue {
+  file: Omit<DataFileRef, 'schemaVersion'>;
+  signer?: UserReferenceValue;
+  signedAt: string;
+  points?: Array<{ x: number; y: number; t: number }>;
+  hash: string;
+}
+export interface StableAddressValue {
+  country?: LabeledValue;
+  province?: LabeledValue;
+  city?: LabeledValue;
+  district?: LabeledValue;
+  street?: LabeledValue;
+  detail?: string;
+  fullAddress?: string;
+}
+export interface StableLocationSnapshot {
+  address?: string;
+  name?: string;
+  province?: string;
+  city?: string;
+  district?: string;
+  accuracy?: number;
+  capturedAt?: string;
+}
+export type StableLocationValue = StableLocationSnapshot & {
+  source: 'browser' | 'dingTalk';
+  longitude: number;
+  latitude: number;
+};

package/template/scripts/verify-template-budget.mjs

@@ -9,14 +9,18 @@ function visit(directory) {
   for (const entry of readdirSync(directory, { withFileTypes: true })) {
     const path = join(directory, entry.name);
     const name = relative(root, path).replaceAll('\\', '/');
-    if (generated.test(name)) continue;
+    if (
+      generated.test(name) ||
+      name === 'pnpm-lock.yaml' ||
+      name === 'packages/contracts/src/generated.ts'
+    ) continue;
     if (entry.isDirectory()) visit(path);
     else if (entry.isFile() && sourceExtensions.test(name)) files.push(path);
   }
 }
 visit(root);
 const bytes = files.reduce((total, file) => total + statSync(file).size, 0);
-if (files.length > 52) throw new Error(`TEMPLATE_SOURCE_FILE_BUDGET_EXCEEDED:${files.length}>52`);
+if (files.length > 80) throw new Error(`TEMPLATE_SOURCE_FILE_BUDGET_EXCEEDED:${files.length}>80`);
 if (bytes > 500_000) throw new Error(`TEMPLATE_SOURCE_BYTE_BUDGET_EXCEEDED:${bytes}>500000`);
 const productionFiles = files.filter(file => {
   const name = relative(root, file).replaceAll('\\', '/');
@@ -33,8 +37,11 @@ const productionFiles = files.filter(file => {
 const source = productionFiles.map(file => readFileSync(file, 'utf8')).join('\n');
 const agents = readFileSync(resolve(root, 'AGENTS.md'), 'utf8');
 if (!agents.includes('pnpm openxiangda')) throw new Error('TEMPLATE_AGENT_PINNED_CLI_MISSING');
-if (agents.includes('RoleSession') && !agents.includes('Do not select RoleSession')) {
-  throw new Error('TEMPLATE_AGENT_ROLE_SESSION_PATH_ACTIVE');
+if (
+  !agents.includes("union of that user's application roles") ||
+  !agents.includes('opaque authorization context')
+) {
+  throw new Error('TEMPLATE_AGENT_ROLE_UNION_BOUNDARY_MISSING');
 }
 for (const marker of ['@umijs/', 'openxiangda-' + 'admin', 'openxiangda-' + 'user', 'instrument_query', 'instrument_save', 'function.invoke', 'departmentScopeKey', 'instrumentScopeKey', 'adminUserIds', 'college-' + 'am', 'user-' + 'wang', 'dept-' + 'am-test']) {
   if (source.includes(marker)) throw new Error(`TEMPLATE_FORBIDDEN_MARKER:${marker}`);