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

package/dist/compiler/config.js

@@ -1,4 +1,5 @@
-import { SCHEMA_VERSIONS, DATA_FIELD_TYPES, nativePlatformCapabilityCatalog, validateDataResource, } from 'openxiangda-contracts';
+import { SCHEMA_VERSIONS, DATA_FIELD_TYPES, PLATFORM_EVENT_TYPES_V2, nativePlatformCapabilityCatalog, validateDataResource, } from 'openxiangda-contracts';
+import { Ajv2020 } from 'ajv/dist/2020.js';
 import { CronExpressionParser } from 'cron-parser';
 import { fieldNullable, isGeneratedField } from './field-codec.js';
 import { supportsFilter, supportsSearch, supportsSort, } from './field-query-plan.js';
@@ -8,6 +9,14 @@ import { compatibleWidgets, isCompatibleFieldWidget, resolveDataFieldSurfaceWidg
 // The compiler owns the application source contract. Devkit and every adapter
 // re-export this module instead of maintaining separate configuration models.
 import { validateWorkflowBinding, validateWorkflowDefinition, } from '../internal/workflow.js';
+const DATE_TRIGGER_RESERVED_DATA_FIELDS = new Set([
+    'triggerCode',
+    'resourceCode',
+    'recordId',
+    'recordRevision',
+    'field',
+    'dueAt',
+]);
 const APP_DATA_FIELD_TYPES = new Set(DATA_FIELD_TYPES);
 export const openXiangdaAppConfigSchema = {
     $id: 'openxiangda.app-config/v3',
@@ -154,6 +163,11 @@ export const openXiangdaAppConfigSchema = {
             additionalProperties: false,
             required: ['subscriptions'],
             properties: {
+                schemas: {
+                    type: 'array',
+                    maxItems: 100,
+                    items: { type: 'object' },
+                },
                 subscriptions: {
                     type: 'array',
                     maxItems: 100,
@@ -164,6 +178,11 @@ export const openXiangdaAppConfigSchema = {
                     maxItems: 100,
                     items: { type: 'object' },
                 },
+                dateTriggers: {
+                    type: 'array',
+                    maxItems: 100,
+                    items: { type: 'object' },
+                },
             },
         },
         workflows: {
@@ -239,6 +258,7 @@ export function backendRuntimeRequired(config) {
                 backend.secrets?.length ||
                 config.events?.subscriptions?.length ||
                 config.events?.timers?.length ||
+                config.events?.dateTriggers?.length ||
                 config.workflows?.activations?.length ||
                 config.workflows?.providers?.length)));
 }
@@ -250,6 +270,109 @@ function object(value) {
 function string(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function eventSchemaDeclaresPath(schema, path) {
+    let current = schema;
+    for (const segment of path.split('.')) {
+        if (current.type === 'array')
+            current = object(current.items);
+        const properties = object(current.properties);
+        if (!Object.prototype.hasOwnProperty.call(properties, segment)) {
+            return false;
+        }
+        current = object(properties[segment]);
+    }
+    return true;
+}
+function eventDataMatchesSchema(schema, data) {
+    if (!schema)
+        return false;
+    try {
+        const validator = new Ajv2020({
+            allErrors: true,
+            strict: false,
+            validateFormats: false,
+        }).compile(schema);
+        return Boolean(validator(data));
+    }
+    catch {
+        return false;
+    }
+}
+function validDateTriggerOffset(value) {
+    const match = /^([+-])?P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(string(value));
+    if (!match || !match.slice(2).some(part => part !== undefined))
+        return false;
+    const milliseconds = Number(match[2] || 0) * 24 * 60 * 60 * 1000 +
+        Number(match[3] || 0) * 60 * 60 * 1000 +
+        Number(match[4] || 0) * 60 * 1000 +
+        Number(match[5] || 0) * 1000;
+    return (Number.isFinite(milliseconds) &&
+        milliseconds <= 10 * 365 * 24 * 60 * 60 * 1000);
+}
+const EVENT_TYPE_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9_-]*)+\.v[1-9][0-9]*$/;
+const EVENT_DATA_SCHEMA_VERSION_PATTERN = /^[1-9][0-9]*\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)$/;
+const EVENT_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+function eventPredicateValid(value) {
+    const predicate = object(value);
+    const keys = Object.keys(predicate);
+    if (keys.length !== 1 ||
+        !['eq', 'ne', 'in', 'notIn', 'exists'].includes(keys[0] || '')) {
+        return false;
+    }
+    const operand = predicate[keys[0]];
+    if (keys[0] === 'exists' && typeof operand !== 'boolean')
+        return false;
+    if ((keys[0] === 'in' || keys[0] === 'notIn') &&
+        (!Array.isArray(operand) || operand.length < 1 || operand.length > 20))
+        return false;
+    try {
+        const serialized = JSON.stringify(predicate);
+        return (typeof serialized === 'string' &&
+            Buffer.byteLength(serialized, 'utf8') <= 4096);
+    }
+    catch {
+        return false;
+    }
+}
+function validateEventChangeFilter(value, path, allowedFields, diagnostics) {
+    const change = object(value);
+    const field = string(change.field);
+    const keys = Object.keys(change);
+    if (!EVENT_FIELD_PATTERN.test(field) ||
+        !allowedFields.has(field) ||
+        keys.some(key => !['field', 'before', 'after'].includes(key)) ||
+        (!('before' in change) && !('after' in change)) ||
+        ('before' in change && !eventPredicateValid(change.before)) ||
+        ('after' in change && !eventPredicateValid(change.after))) {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGE_FILTER_INVALID', '字段变化条件必须引用已声明字段，并且 before/after 各只使用一个受支持操作符', path));
+    }
+}
+function validateEventFilterCondition(value, path, allowedFields, diagnostics, state, depth = 1) {
+    const condition = object(value);
+    const keys = Object.keys(condition);
+    if (depth > 3 || keys.length !== 1) {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_COMPLEXITY_EXCEEDED', '事件过滤条件最多嵌套 3 层，且每层只能声明 change/all/any/not 之一', path));
+        return;
+    }
+    const key = keys[0];
+    if (key === 'change') {
+        state.atoms += 1;
+        validateEventChangeFilter(condition.change, `${path}.change`, allowedFields, diagnostics);
+    }
+    else if (key === 'all' || key === 'any') {
+        const items = Array.isArray(condition[key]) ? condition[key] : [];
+        if (items.length < 1 || items.length > 16) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_GROUP_INVALID', '事件过滤 all/any 必须包含 1 到 16 个条件', `${path}.${key}`));
+        }
+        items.forEach((item, index) => validateEventFilterCondition(item, `${path}.${key}[${index}]`, allowedFields, diagnostics, state, depth + 1));
+    }
+    else if (key === 'not') {
+        validateEventFilterCondition(condition.not, `${path}.not`, allowedFields, diagnostics, state, depth + 1);
+    }
+    else {
+        diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_OPERATOR_INVALID', '事件过滤条件只支持 change/all/any/not', path));
+    }
+}
 export function validateAppConfig(value) {
     const diagnostics = [];
     const config = object(value);
@@ -322,6 +445,8 @@ export function validateAppConfig(value) {
             Array.isArray(eventConfig.subscriptions) &&
                 eventConfig.subscriptions.length > 0 ||
             Array.isArray(eventConfig.timers) && eventConfig.timers.length > 0 ||
+            Array.isArray(eventConfig.dateTriggers) &&
+                eventConfig.dateTriggers.length > 0 ||
             Array.isArray(workflowConfig.activations) &&
                 workflowConfig.activations.length > 0 ||
             Array.isArray(workflowConfig.providers) && workflowConfig.providers.length > 0)) {
@@ -732,6 +857,70 @@ export function validateAppConfig(value) {
     }
     validateCapabilityClosure(appCode, config, declaredCapabilities, diagnostics);
     const events = object(config.events);
+    const eventDataResources = Array.isArray(object(config.data).resources)
+        ? object(config.data).resources
+        : [];
+    const eventResourceFields = new Map(eventDataResources.map(rawResource => {
+        const resource = object(rawResource);
+        const fields = Array.isArray(object(resource.schema).fields)
+            ? object(resource.schema).fields
+            : [];
+        return [
+            string(resource.code),
+            new Map(fields.map(rawField => {
+                const field = object(rawField);
+                return [string(field.code), string(field.type)];
+            })),
+        ];
+    }));
+    const platformEventTypes = new Set(PLATFORM_EVENT_TYPES_V2);
+    const declaredEventTypes = new Set();
+    const applicationEventSchemas = new Map();
+    const schemaKeys = new Set();
+    (Array.isArray(events.schemas) ? events.schemas : []).forEach((item, index) => {
+        const schema = object(item);
+        const path = `events.schemas[${index}]`;
+        const eventType = string(schema.eventType);
+        const dataSchemaVersion = string(schema.dataSchemaVersion);
+        const jsonSchema = object(schema.jsonSchema);
+        const sensitiveFields = Array.isArray(schema.sensitiveFields)
+            ? schema.sensitiveFields.map(value => string(value))
+            : [];
+        const sensitiveFieldsValid = (schema.sensitiveFields === undefined ||
+            Array.isArray(schema.sensitiveFields)) &&
+            sensitiveFields.length <= 100 &&
+            new Set(sensitiveFields).size === sensitiveFields.length &&
+            sensitiveFields.every(field => /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*){0,7}$/.test(field) && eventSchemaDeclaresPath(jsonSchema, field));
+        const schemaKey = `${eventType}:${dataSchemaVersion}`;
+        let schemaBytes = Number.POSITIVE_INFINITY;
+        try {
+            schemaBytes = Buffer.byteLength(JSON.stringify(schema.jsonSchema), 'utf8');
+        }
+        catch {
+            // Reported by the combined validation below.
+        }
+        const schemaValid = !(!EVENT_TYPE_PATTERN.test(eventType) ||
+            eventType.startsWith('openxiangda.') ||
+            !eventType.startsWith(`${appCode}.`) ||
+            !EVENT_DATA_SCHEMA_VERSION_PATTERN.test(dataSchemaVersion) ||
+            object(schema.jsonSchema) !== schema.jsonSchema ||
+            jsonSchema.type !== 'object' ||
+            schemaBytes > 256 * 1024 ||
+            !sensitiveFieldsValid ||
+            schemaKeys.has(schemaKey) ||
+            declaredEventTypes.has(eventType));
+        if (!schemaValid) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_SCHEMA_INVALID', '应用事件 Schema 必须使用 appCode 命名空间、major 事件类型、SemVer dataSchemaVersion、不超过 256 KiB 的 object JSON Schema；sensitiveFields 最多 100 个、路径规范且必须指向已声明字段，且版本不可重复', path));
+        }
+        if (schemaValid) {
+            declaredEventTypes.add(eventType);
+            applicationEventSchemas.set(eventType, jsonSchema);
+        }
+        schemaKeys.add(schemaKey);
+    });
+    const allowedEventTypes = new Set([...platformEventTypes, ...declaredEventTypes]);
+    const captureFieldsByResource = new Map();
+    const subscriptionCodes = new Set();
     if (config.events !== undefined && !Array.isArray(events.subscriptions)) {
         diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTIONS_REQUIRED', 'events.subscriptions 必须是数组', 'events.subscriptions'));
     }
