openxiangda-devkit-core 2.0.0-alpha.80 → 2.0.0-alpha.81

package/dist/compiler/config.js

@@ -346,17 +346,6 @@ export const openXiangdaAppConfigSchema = {
             required: ['root'],
             properties: {
                 root: { type: 'string', minLength: 1 },
-                requiredCapabilities: {
-                    type: 'array',
-                    maxItems: 64,
-                    uniqueItems: true,
-                    items: {
-                        type: 'string',
-                        minLength: 1,
-                        maxLength: 128,
-                        pattern: '^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$',
-                    },
-                },
             },
         },
         perspectives: {
@@ -737,19 +726,14 @@ export function validateAppConfig(value) {
     if (!string(app.name)) {
         diagnostics.push(diagnostic('APP_CONFIG_NAME_REQUIRED', 'app.name 必须是非空字符串', 'app.name'));
     }
-    const requiredCapabilities = object(config.platform).requiredCapabilities;
-    if (requiredCapabilities !== undefined &&
-        (!Array.isArray(requiredCapabilities) ||
-            requiredCapabilities.length > 64 ||
-            new Set(requiredCapabilities).size !== requiredCapabilities.length ||
-            requiredCapabilities.some(capability => typeof capability !== 'string' ||
-                capability.length > 128 ||
-                !/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(capability)))) {
-        diagnostics.push(diagnostic('APP_CONFIG_PLATFORM_CAPABILITIES_INVALID', 'platform.requiredCapabilities 必须是不重复的规范平台能力代码数组（最多 64 项）', 'platform.requiredCapabilities'));
+    const platform = object(config.platform);
+    for (const key of Object.keys(platform)) {
+        if (key !== 'root') {
+            diagnostics.push(diagnostic('APP_CONFIG_PLATFORM_PROPERTY_UNSUPPORTED', `platform.${key} 不属于应用声明合同；平台能力要求只能由 compiler 派生`, `platform.${key}`));
+        }
     }
     const frontend = object(config.frontend);
     const backend = object(config.backend);
-    const platform = object(config.platform);
     const backendKeys = new Set([
         'root',
         'runtime',
@@ -795,10 +779,25 @@ export function validateAppConfig(value) {
     validateFrontendRoutes(config, diagnostics);
     validateAdminNavigation(config, diagnostics);
     validatePerspectives(config.perspectives, object(config.authz).roles, diagnostics);
-    const declaredResourceCodes = new Set((Array.isArray(object(config.data).resources)
+    const declaredResources = new Map((Array.isArray(object(config.data).resources)
         ? object(config.data).resources
-        : []).map(resource => string(object(resource).code)));
-    validateBackendOperations(backend.operations, declaredResourceCodes, diagnostics);
+        : []).map(resource => {
+        const item = object(resource);
+        const schema = object(item.schema);
+        const fields = Array.isArray(schema.fields) ? schema.fields : [];
+        return [
+            string(item.code),
+            new Map(fields.map(field => {
+                const declaration = object(field);
+                return [string(declaration.code), string(declaration.type)];
+            })),
+        ];
+    }));
+    const declaredResourceCodes = new Set(declaredResources.keys());
+    const declaredWorkflowCodes = new Set((Array.isArray(object(config.workflows).activations)
+        ? object(config.workflows).activations
+        : []).map(item => string(object(item).workflowCode)));
+    validateBackendOperations(backend.operations, declaredResources, declaredWorkflowCodes, diagnostics);
     const eventConfig = object(config.events);
     const workflowConfig = object(config.workflows);
     if (backend.enabled === false &&
@@ -1646,7 +1645,7 @@ export function validateAppConfig(value) {
                 !Number.isInteger(delivery.maxBackoffMs) ||
                 Number(delivery.maxBackoffMs) < Number(delivery.initialBackoffMs) ||
                 Number(delivery.maxBackoffMs) > 1_800_000 ||
-                !['none', 'record'].includes(string(delivery.ordering)) ||
+                !['none', 'record', 'workflow-instance'].includes(string(delivery.ordering)) ||
                 !Number.isInteger(delivery.concurrency) ||
                 Number(delivery.concurrency) < 1 ||
                 Number(delivery.concurrency) > 50) {
@@ -1881,6 +1880,20 @@ export function validateAppConfig(value) {
                 string(object(declaration.definition).code)) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_USER_TITLE_REQUIRED', 'Workflow title 必须是用户可读本地化名称，不能等于内部 code', `${path}.definition.title`));
             }
+            const subject = object(definition.subject);
+            const factProjection = object(subject.factProjection);
+            const factEntries = Object.entries(factProjection);
+            const subjectFields = eventResourceFields.get(string(subject.resourceCode));
+            if (Object.keys(subject).some(key => !['resourceCode', 'factProjection'].includes(key)) ||
+                !subjectFields ||
+                !isRecord(subject.factProjection) ||
+                factEntries.length < 1 ||
+                factEntries.length > 64 ||
+                factEntries.some(([factKey, fieldCode]) => !/^[A-Za-z][A-Za-z0-9_.]{0,127}$/.test(factKey) ||
+                    !/^[A-Za-z][A-Za-z0-9_]{0,62}$/.test(string(fieldCode)) ||
+                    !subjectFields.has(string(fieldCode)))) {
+                diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_SUBJECT_INVALID', 'Workflow subject 必须绑定已声明资源，并将 1 到 64 个 fact key 映射到该资源的已声明字段', `${path}.definition.subject`));
+            }
             for (const error of validateWorkflowDefinition(definition)) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DEFINITION_INVALID', error, path));
             }
@@ -1904,10 +1917,23 @@ export function validateAppConfig(value) {
             }
             bindingByKey.set(key, binding);
         });
+        const activationWorkflowCodes = new Set();
         activations.forEach((item, index) => {
             const activation = object(item);
             const path = `workflows.activations[${index}]`;
+            if (Object.keys(activation).some(key => ![
+                'workflowCode',
+                'definitionVersion',
+                'bindingVersion',
+                'acceptedCommandDeactivationPolicy',
+            ].includes(key))) {
+                diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_ACTIVATION_INVALID', 'Workflow activation 只能声明固定版本与停用策略', path));
+            }
             const workflowCode = string(activation.workflowCode);
+            if (activationWorkflowCodes.has(workflowCode)) {
+                diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_ACTIVATION_DUPLICATE', `Workflow activation 重复: ${workflowCode}`, path));
+            }
+            activationWorkflowCodes.add(workflowCode);
             if ('environmentKey' in activation) {
                 diagnostics.push(diagnostic('APP_CONFIG_ENVIRONMENT_OVERRIDE_FORBIDDEN', 'Workflow activation 属于环境中立 AppVersion，不能声明 environmentKey', `${path}.environmentKey`));
             }
@@ -1919,6 +1945,10 @@ export function validateAppConfig(value) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_ACTIVATION_VERSION_NOT_FOUND', 'Workflow activation 引用的 definition 或 binding 版本不存在', path));
                 return;
             }
+            if (activation.acceptedCommandDeactivationPolicy !==
+                definition.acceptedCommandDeactivationPolicy) {
+                diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_ACTIVATION_DEACTIVATION_POLICY_MISMATCH', 'Workflow activation 停用策略必须等于所选 definition', `${path}.acceptedCommandDeactivationPolicy`));
+            }
             for (const error of validateWorkflowBinding(definition, binding)) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_BINDING_INVALID', error, path));
             }
@@ -2047,7 +2077,8 @@ function validateCapabilityDeclarations(appCode, declarations, diagnostics) {
         seen.add(code);
     });
 }
-function validateBackendOperations(rawOperations, declaredResourceCodes, diagnostics) {
+function validateBackendOperations(rawOperations, declaredResources, declaredWorkflowCodes, diagnostics) {
+    const declaredResourceCodes = new Set(declaredResources.keys());
     if (rawOperations !== undefined && !Array.isArray(rawOperations)) {
         diagnostics.push(diagnostic('APP_CONFIG_BACKEND_OPERATIONS_INVALID', 'backend.operations 必须是数组', 'backend.operations'));
         return;
@@ -2075,6 +2106,87 @@ function validateBackendOperations(rawOperations, declaredResourceCodes, diagnos
         if ('resources' in operation) {
             diagnostics.push(diagnostic('APP_CONFIG_BACKEND_OPERATION_RESOURCES_REMOVED', '资源范围只能在显式 backend.operations[].ai 中声明', `${path}.resources`));
         }
+        if (operation.platformAccess !== undefined) {
+            const access = object(operation.platformAccess);
+            const allowedAccessKeys = new Set([
+                'directory',
+                'managedFiles',
+                'notification',
+                'workflow',
+            ]);
+            let invalid = !isRecord(operation.platformAccess) ||
+                Object.keys(access).length === 0 ||
+                Object.keys(access).some(key => !allowedAccessKeys.has(key));
+            if (access.directory !== undefined) {
+                const directory = object(access.directory);
+                const fields = Array.isArray(directory.fields) ? directory.fields : [];
+                const allowedFields = new Set([
+                    'displayName',
+                    'employeeNumber',
+                    'primaryDepartment',
+                    'departments',
+                ]);
+                invalid ||=
+                    directory.mode !== 'current-initiator' ||
+                        fields.length === 0 ||
+                        fields.length > allowedFields.size ||
+                        new Set(fields).size !== fields.length ||
+                        fields.some(field => !allowedFields.has(string(field))) ||
+                        Object.keys(directory).some(key => !['mode', 'fields'].includes(key));
+            }
+            if (access.managedFiles !== undefined) {
+                const managedFiles = Array.isArray(access.managedFiles)
+                    ? access.managedFiles
+                    : [];
+                invalid ||= managedFiles.length === 0 || managedFiles.length > 16;
+                const resources = new Set();
+                for (const rawManagedFile of managedFiles) {
+                    const managedFile = object(rawManagedFile);
+                    const resourceCode = string(managedFile.resourceCode);
+                    const fieldCodes = Array.isArray(managedFile.fieldCodes)
+                        ? managedFile.fieldCodes.map(string)
+                        : [];
+                    const intents = Array.isArray(managedFile.intents)
+                        ? managedFile.intents.map(string)
+                        : [];
+                    const resourceFields = declaredResources.get(resourceCode);
+                    invalid ||=
+                        !resourceFields ||
+                            resources.has(resourceCode) ||
+                            fieldCodes.length === 0 ||
+                            fieldCodes.length > 16 ||
+                            new Set(fieldCodes).size !== fieldCodes.length ||
+                            fieldCodes.some(fieldCode => !['file', 'image', 'signature'].includes(string(resourceFields?.get(fieldCode)))) ||
+                            intents.length === 0 ||
+                            intents.length > 2 ||
+                            new Set(intents).size !== intents.length ||
+                            intents.some(intent => !['create', 'update'].includes(intent)) ||
+                            Object.keys(managedFile).some(key => !['resourceCode', 'fieldCodes', 'intents'].includes(key));
+                    resources.add(resourceCode);
+                }
+            }
+            if (access.notification !== undefined) {
+                const notification = object(access.notification);
+                invalid ||=
+                    notification.mode !== 'business-standard' ||
+                        Object.keys(notification).some(key => key !== 'mode');
+            }
+            if (access.workflow !== undefined) {
+                const workflow = object(access.workflow);
+                const workflowCodes = Array.isArray(workflow.codes)
+                    ? workflow.codes.map(string)
+                    : [];
+                invalid ||=
+                    workflowCodes.length === 0 ||
+                        workflowCodes.length > 16 ||
+                        new Set(workflowCodes).size !== workflowCodes.length ||
+                        workflowCodes.some(code => !declaredWorkflowCodes.has(code)) ||
+                        Object.keys(workflow).some(key => key !== 'codes');
+            }
+            if (invalid) {
+                diagnostics.push(diagnostic('APP_CONFIG_BACKEND_OPERATION_PLATFORM_ACCESS_INVALID', 'operation.platformAccess 必须只声明有界的发起人目录、托管文件、标准通知或现有工作流依赖', `${path}.platformAccess`));
+            }
+        }
         if (operation.ai !== undefined) {
             const ai = object(operation.ai);
             const aiResources = Array.isArray(ai.resources) ? ai.resources : [];
@@ -2824,6 +2936,9 @@ export function materializeDataResource(appCode, declaration) {
             ...(field.scale !== undefined ? { scale: field.scale } : {}),
             ...(field.min !== undefined ? { min: field.min } : {}),
             ...(field.max !== undefined ? { max: field.max } : {}),
+            ...(field.rangeBoundary
+                ? { rangeBoundary: field.rangeBoundary }
+                : {}),
             ...(field.timePrecision ? { timePrecision: field.timePrecision } : {}),
             ...(field.file ? { file: field.file } : {}),
             ...(field.serial ? { serial: field.serial } : {}),
@@ -2876,6 +2991,9 @@ export function materializeDataResource(appCode, declaration) {
                 ...(field.scale !== undefined ? { scale: field.scale } : {}),
                 ...(field.min !== undefined ? { min: field.min } : {}),
                 ...(field.max !== undefined ? { max: field.max } : {}),
+                ...(field.rangeBoundary
+                    ? { rangeBoundary: field.rangeBoundary }
+                    : {}),
                 ...(field.file?.maxCount !== undefined
                     ? { maxCount: field.file.maxCount }
                     : {}),
@@ -2972,6 +3090,7 @@ export function validateAppDeclaration(value) {
         'scale',
         'min',
         'max',
+        'rangeBoundary',
         'timePrecision',
         'file',
         'serial',
@@ -3049,6 +3168,15 @@ export function validateAppDeclaration(value) {
                 if (field.sortable === true && !supportsSort(semanticType)) {
                     diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_SORT_UNSUPPORTED', `${semanticType} 不支持稳定排序`, `${fieldPath}.sortable`));
                 }
+                const rangeType = semanticType === 'date-range' || semanticType === 'datetime-range';
+                if (rangeType &&
+                    !['closed', 'half-open'].includes(string(field.rangeBoundary))) {
+                    materializable = false;
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_RANGE_BOUNDARY_REQUIRED', `${semanticType} 必须显式声明 rangeBoundary: closed 或 half-open`, `${fieldPath}.rangeBoundary`));
+                }
+                else if (!rangeType && field.rangeBoundary !== undefined) {
+                    diagnostics.push(diagnostic('APP_CONFIG_DATA_FIELD_RANGE_BOUNDARY_TYPE_INVALID', 'rangeBoundary 只能用于 date-range 或 datetime-range', `${fieldPath}.rangeBoundary`));
+                }
                 if (field.indexed === false &&
                     (field.filter === true ||
                         field.searchable === true ||