openxiangda-devkit-core 2.0.0-alpha.73 → 2.0.0-alpha.76

package/dist/compiler/config.js

@@ -38,6 +38,9 @@ export function adminResourcePage(resourceCode, options) {
 export function adminOperationPage(routeCode, options) {
     return adminNavigationItem({ kind: 'operation', routeCode }, options);
 }
+export function adminApplicationTodoCenterPage(options) {
+    return adminNavigationItem({ kind: 'application-todo-center' }, options);
+}
 export function adminWorkflowWorkCenterPage(options) {
     return adminNavigationItem({ kind: 'workflow-work-center' }, options);
 }
@@ -121,6 +124,10 @@ export function renderAdminNavigationSuggestion(config) {
                     imports.add('adminOperationPage');
                     expression = `adminOperationPage(${JSON.stringify(item.page.routeCode)}${options ? `, ${options}` : ''})`;
                     break;
+                case 'application-todo-center':
+                    imports.add('adminApplicationTodoCenterPage');
+                    expression = `adminApplicationTodoCenterPage(${options || ''})`;
+                    break;
                 case 'workflow-work-center':
                     imports.add('adminWorkflowWorkCenterPage');
                     expression = `adminWorkflowWorkCenterPage(${options || ''})`;
@@ -761,7 +768,7 @@ export function validateAppConfig(value) {
         !['light', 'standard'].includes(String(backend.resourceProfile))) {
         diagnostics.push(diagnostic('APP_CONFIG_BACKEND_RESOURCE_PROFILE_UNSUPPORTED', 'backend.resourceProfile 必须是 light 或 standard', 'backend.resourceProfile'));
     }
-    validateFrontendRoutes(frontend.routes, diagnostics);
+    validateFrontendRoutes(config, diagnostics);
     validateAdminNavigation(config, diagnostics);
     validatePerspectives(config.perspectives, object(config.authz).roles, diagnostics);
     const declaredResourceCodes = new Set((Array.isArray(object(config.data).resources)
@@ -1740,6 +1747,10 @@ export function validateAppConfig(value) {
         const editableParameters = Array.isArray(workflows.editableParameters)
             ? workflows.editableParameters
             : [];
+        const frontendRoutesByCode = new Map((Array.isArray(frontend.routes) ? frontend.routes : []).map(routeValue => {
+            const route = object(routeValue);
+            return [string(route.code), route];
+        }));
         const definitionByKey = new Map();
         const bindingByKey = new Map();
         const providerKeys = new Set();
@@ -1791,6 +1802,9 @@ export function validateAppConfig(value) {
             const version = Number(declaration.version);
             const path = `workflows.definitions[${index}]`;
             const launch = object(declaration.launch);
+            if (Object.keys(declaration).some(key => !['version', 'definition', 'launch', 'detailRouteCode'].includes(key))) {
+                diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DEFINITION_DECLARATION_INVALID', 'Workflow definition declaration 只能声明 version、definition、launch 和 detailRouteCode', path));
+            }
             if (declaration.launch !== undefined &&
                 (Object.keys(launch).some(key => key !== 'mode') ||
                     ![
@@ -1801,6 +1815,41 @@ export function validateAppConfig(value) {
                     ].includes(string(launch.mode)))) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_LAUNCH_MODE_INVALID', 'Workflow launch.mode 必须是 standalone、custom-page、hidden-handoff 或 work-center-only', `${path}.launch.mode`));
             }
+            if (declaration.detailRouteCode !== undefined) {
+                const detailRouteCode = object(declaration.detailRouteCode);
+                const desktopCode = string(detailRouteCode.desktop);
+                const mobileCode = string(detailRouteCode.mobile);
+                if (Object.keys(detailRouteCode).some(key => !['desktop', 'mobile'].includes(key)) ||
+                    !OPERATION_CODE_PATTERN.test(desktopCode) ||
+                    !OPERATION_CODE_PATTERN.test(mobileCode) ||
+                    desktopCode === mobileCode) {
+                    diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DETAIL_ROUTE_INVALID', 'detailRouteCode 必须声明两个不同且合法的 desktop/mobile route code', `${path}.detailRouteCode`));
+                }
+                else {
+                    for (const [device, code, surface] of [
+                        ['desktop', desktopCode, 'admin'],
+                        ['mobile', mobileCode, 'user'],
+                    ]) {
+                        const route = frontendRoutesByCode.get(code);
+                        const routePointer = `${path}.detailRouteCode.${device}`;
+                        if (!route) {
+                            diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DETAIL_ROUTE_REFERENCE_MISSING', `detailRouteCode.${device} 必须引用已声明 frontend route`, routePointer));
+                            continue;
+                        }
+                        if (string(route.surface) !== surface) {
+                            diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DETAIL_ROUTE_SURFACE_INVALID', `detailRouteCode.${device} 必须引用 ${surface} surface`, routePointer));
+                        }
+                        const parameters = [
+                            ...string(route.path).matchAll(/:([A-Za-z][A-Za-z0-9_]*)/g),
+                        ].map(match => match[1]);
+                        if (string(route.path).includes('*') ||
+                            parameters.length !== 1 ||
+                            parameters[0] !== 'instanceId') {
+                            diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_DETAIL_ROUTE_PATH_INVALID', `detailRouteCode.${device} 路由必须且只能声明 :instanceId 动态参数`, routePointer));
+                        }
+                    }
+                }
+            }
             if (!Number.isInteger(version) || version < 1) {
                 diagnostics.push(diagnostic('APP_CONFIG_WORKFLOW_VERSION_INVALID', 'Workflow definition version 必须是正整数', `${path}.version`));
             }
@@ -2048,14 +2097,108 @@ function validateBackendOperations(rawOperations, declaredResourceCodes, diagnos
         routes.add(routeKey);
     });
 }
-function validateFrontendRoutes(rawRoutes, diagnostics) {
+function canonicalFrontendRouteShape(path) {
+    const normalized = path.replace(/\/{2,}/g, '/').replace(/\/$/, '') || '/';
+    return normalized
+        .split('/')
+        .map(segment => segment.startsWith(':') ? ':' : segment.includes('*') ? '*' : segment)
+        .join('/');
+}
+function generatedPlatformRouteClaims(config) {
+    const claims = [
+        { owner: 'platform:admin-entry', path: '/' },
+        { owner: 'platform:admin-entry', path: '/admin' },
+        {
+            owner: 'platform:file-preview',
+            path: '/files/:resourceCode/:fileId/preview',
+        },
+    ];
+    const data = object(config.data);
+    const resources = Array.isArray(data.resources) ? data.resources : [];
+    for (const rawResource of resources) {
+        const resource = object(rawResource);
+        const code = string(resource.code);
+        if (!code)
+            continue;
+        const surface = object(resource.surface);
+        const generated = object(surface.generated);
+        const native = !surface.mutationOwner || surface.mutationOwner === 'native';
+        const operations = {
+            list: generated.list === undefined ? true : generated.list === true,
+            detail: generated.detail === undefined ? true : generated.detail === true,
+            create: generated.create === undefined ? native : generated.create === true,
+            update: generated.update === undefined ? native : generated.update === true,
+        };
+        const base = `/admin/resources/${code}`;
+        const candidates = [
+            ['list', base],
+            ['detail', `${base}/:id`],
+            ['create', `${base}/new`],
+            ['update', `${base}/:id/edit`],
+        ];
+        for (const [operation, path] of candidates) {
+            if (!operations[operation])
+                continue;
+            claims.push({ owner: `resource:${code}:${operation}`, path }, { owner: `resource:${code}:${operation}:mobile`, path: `/m${path}` });
+        }
+    }
+    const frontend = object(config.frontend);
+    const admin = object(frontend.admin);
+    const navigation = Array.isArray(admin.navigation) ? admin.navigation : [];
+    const hasTodoCenter = navigation.some(rawGroup => {
+        const group = object(rawGroup);
+        const items = Array.isArray(group.items) ? group.items : [];
+        return items.some(rawItem => string(object(object(rawItem).page).kind) === 'application-todo-center');
+    });
+    if (hasTodoCenter) {
+        claims.push({ owner: 'application:todo-center', path: '/admin/todos' }, { owner: 'application:todo-center:mobile', path: '/m/todos' });
+    }
+    const workflows = object(config.workflows);
+    const definitions = Array.isArray(workflows.definitions)
+        ? workflows.definitions
+        : [];
+    if (definitions.length > 0) {
+        claims.push({ owner: 'workflow:work-center', path: '/admin/work-center' }, { owner: 'workflow:work-center:mobile', path: '/m/work-center' }, { owner: 'workflow:task', path: '/admin/tasks/:taskId' }, { owner: 'workflow:task:mobile', path: '/m/tasks/:taskId' }, { owner: 'workflow:instance', path: '/admin/workflows/:instanceId' }, {
+            owner: 'workflow:instance:mobile',
+            path: '/m/workflows/:instanceId',
+        });
+        const standaloneCodes = new Set();
+        for (const rawDefinition of definitions) {
+            const declaration = object(rawDefinition);
+            if (string(object(declaration.launch).mode) !== 'standalone')
+                continue;
+            const workflowCode = string(object(declaration.definition).code);
+            if (workflowCode)
+                standaloneCodes.add(workflowCode);
+        }
+        for (const workflowCode of standaloneCodes) {
+            claims.push({
+                owner: `workflow:${workflowCode}:launch`,
+                path: `/admin/workflows/${workflowCode}/new`,
+            });
+        }
+        if (standaloneCodes.size > 0) {
+            claims.push({
+                owner: 'workflow:launch:mobile',
+                path: '/m/workflows/:workflowCode/start',
+            });
+        }
+    }
+    return claims;
+}
+function validateFrontendRoutes(config, diagnostics) {
+    const frontend = object(config.frontend);
+    const rawRoutes = frontend.routes;
     if (rawRoutes !== undefined && !Array.isArray(rawRoutes)) {
         diagnostics.push(diagnostic('APP_CONFIG_FRONTEND_ROUTES_INVALID', 'frontend.routes 必须是数组', 'frontend.routes'));
         return;
     }
     const routes = Array.isArray(rawRoutes) ? rawRoutes : [];
     const codes = new Set();
-    const paths = new Set();
+    const pathClaims = new Map();
+    for (const claim of generatedPlatformRouteClaims(config)) {
+        pathClaims.set(canonicalFrontendRouteShape(claim.path), claim);
+    }
     routes.forEach((raw, index) => {
         const route = object(raw);
         const code = string(route.code);
@@ -2103,17 +2246,31 @@ function validateFrontendRoutes(rawRoutes, diagnostics) {
         if (!OPERATION_CODE_PATTERN.test(code) ||
             codes.has(code) ||
             !validAppPath(routePath) ||
-            paths.has(routePath) ||
             !string(route.label) ||
             !['admin', 'user'].includes(string(route.surface)) ||
+            (route.surface === 'admin' &&
+                routePath !== '/admin' &&
+                !routePath.startsWith('/admin/')) ||
+            (route.surface === 'user' &&
+                (routePath === '/admin' || routePath.startsWith('/admin/'))) ||
             (route.capability !== undefined &&
                 !CAPABILITY_PATTERN.test(string(route.capability))) ||
             accessInvalid ||
             routePolicyInvalid) {
             diagnostics.push(diagnostic('APP_CONFIG_FRONTEND_ROUTE_INVALID', '前端 route 必须声明唯一 code/path、label、surface、有效访问表达式和有界标签策略；动态 route 不能固定、恢复或保活', path));
         }
+        const shape = canonicalFrontendRouteShape(routePath);
+        const existing = pathClaims.get(shape);
+        if (routePath && existing) {
+            diagnostics.push(diagnostic('APP_CONFIG_FRONTEND_ROUTE_PATH_CONFLICT', `前端 route path 与 ${existing.owner} 冲突: ${routePath}`, `${path}.path`));
+        }
+        else if (routePath) {
+            pathClaims.set(shape, {
+                owner: `frontend:${code || index}`,
+                path: routePath,
+            });
+        }
         codes.add(code);
-        paths.add(routePath);
     });
     const parentByCode = new Map();
     routes.forEach((raw, index) => {
@@ -2239,6 +2396,12 @@ function validateAdminNavigation(config, diagnostics) {
                 internalCode = routeCode;
                 exists = Boolean(route && route.surface === 'admin' && !/[:*]/.test(route.path));
             }
+            else if (kind === 'application-todo-center') {
+                pageKey = 'application:todo-center';
+                defaultLabel = '待办中心';
+                internalCode = pageKey;
+                exists = true;
+            }
             else if (kind === 'workflow-work-center') {
                 pageKey = 'workflow:work-center';
                 defaultLabel = '我的审批';
@@ -2255,7 +2418,13 @@ function validateAdminNavigation(config, diagnostics) {
                 exists = Boolean(workflow && workflow.mode === 'standalone');
             }
             if (Object.keys(item).some(key => !['page', 'label', 'icon', 'order'].includes(key)) ||
-                !['resource', 'operation', 'workflow-work-center', 'workflow-launch'].includes(kind) ||
+                ![
+                    'resource',
+                    'operation',
+                    'application-todo-center',
+                    'workflow-work-center',
+                    'workflow-launch',
+                ].includes(kind) ||
                 (item.icon !== undefined &&
                     !ADMIN_NAVIGATION_ICONS.has(string(item.icon))) ||
                 !validAdminOrder(item.order)) {