@@ -742,34 +931,154 @@ export function validateAppConfig(value) {
             if ('environmentKey' in subscription) {
                 diagnostics.push(diagnostic('APP_CONFIG_ENVIRONMENT_OVERRIDE_FORBIDDEN', '事件声明属于环境中立 AppVersion，不能声明 environmentKey', `${path}.environmentKey`));
             }
-            if (!/^[a-z][a-z0-9-]*$/.test(string(subscription.code))) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTION_CODE_INVALID', '事件订阅 code 必须是 kebab-case', `${path}.code`));
+            const subscriptionCode = string(subscription.code);
+            if (!/^[a-z][a-z0-9-]*$/.test(subscriptionCode) ||
+                subscriptionCodes.has(subscriptionCode)) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_SUBSCRIPTION_CODE_INVALID', '事件订阅 code 必须是唯一的 kebab-case', `${path}.code`));
             }
             if (!Array.isArray(subscription.eventTypes) ||
-                subscription.eventTypes.length === 0) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_TYPES_REQUIRED', '事件订阅必须声明 eventTypes', `${path}.eventTypes`));
+                subscription.eventTypes.length === 0 ||
+                subscription.eventTypes.length > 20 ||
+                new Set(subscription.eventTypes.map(string)).size !==
+                    subscription.eventTypes.length ||
+                subscription.eventTypes.some(eventType => !allowedEventTypes.has(string(eventType)))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_TYPES_INVALID', '事件订阅必须声明 1 到 20 个不重复且已注册的 v2 eventTypes', `${path}.eventTypes`));
+            }
+            if ('endpointPath' in subscription) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_ENDPOINT_DECLARATION_FORBIDDEN', '事件订阅 endpointPath 由 code 生成，应用不能重复声明', `${path}.endpointPath`));
+            }
+            subscriptionCodes.add(subscriptionCode);
+            const filter = object(subscription.filter);
+            const filterKeys = Object.keys(filter);
+            const resourceCodes = Array.isArray(filter.resourceCodes)
+                ? filter.resourceCodes.map(string)
+                : [];
+            if (filterKeys.some(key => !['resourceCodes', 'subject', 'changedFields', 'changes', 'where'].includes(key)) ||
+                resourceCodes.length > 20 ||
+                new Set(resourceCodes).size !== resourceCodes.length ||
+                resourceCodes.some(code => !eventResourceFields.has(code))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_RESOURCE_INVALID', '事件过滤 resourceCodes 必须引用最多 20 个不重复的已声明资源', `${path}.filter`));
+            }
+            const allowedFields = new Set();
+            if (resourceCodes.length > 0) {
+                const fieldSets = resourceCodes
+                    .map(code => eventResourceFields.get(code))
+                    .filter(Boolean);
+                for (const field of fieldSets[0]?.keys() || []) {
+                    if (fieldSets.every(fields => fields.has(field)))
+                        allowedFields.add(field);
+                }
+            }
+            const subject = object(filter.subject);
+            if (Object.keys(subject).length > 1 ||
+                Object.keys(subject).some(key => !['equals', 'prefix'].includes(key)) ||
+                Object.values(subject).some(value => typeof value !== 'string')) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_SUBJECT_INVALID', 'subject 过滤只能声明 equals 或 prefix 之一', `${path}.filter.subject`));
             }
