openxiangda-devkit-core 2.0.0-alpha.52 → 2.0.0-alpha.56

package/dist/compiler/bundle.js

@@ -1,10 +1,48 @@
 import { createHash } from 'node:crypto';
-import { canonicalJson, nativePlatformCapabilityCatalog, OPENXIANGDA_COMPILER_CONTRACT_VERSION, SCHEMA_VERSIONS, sha256Digest, } from 'openxiangda-contracts';
+import { canonicalJson, applicationEventHandlerPathV2, DATA_EVENT_TYPES_V2, nativePlatformCapabilityCatalog, OPENXIANGDA_COMPILER_CONTRACT_VERSION, SCHEMA_VERSIONS, WORKFLOW_EVENT_TYPES_V2, sha256Digest, } from 'openxiangda-contracts';
 import { compileAiCapabilityCatalog } from './ai-catalog.js';
+import { FIELD_VALUE_TYPESCRIPT_DECLARATIONS, fieldNullable, isGeneratedField, typescriptType, } from './field-codec.js';
+import { supportsSearch, supportsSort } from './field-query-plan.js';
 import { resolveDataFieldSurfaceWidget } from './field-surface.js';
 export const CONFIG_BUNDLE_SCHEMA = SCHEMA_VERSIONS.configurationBundle;
 export const CONTRACT_BUNDLE_SCHEMA = SCHEMA_VERSIONS.contractBundle;
 export const COMPILER_CONTRACT_VERSION = OPENXIANGDA_COMPILER_CONTRACT_VERSION;