-            const endpointPath = string(subscription.endpointPath);
-            if (!endpointPath.startsWith('/') ||
-                endpointPath.startsWith('//') ||
-                endpointPath.includes('..')) {
-                diagnostics.push(diagnostic('APP_CONFIG_EVENT_ENDPOINT_INVALID', '事件订阅 endpointPath 必须是应用后端相对路径', `${path}.endpointPath`));
+            const referencedFields = new Set();
+            const changedFields = object(filter.changedFields);
+            const filterComplexity = {
+                atoms: (resourceCodes.length > 0 ? 1 : 0) +
+                    (Object.keys(subject).length > 0 ? 1 : 0),
+            };
+            for (const [group, rawFields] of Object.entries(changedFields)) {
+                const fields = Array.isArray(rawFields) ? rawFields.map(string) : [];
+                fields.forEach(field => referencedFields.add(field));
+                if (['anyOf', 'allOf', 'noneOf'].includes(group)) {
+                    filterComplexity.atoms += 1;
+                }
+                if (!['anyOf', 'allOf', 'noneOf'].includes(group) ||
+                    fields.length < 1 ||
+                    fields.length > 32 ||
+                    new Set(fields).size !== fields.length) {
+                    diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGED_FIELDS_INVALID', 'changedFields 只支持 anyOf/allOf/noneOf，每组 1 到 32 个不重复字段', `${path}.filter.changedFields.${group}`));
+                }
+            }
+            const changes = Array.isArray(filter.changes) ? filter.changes : [];
+            filterComplexity.atoms += changes.length;
+            if (changes.length > 16) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_CHANGE_FILTERS_EXCEEDED', '单个订阅最多声明 16 个字段变化条件', `${path}.filter.changes`));
+            }
+            changes.forEach((change, changeIndex) => {
+                referencedFields.add(string(object(change).field));
+                validateEventChangeFilter(change, `${path}.filter.changes[${changeIndex}]`, allowedFields, diagnostics);
+            });
+            if (filter.where !== undefined) {
+                validateEventFilterCondition(filter.where, `${path}.filter.where`, allowedFields, diagnostics, filterComplexity);
+            }
+            if (filterComplexity.atoms > 16) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_FILTER_ATOMS_EXCEEDED', '单个订阅最多包含 16 个原子过滤条件', `${path}.filter`));
+            }
+            const payload = object(subscription.payload);
+            const projectionFields = Array.isArray(payload.fields)
+                ? payload.fields.map(string)
+                : [];
+            projectionFields.forEach(field => referencedFields.add(field));
+            if (Object.keys(payload).some(key => !['includeChanges', 'fields'].includes(key)) ||
+                (payload.includeChanges !== undefined &&
+                    typeof payload.includeChanges !== 'boolean') ||
+                projectionFields.length > 32 ||
+                new Set(projectionFields).size !== projectionFields.length ||
+                referencedFields.size > 0 && resourceCodes.length === 0 ||
+                [...referencedFields].some(field => !allowedFields.has(field))) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_PROJECTION_INVALID', '字段过滤和 payload.fields 必须绑定 resourceCodes、引用各目标资源共有字段，且单订阅投影最多 32 个字段', `${path}.payload`));
+            }
+            for (const resourceCode of resourceCodes) {
+                const captured = captureFieldsByResource.get(resourceCode) || new Set();
+                referencedFields.forEach(field => captured.add(field));
+                captureFieldsByResource.set(resourceCode, captured);
+            }
+            const delivery = {
+                timeoutMs: 10_000,
+                maxAttempts: 8,
+                initialBackoffMs: 1_000,
+                maxBackoffMs: 300_000,
+                ordering: 'none',
+                concurrency: 10,
+                ...object(subscription.delivery),
+            };
+            if (!Number.isInteger(delivery.timeoutMs) ||
+                Number(delivery.timeoutMs) < 1000 ||
+                Number(delivery.timeoutMs) > 30_000 ||
+                !Number.isInteger(delivery.maxAttempts) ||
+                Number(delivery.maxAttempts) < 1 ||
+                Number(delivery.maxAttempts) > 12 ||
+                !Number.isInteger(delivery.initialBackoffMs) ||
+                Number(delivery.initialBackoffMs) < 1000 ||
+                !Number.isInteger(delivery.maxBackoffMs) ||
+                Number(delivery.maxBackoffMs) < Number(delivery.initialBackoffMs) ||
+                Number(delivery.maxBackoffMs) > 1_800_000 ||
+                !['none', 'record'].includes(string(delivery.ordering)) ||
+                !Number.isInteger(delivery.concurrency) ||
+                Number(delivery.concurrency) < 1 ||
+                Number(delivery.concurrency) > 50) {
+                diagnostics.push(diagnostic('APP_CONFIG_EVENT_DELIVERY_POLICY_INVALID', 'delivery 超出 timeout、attempt、backoff、ordering 或 concurrency 的平台上限', `${path}.delivery`));
             }
         });
     }