+const DEFAULT_EVENT_DELIVERY = {
+    timeoutMs: 10_000,
+    maxAttempts: 8,
+    initialBackoffMs: 1_000,
+    maxBackoffMs: 300_000,
+    ordering: 'none',
+    concurrency: 10,
+};
+function normalizeEventFilter(filter) {
+    if (!filter)
+        return {};
+    return {
+        ...(filter.resourceCodes
+            ? { resourceCodes: uniqueSorted(filter.resourceCodes) }
+            : {}),
+        ...(filter.subject ? { subject: { ...filter.subject } } : {}),
+        ...(filter.changedFields
+            ? {
+                changedFields: Object.fromEntries(Object.entries(filter.changedFields).map(([key, value]) => [
+                    key,
+                    uniqueSorted(value),
+                ])),
+            }
+            : {}),
+        ...(filter.changes
+            ? {
+                changes: sorted(filter.changes.map(change => ({
+                    field: change.field,
+                    ...(change.before ? { before: change.before } : {}),
+                    ...(change.after ? { after: change.after } : {}),
+                })), change => String(change.field || '')),
+            }
+            : {}),
+        ...(filter.where ? { where: filter.where } : {}),
+    };
+}
 export function compileApplicationSources(config, generatorVersion = 'openxiangda-devkit-core') {
     const configuration = normalizeConfiguration(config);
     const configContent = canonicalJson(configuration);
@@ -128,7 +166,7 @@ export function normalizeConfiguration(config) {
             dataPolicies: sorted((config.authz?.dataPolicies || []).map(policy => ({
                 code: policy.code,
                 name: policy.name,
-                ...(policy.resourceCode ? { resourceCode: policy.resourceCode } : {}),
+                resourceCode: policy.resourceCode,
                 ...(policy.unrestrictedRoleCodes !== undefined
                     ? {
                         unrestrictedRoleCodes: uniqueSorted(policy.unrestrictedRoleCodes),
@@ -193,19 +231,28 @@ export function normalizeConfiguration(config) {
             resources: sorted((config.data?.resources || []).map(normalizeDataResource), item => item.code),
         },
         events: {
+            schemas: sorted((config.events?.schemas || []).map(schema => ({
+                schemaVersion: SCHEMA_VERSIONS.eventSchema,
+                eventType: schema.eventType,
+                dataSchemaVersion: schema.dataSchemaVersion,
+                jsonSchema: schema.jsonSchema,
+                schemaDigest: sha256Digest(schema.jsonSchema),
+                sensitiveFields: uniqueSorted(schema.sensitiveFields || []),
+                owner: 'application',
+            })), item => `${item.eventType}:${item.dataSchemaVersion}`),
             subscriptions: sorted((config.events?.subscriptions || []).map(subscription => ({
                 code: subscription.code,
                 ...(subscription.description
                     ? { description: subscription.description }
                     : {}),
                 eventTypes: uniqueSorted(subscription.eventTypes),
-                ...(subscription.subjectFilters
-                    ? { subjectFilters: subscription.subjectFilters }
-                    : {}),
-                endpointPath: subscription.endpointPath,
-                ...(subscription.delivery
-                    ? { delivery: subscription.delivery }
-                    : {}),
+                filter: normalizeEventFilter(subscription.filter),
+                payload: {
+                    includeChanges: subscription.payload?.includeChanges !== false,
+                    fields: uniqueSorted(subscription.payload?.fields || []),
+                },
+                endpointPath: applicationEventHandlerPathV2(subscription.code),
+                delivery: { ...DEFAULT_EVENT_DELIVERY, ...subscription.delivery },
             })), item => item.code),
             timers: sorted((config.events?.timers || []).map(timer => ({
                 code: timer.code,
@@ -213,6 +260,15 @@ export function normalizeConfiguration(config) {
                 cronExpression: timer.cronExpression,
                 timezone: timer.timezone,
                 payload: timer.payload,
+                misfirePolicy: timer.misfirePolicy || 'coalesce_one',
+            })), item => item.code),
+            dateTriggers: sorted((config.events?.dateTriggers || []).map(trigger => ({
+                code: trigger.code,
+                resourceCode: trigger.resourceCode,
+                field: trigger.field,
+                offset: trigger.offset,
+                eventType: trigger.eventType,
+                payload: trigger.payload,
             })), item => item.code),
         },
         workflows: {
@@ -277,6 +333,61 @@ export function compileContractBundle(config, configDigest, generatorVersion = '
 }
 function compileContractBundleFromNormalized(config, configDigest, generatorVersion, normalizedConfiguration) {
     const capabilities = compileCapabilities(normalizedConfiguration);
+    const eventConsumers = sorted(normalizedConfiguration.events.subscriptions.map(subscription => ({
+        code: subscription.code,
+        endpointPath: subscription.endpointPath,
+        eventTypes: subscription.eventTypes,
+        filter: subscription.filter,
+        payload: subscription.payload,
+        delivery: subscription.delivery,
+    })), item => item.code);
+    const applicationSchemaVersions = new Map(normalizedConfiguration.events.schemas.map(schema => [
+        schema.eventType,
+        schema.dataSchemaVersion,
+    ]));
+    const dataEventProducers = config.data?.resources.flatMap(resource => DATA_EVENT_TYPES_V2.filter(type => !type.endsWith('.date_due.v2')).map(eventType => ({
+        code: `data:${resource.code}:${eventType}`,
+        source: 'data',
+        eventType,
+        dataSchemaVersion: '2.0.0',
+        resourceCode: resource.code,
+    }))) || [];
+    const workflowEventProducers = config.workflows?.activations.length
+        ? WORKFLOW_EVENT_TYPES_V2.map(eventType => ({
+            code: `workflow:${eventType}`,
+            source: 'workflow',
+            eventType,
+            dataSchemaVersion: '2.0.0',
+        }))
+        : [];
+    const eventProducers = sorted([
+        ...dataEventProducers,
+        ...normalizedConfiguration.events.schemas.map(schema => ({
+            code: `app:${schema.eventType}`,
+            source: 'app',
+            eventType: schema.eventType,
+            dataSchemaVersion: schema.dataSchemaVersion,
+        })),
+        ...normalizedConfiguration.events.timers.map(timer => ({
+            code: timer.code,
+            source: 'timer',
+            eventType: timer.eventType,
+            dataSchemaVersion: applicationSchemaVersions.get(timer.eventType) || '2.0.0',
+        })),
+        ...normalizedConfiguration.events.dateTriggers.map(trigger => ({
+            code: trigger.code,
+            source: 'date',
+            eventType: trigger.eventType,
+            dataSchemaVersion: applicationSchemaVersions.get(trigger.eventType) || '2.0.0',
+            resourceCode: trigger.resourceCode,
+            field: trigger.field,
+        })),
+        ...workflowEventProducers,
+    ], item => `${item.source}:${item.code}:${item.eventType}`);
+    const eventTypes = uniqueSorted([
+        ...eventConsumers.flatMap(item => item.eventTypes),
+        ...eventProducers.map(item => item.eventType),
+    ]);
     return {
         schemaVersion: CONTRACT_BUNDLE_SCHEMA,
         compilerContractVersion: COMPILER_CONTRACT_VERSION,
@@ -286,20 +397,24 @@ function compileContractBundleFromNormalized(config, configDigest, generatorVers
         resources: compileResources(config),
         capabilities,
         operations: compileOperations(config),
-        eventConsumers: sorted((config.events?.subscriptions || []).map(subscription => ({
-            code: subscription.code,
-            endpointPath: subscription.endpointPath,
-            eventTypes: uniqueSorted(subscription.eventTypes),
-        })), item => item.code),
-        eventProducers: sorted((config.events?.timers || []).map(timer => ({
-            code: timer.code,
-            source: 'timer',
-            eventType: timer.eventType,
-        })), item => item.code),
-        eventTypes: uniqueSorted([
-            ...(config.events?.subscriptions || []).flatMap(item => item.eventTypes),
-            ...(config.events?.timers || []).map(item => item.eventType),
-        ]),
+        eventConsumers,
+        eventProducers,
+        eventSchemas: normalizedConfiguration.events.schemas,
+        eventHandlerManifest: {
+            schemaVersion: SCHEMA_VERSIONS.eventHandlerManifest,
+            appCode: config.app.code,
+            handlers: eventConsumers.map(consumer => ({
+                code: consumer.code,
+                endpointPath: consumer.endpointPath,
+                eventTypes: consumer.eventTypes,
+                dataSchemaVersions: uniqueSorted(consumer.eventTypes.map(eventType => eventType.startsWith('openxiangda.')
+                    ? '2.0.0'
+                    : applicationSchemaVersions.get(eventType) || '2.0.0')),
+                maxBodyBytes: 65_536,
+                receiptProtocolVersion: 2,
+            })),
+        },
+        eventTypes,
         workflows: compileWorkflows(config),
         routes: compileFrontendRoutes(config),
     };
@@ -446,7 +561,7 @@ function compileWorkflows(config) {
     });
 }
 function runtimeProtocolCapabilities(config) {
-    const usesDirectory = config.data?.resources.some(resource => resource.schema.fields.some(field => ['directory-user', 'directory-department'].includes(field.reference?.kind || '')));
+    const usesDirectory = config.data?.resources.some(resource => resource.schema.fields.some(field => field.type.startsWith('user.') || field.type.startsWith('department.')));
     return uniqueSorted([
         'application-native-2',
         'authz.batch-explain',
@@ -454,7 +569,9 @@ function runtimeProtocolCapabilities(config) {
         'deployment.platform-executor',
         ...(config.data?.resources.length ? ['data-api-v2'] : []),
         ...(usesDirectory ? ['directory-v2'] : []),
-        ...(config.events?.subscriptions.length || config.events?.timers?.length
+        ...(config.events?.subscriptions.length ||
+            config.events?.timers?.length ||
+            config.events?.dateTriggers?.length
             ? ['events-v2', 'events.durable-receipts']
             : []),
         ...(config.workflows?.activations.length ? ['workflow-kernel-v2'] : []),
@@ -475,22 +592,43 @@ function normalizeDataResource(resource) {
                 type: field.type,
                 ...(field.nullable !== undefined ? { nullable: field.nullable } : {}),
                 ...(field.indexed !== undefined ? { indexed: field.indexed } : {}),
-                ...(field.reference
+                ...(field.options ? { options: field.options } : {}),
+                ...(field.source
                     ? {
-                        reference: {
-                            ...field.reference,
-                            ...(field.reference.kind === 'resource'
-                                ? { resourceCode: field.reference.resourceCode }
+                        source: {
+                            kind: field.source.kind,
+                            resourceCode: field.source.resourceCode,
+                            labelField: field.source.labelField,
+                            ...(field.source.searchFields
+                                ? { searchFields: uniqueSorted(field.source.searchFields) }
+                                : {}),
+                            ...(field.source.descriptionFields
+                                ? {
+                                    descriptionFields: uniqueSorted(field.source.descriptionFields),
+                                }
+                                : {}),
+                            ...(field.source.snapshotFields
+                                ? { snapshotFields: uniqueSorted(field.source.snapshotFields) }
+                                : {}),
+                            ...(field.source.filters
+                                ? { filters: field.source.filters.map(filter => ({ ...filter })) }
+                                : {}),
+                            ...(field.source.pageSize !== undefined
+                                ? { pageSize: field.source.pageSize }
+                                : {}),
+                            ...(field.source.loadMode
+                                ? { loadMode: field.source.loadMode }
                                 : {}),
                         },
                     }
                     : {}),
+                ...(field.maxLength !== undefined ? { maxLength: field.maxLength } : {}),
+                ...(field.precision !== undefined ? { precision: field.precision } : {}),
+                ...(field.scale !== undefined ? { scale: field.scale } : {}),
+                ...(field.timePrecision ? { timePrecision: field.timePrecision } : {}),
                 ...(field.file
                     ? {
                         file: {
-                            ...(field.file.multiple !== undefined
-                                ? { multiple: field.file.multiple }
-                                : {}),
                             ...(field.file.maxCount !== undefined
                                 ? { maxCount: field.file.maxCount }
                                 : {}),
@@ -503,8 +641,13 @@ function normalizeDataResource(resource) {
                         },
                     }
                     : {}),
+                ...(field.serial ? { serial: { ...field.serial } } : {}),
+                ...(field.subtable ? { subtable: { ...field.subtable } } : {}),
             })),
         },
+        ...(resource.surface
+            ? { surface: normalizeResourceSurface(resource.surface) }
+            : {}),
         capabilities: { ...resource.capabilities },
         ...(resource.dataPolicyCode
             ? { dataPolicyCode: resource.dataPolicyCode }
@@ -565,7 +708,7 @@ export function renderGeneratedContracts(config, contract = compileContractBundl
     const workflowCodes = contract.workflows.map(item => item.code);
     const resourceSurfaces = Object.fromEntries(sorted(config.data?.resources || [], item => item.code).map(item => [
         item.code,
-        normalizeResourceSurface(item.surface || defaultResourceSurface(item), item.schema.fields),
+        normalizeResourceSurface(item.surface || defaultResourceSurface(item)),
     ]));
     const resourceDefinitions = Object.fromEntries(sorted(config.data?.resources || [], item => item.code).map(item => [
         item.code,
@@ -573,7 +716,7 @@ export function renderGeneratedContracts(config, contract = compileContractBundl
             code: item.code,
             name: item.name,
             capabilities: { ...item.capabilities },
-            surface: normalizeResourceSurface(item.surface || defaultResourceSurface(item), item.schema.fields),
+            surface: normalizeResourceSurface(item.surface || defaultResourceSurface(item)),
         },
     ]));
     const operationEntries = contract.operations.map(operation => [
@@ -581,6 +724,17 @@ export function renderGeneratedContracts(config, contract = compileContractBundl
         operation,
     ]);
     const routeEntries = contract.routes.map(route => [camel(route.code), route]);
+    const eventHandlerEntries = contract.eventHandlerManifest.handlers.map(handler => [
+        handler.code,
+        handler,
+    ]);
+    const eventTypesForSubscription = contract.eventConsumers.length
+        ? contract.eventConsumers
+            .map(consumer => `TCode extends ${JSON.stringify(consumer.code)} ? ${consumer.eventTypes
+            .map(eventType => JSON.stringify(eventType))
+            .join(' | ')} :`)
+            .join(' ') + ' never'
+        : 'never';
     const lines = [
         '// Generated by OpenXiangda 2.0 Native compiler. Do not edit by hand.',
         `export const compilerContractVersion = ${JSON.stringify(COMPILER_CONTRACT_VERSION)} as const;`,
@@ -593,6 +747,9 @@ export function renderGeneratedContracts(config, contract = compileContractBundl
         `export const appRoutes = ${renderEntries(routeEntries)} as const;`,
         `export const eventTypes = ${JSON.stringify(contract.eventTypes, null, 2)} as const;`,
         `export const eventSubscriptionCodes = ${JSON.stringify(eventSubscriptionCodes, null, 2)} as const;`,
+        `export const eventHandlerManifest = ${JSON.stringify(contract.eventHandlerManifest, null, 2)} as const;`,
+        `export const eventHandlers = ${renderEntries(eventHandlerEntries)} as const;`,
+        `export const eventSchemas = ${JSON.stringify(contract.eventSchemas, null, 2)} as const;`,
         `export const workflowCodes = ${JSON.stringify(workflowCodes, null, 2)} as const;`,
         '',
         'export type ResourceCode = (typeof resourceCodes)[number];',
@@ -601,31 +758,68 @@ export function renderGeneratedContracts(config, contract = compileContractBundl
         '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> = ${eventTypesForSubscription};`,
         '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>>;',
+        '',
+        FIELD_VALUE_TYPESCRIPT_DECLARATIONS,
+        '',
     ];
     for (const resource of sorted(config.data?.resources || [], item => item.code)) {
         lines.push(`export interface ${pascal(resource.code)}Record {`);
         lines.push('  id: string;');
         lines.push('  revision: number;');
         for (const field of resource.schema.fields) {
-            const optional = field.nullable === false ? '' : '?';
-            lines.push(`  ${safeProperty(field.code)}${optional}: ${typescriptType(field.type)}${field.nullable === false ? '' : ' | null'};`);
+            const nullable = fieldNullable(field);
+            const optional = nullable ? '?' : '';
+            lines.push(`  ${safeProperty(field.code)}${optional}: ${typescriptType(field.type)}${nullable ? ' | null' : ''};`);
+        }
+        lines.push('}', '');
+        lines.push(`export interface ${pascal(resource.code)}CreateInput {`);
+        for (const field of resource.schema.fields) {
+            if (isGeneratedField(field.type))
+                continue;
+            const nullable = fieldNullable(field);
+            const optional = nullable ? '?' : '';
+            lines.push(`  ${safeProperty(field.code)}${optional}: ${typescriptType(field.type)}${nullable ? ' | null' : ''};`);
+        }
+        lines.push('}', '');
+        lines.push(`export interface ${pascal(resource.code)}UpdateInput {`);
+        for (const field of resource.schema.fields) {
+            if (isGeneratedField(field.type))
+                continue;
+            const nullable = fieldNullable(field);
+            lines.push(`  ${safeProperty(field.code)}?: ${typescriptType(field.type)}${nullable ? ' | null' : ''};`);
         }
         lines.push('}', '');
     }
     return `${lines.join('\n').trimEnd()}\n`;
 }
-function normalizeResourceSurface(surface, schemaFields = []) {
-    const schemaReferences = new Map(schemaFields
-        .filter(field => field.reference)
-        .map(field => [field.code, field.reference]));
+function normalizeResourceSurface(surface) {
     const fields = Object.fromEntries(Object.entries(surface.fields)
         .sort(([left], [right]) => compare(left, right))
         .map(([code, field]) => [
         code,
         {
             label: field.label,
+            type: field.type,
             widget: field.widget,
             ...(field.section ? { section: field.section } : {}),
             ...(field.requiredHint !== undefined
@@ -635,18 +829,24 @@ function normalizeResourceSurface(surface, schemaFields = []) {
             readCapabilities: uniqueSorted(field.readCapabilities),
             createCapabilities: uniqueSorted(field.createCapabilities),
             updateCapabilities: uniqueSorted(field.updateCapabilities),
-            ...(field.multiple !== undefined ? { multiple: field.multiple } : {}),
+            ...(field.maxLength !== undefined ? { maxLength: field.maxLength } : {}),
+            ...(field.precision !== undefined ? { precision: field.precision } : {}),
+            ...(field.scale !== undefined ? { scale: field.scale } : {}),
             ...(field.maxCount !== undefined ? { maxCount: field.maxCount } : {}),
+            ...(field.maxSizeMb !== undefined ? { maxSizeMb: field.maxSizeMb } : {}),
             ...(field.accept !== undefined ? { accept: field.accept } : {}),
             ...(field.options ? { options: field.options } : {}),
+            ...(field.source ? { source: { ...field.source } } : {}),
+            ...(field.timePrecision
+                ? { timePrecision: field.timePrecision }
+                : {}),
+            ...(field.serial ? { serial: { ...field.serial } } : {}),
+            ...(field.subtable ? { subtable: { ...field.subtable } } : {}),
             ...(field.list !== undefined ? { list: field.list } : {}),
             ...(field.searchable !== undefined
                 ? { searchable: field.searchable }
                 : {}),
             ...(field.sortable !== undefined ? { sortable: field.sortable } : {}),
-            ...(field.reference || schemaReferences.get(code)
-                ? { reference: field.reference || schemaReferences.get(code) }
-                : {}),
         },
     ]));
     return {
@@ -680,23 +880,31 @@ function defaultResourceSurface(resource) {
     const visible = fields.slice(0, 8);
     const first = fields[0]?.code || 'id';
     const searchableFields = fields
-        .filter(field => ['string', 'text'].includes(field.type))
+        .filter(field => supportsSearch(field.type))
         .slice(0, 5)
         .map(field => field.code);
     const surfaceFields = Object.fromEntries(fields.map(field => [
         field.code,
         {
             label: field.code,
+            type: field.type,
             widget: resolveDataFieldSurfaceWidget(field),
             ...(field.nullable === false ? { requiredHint: true } : {}),
-            ...(field.file?.multiple !== undefined
-                ? { multiple: field.file.multiple }
-                : {}),
+            ...(field.maxLength !== undefined ? { maxLength: field.maxLength } : {}),
+            ...(field.precision !== undefined ? { precision: field.precision } : {}),
+            ...(field.scale !== undefined ? { scale: field.scale } : {}),
             ...(field.file?.maxCount !== undefined
                 ? { maxCount: field.file.maxCount }
                 : {}),
+            ...(field.file?.maxSizeMb !== undefined
+                ? { maxSizeMb: field.file.maxSizeMb }
+                : {}),
             ...(field.file?.accept ? { accept: uniqueSorted(field.file.accept) } : {}),
-            ...(field.reference ? { reference: field.reference } : {}),
+            ...(field.options ? { options: field.options } : {}),
+            ...(field.source ? { source: field.source } : {}),
+            ...(field.timePrecision ? { timePrecision: field.timePrecision } : {}),
+            ...(field.serial ? { serial: { ...field.serial } } : {}),
+            ...(field.subtable ? { subtable: { ...field.subtable } } : {}),
             readCapabilities: [resource.capabilities.read],
             createCapabilities: [resource.capabilities.create],
             updateCapabilities: [resource.capabilities.update],
@@ -705,7 +913,7 @@ function defaultResourceSurface(resource) {
                 : {}),
             ...(searchableFields.includes(field.code) ? { searchable: true } : {}),
             ...(visible.some(item => item.code === field.code) &&
-                ['string', 'text', 'integer', 'decimal', 'date', 'datetime'].includes(field.type)
+                supportsSort(field.type)
                 ? { sortable: true }
                 : {}),
         },
@@ -767,13 +975,4 @@ function safeProperty(value) {
         ? value
         : JSON.stringify(value);
 }
-function typescriptType(type) {
-    if (type === 'integer' || type === 'decimal')
-        return 'number';
-    if (type === 'boolean')
-        return 'boolean';
-    if (type === 'json')
-        return 'unknown';
-    return 'string';
-}
 //# sourceMappingURL=bundle.js.map