+    for (const [resourceCode, fields] of captureFieldsByResource) {
+        if (fields.size > 64) {
+            diagnostics.push(diagnostic('APP_CONFIG_EVENT_CAPTURE_PLAN_EXCEEDED', `资源 ${resourceCode} 的订阅捕获字段并集超过 64 个`, 'events.subscriptions'));
+        }
+    }
+    const timerCodes = new Set();
     (Array.isArray(events.timers) ? events.timers : []).forEach((item, index) => {
         const timer = object(item);
         const path = `events.timers[${index}]`;
         if ('environmentKey' in timer) {
             diagnostics.push(diagnostic('APP_CONFIG_ENVIRONMENT_OVERRIDE_FORBIDDEN', '定时声明属于环境中立 AppVersion，不能声明 environmentKey', `${path}.environmentKey`));
         }
-        if (!/^[a-z][a-z0-9-]*$/.test(string(timer.code))) {
+        if (!/^[a-z][a-z0-9-]*$/.test(string(timer.code)) ||
+            timerCodes.has(string(timer.code))) {
             diagnostics.push(diagnostic('APP_CONFIG_TIMER_CODE_INVALID', '定时订阅 code 必须是 kebab-case', `${path}.code`));
         }
-        if (!string(timer.eventType) ||
+        timerCodes.add(string(timer.code));
+        if (!declaredEventTypes.has(string(timer.eventType)) ||
             !string(timer.cronExpression) ||
-            !string(timer.timezone)) {
-            diagnostics.push(diagnostic('APP_CONFIG_TIMER_SCHEDULE_REQUIRED', '定时订阅必须声明 eventType、六段 cronExpression 和 IANA timezone', path));
+            !string(timer.timezone) ||
+            (timer.misfirePolicy !== undefined &&
+                timer.misfirePolicy !== 'coalesce_one')) {
+            diagnostics.push(diagnostic('APP_CONFIG_TIMER_SCHEDULE_REQUIRED', '定时订阅必须引用应用事件 Schema，并声明六段 cronExpression、IANA timezone 和 coalesce_one misfire policy', path));
         }
         const cronExpression = string(timer.cronExpression);
         const timezone = string(timer.timezone);
@@ -799,6 +1108,49 @@ export function validateAppConfig(value) {
         else if (Buffer.byteLength(JSON.stringify(timer.payload || {}), 'utf8') > 64 * 1024) {
             diagnostics.push(diagnostic('APP_CONFIG_TIMER_PAYLOAD_TOO_LARGE', '定时事件 payload 不能超过 64 KiB', `${path}.payload`));
         }
+        else if (!eventDataMatchesSchema(applicationEventSchemas.get(string(timer.eventType)), timer.payload)) {
+            diagnostics.push(diagnostic('APP_CONFIG_TIMER_PAYLOAD_SCHEMA_INVALID', '定时事件 payload 必须完整满足所引用的应用事件 JSON Schema', `${path}.payload`));
+        }
+    });
+    const dateTriggerCodes = new Set();
+    (Array.isArray(events.dateTriggers) ? events.dateTriggers : []).forEach((item, index) => {
+        const trigger = object(item);
+        const path = `events.dateTriggers[${index}]`;
+        const code = string(trigger.code);
+        const resourceCode = string(trigger.resourceCode);
+        const field = string(trigger.field);
+        const fieldType = eventResourceFields.get(resourceCode)?.get(field);
+        const payload = object(trigger.payload);
+        let payloadBytes = Number.POSITIVE_INFINITY;
+        try {
+            payloadBytes = Buffer.byteLength(JSON.stringify(trigger.payload || {}), 'utf8');
+        }
+        catch {
+            // Reported by the combined validation below.
+        }
+        if (!/^[a-z][a-z0-9-]*$/.test(code) ||
+            dateTriggerCodes.has(code) ||
+            !eventResourceFields.has(resourceCode) ||
+            !['date', 'datetime'].includes(fieldType || '') ||
+            !validDateTriggerOffset(trigger.offset) ||
+            !declaredEventTypes.has(string(trigger.eventType)) ||
+            trigger.payload === null ||
+            typeof trigger.payload !== 'object' ||
+            Array.isArray(trigger.payload) ||
+            payloadBytes > 64 * 1024 ||
+            Object.keys(payload).some(key => DATE_TRIGGER_RESERVED_DATA_FIELDS.has(key)) ||
+            !eventDataMatchesSchema(applicationEventSchemas.get(string(trigger.eventType)), {
+                ...payload,
+                triggerCode: code,
+                resourceCode,
+                recordId: '00000000-0000-4000-8000-000000000000',
+                recordRevision: 1,
+                field,
+                dueAt: '2026-01-01T00:00:00.000Z',
+            })) {
+            diagnostics.push(diagnostic('APP_CONFIG_DATE_TRIGGER_INVALID', 'dateTrigger 必须使用唯一 code、date/datetime 字段、十年内 ISO-8601 offset、已注册应用事件、无保留字段且完整生成数据满足 JSON Schema', path));
+        }
+        dateTriggerCodes.add(code);
     });
     const workflows = object(config.workflows);
     if (config.workflows !== undefined &&