openxiangda-devkit-core 2.69.1 → 2.71.0

package/dist/compiler/config.js

@@ -2911,6 +2911,8 @@ function validateBackendOperations(rawOperations, declaredResources, declaredRes
             const allowedAccessKeys = new Set([
                 'directory',
                 'selectedDepartments',
+                'directoryClasses',
+                'transactionTime',
                 'managedFiles',
                 'managedFileCopies',
                 'notification',
@@ -2993,6 +2995,21 @@ function validateBackendOperations(rawOperations, declaredResources, declaredRes
                         fields.some(field => !allowedFields.has(string(field))) ||
                         Object.keys(directory).some(key => !['mode', 'fields'].includes(key));
             }
+            if (access.directoryClasses !== undefined) {
+                const classes = object(access.directoryClasses);
+                invalid ||= !isRecord(access.directoryClasses) ||
+                    !Number.isSafeInteger(classes.maxIds) ||
+                    Number(classes.maxIds) < 1 || Number(classes.maxIds) > 20 ||
+                    Object.keys(classes).some(key => key !== 'maxIds');
+            }
+            if (access.transactionTime !== undefined) {
+                const time = object(access.transactionTime);
+                invalid ||= !isRecord(access.transactionTime) ||
+                    time.mode !== 'database-accepted' ||
+                    object(access.dataCommands).mode !== 'recoverable-native' ||
+                    (time.recordSetAssertions !== undefined && time.recordSetAssertions !== true) ||
+                    Object.keys(time).some(key => !['mode', 'recordSetAssertions'].includes(key));
+            }
             if (access.selectedDepartments !== undefined) {
                 const departments = object(access.selectedDepartments);
                 const fields = Array.isArray(departments.fields) ? departments.fields : [];
@@ -3710,6 +3727,7 @@ const ANONYMOUS_PUBLIC_OPERATIONS = new Set([
     'own.read',
     'public.list',
     'public.read',
+    'public.query',
 ]);
 function validateAnonymousPublicAccess(config, diagnostics) {
     const frontend = object(config.frontend);
@@ -3859,6 +3877,90 @@ function validateAnonymousPublicAccess(config, diagnostics) {
                 childFields.some(field => !childResource.fields.has(field)) ||
                 childFields.some(field => ['signature', 'subtable'].includes(childResource.fields.get(field) || '')));
         });
+        const publicQueries = Array.isArray(policy.publicQueries)
+            ? policy.publicQueries
+            : [];
+        const publicQueryInvalid = publicQueries.length > 16 ||
+            new Set(publicQueries.map(item => string(object(item).code))).size !== publicQueries.length ||
+            publicQueries.some(rawQuery => {
+                const query = object(rawQuery);
+                const queryFields = Array.isArray(query.fields)
+                    ? query.fields.map(string)
+                    : [];
+                const sort = Array.isArray(query.sort) ? query.sort : [];
+                const parameters = Array.isArray(query.parameters) ? query.parameters : [];
+                const sortFields = sort.map(item => string(object(item).field));
+                const parameterNames = parameters.map(item => string(object(item).name));
+                const aggregate = query.aggregate === undefined ? undefined : object(query.aggregate);
+                const dimensions = aggregate && Array.isArray(aggregate.dimensions) ? aggregate.dimensions : [];
+                const measures = aggregate && Array.isArray(aggregate.measures) ? aggregate.measures : [];
+                const aggregateOrder = aggregate && Array.isArray(aggregate.order) ? aggregate.order : [];
+                const aggregateAliases = [
+                    ...dimensions.map(item => string(object(item).as)),
+                    ...measures.map(item => string(object(item).as)),
+                ];
+                const aggregateInvalid = query.aggregate !== undefined && (string(query.kind) !== 'aggregate' ||
+                    Object.keys(aggregate || {}).some(key => !['dimensions', 'measures', 'order'].includes(key)) ||
+                    !Array.isArray(aggregate?.measures) ||
+                    dimensions.length > 3 ||
+                    measures.length < 1 || measures.length > 8 ||
+                    new Set(aggregateAliases).size !== aggregateAliases.length ||
+                    aggregateAliases.some(alias => !/^[A-Za-z][A-Za-z0-9_]{0,62}$/.test(alias)) ||
+                    dimensions.some(item => {
+                        const value = object(item);
+                        return Object.keys(value).some(key => !['field', 'as', 'bucket'].includes(key)) ||
+                            !queryFields.includes(string(value.field)) ||
+                            !['day', 'week', 'month', 'quarter', 'year'].includes(string(value.bucket)) && value.bucket !== undefined;
+                    }) ||
+                    measures.some(item => {
+                        const value = object(item);
+                        const type = string(value.type);
+                        return Object.keys(value).some(key => !['type', 'field', 'as'].includes(key)) ||
+                            !['count', 'countDistinct', 'sum', 'avg', 'min', 'max'].includes(type) ||
+                            (type === 'count' ? value.field !== undefined : !queryFields.includes(string(value.field)));
+                    }) ||
+                    aggregateOrder.length > 10 ||
+                    new Set(aggregateOrder.map(item => string(object(item).field))).size !== aggregateOrder.length ||
+                    aggregateOrder.some(item => {
+                        const value = object(item);
+                        return Object.keys(value).some(key => !['field', 'direction', 'nulls'].includes(key)) ||
+                            !aggregateAliases.includes(string(value.field)) ||
+                            value.direction !== undefined && !['asc', 'desc'].includes(string(value.direction)) ||
+                            value.nulls !== undefined && !['first', 'last'].includes(string(value.nulls));
+                    }));
+                return (Object.keys(query).some(key => !['code', 'kind', 'resourceCode', 'fields', 'defaultLimit', 'maxLimit', 'sort', 'parameters', 'aggregate'].includes(key)) ||
+                    !OPERATION_CODE_PATTERN.test(string(query.code)) ||
+                    !['records', 'aggregate'].includes(string(query.kind)) ||
+                    string(query.resourceCode) !== resourceCode ||
+                    queryFields.length < 1 ||
+                    queryFields.length > 64 ||
+                    new Set(queryFields).size !== queryFields.length ||
+                    queryFields.some(field => !fields.includes(field) || !Array.isArray(policy.publicRecordFields) || !policy.publicRecordFields.map(string).includes(field)) ||
+                    !Number.isSafeInteger(query.defaultLimit) ||
+                    !Number.isSafeInteger(query.maxLimit) ||
+                    Number(query.defaultLimit) < 1 ||
+                    Number(query.maxLimit) < Number(query.defaultLimit) ||
+                    Number(query.maxLimit) > 100 ||
+                    sort.length > 4 ||
+                    new Set(sortFields).size !== sortFields.length ||
+                    sort.some(item => {
+                        const value = object(item);
+                        return Object.keys(value).some(key => !['field', 'direction'].includes(key)) ||
+                            !queryFields.includes(string(value.field)) ||
+                            !['asc', 'desc'].includes(string(value.direction));
+                    }) ||
+                    parameters.length > 8 ||
+                    new Set(parameterNames).size !== parameterNames.length ||
+                    parameters.some(item => {
+                        const value = object(item);
+                        return Object.keys(value).some(key => !['name', 'field', 'operator', 'type'].includes(key)) ||
+                            !OPERATION_CODE_PATTERN.test(string(value.name)) ||
+                            !queryFields.includes(string(value.field)) ||
+                            !['eq', 'contains', 'in'].includes(string(value.operator)) ||
+                            !['string', 'number', 'boolean', 'string[]'].includes(string(value.type));
+                    }) ||
+                    aggregateInvalid);
+            });
         const draft = object(policy.draft);
         const validations = Array.isArray(policy.validations)
             ? policy.validations
@@ -3877,6 +3979,7 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             'serverGeneratedFields',
             'schedule',
             'publicSubtableFields',
+            'publicQueries',
             'draft',
             'validations',
         ];
@@ -3979,6 +4082,13 @@ function validateAnonymousPublicAccess(config, diagnostics) {
                 pointer: `${path}.publicSubtableFields`,
             });
         }
+        if (publicQueryInvalid) {
+            anonymousPolicyProblems.push({
+                code: 'APP_CONFIG_ANONYMOUS_PUBLIC_POLICY_QUERIES_INVALID',
+                message: 'publicQueries 必须是同一资源的有界公开字段查询，limit 不超过 100，参数和排序只能引用查询字段',
+                pointer: path + '.publicQueries',
+            });
+        }
         if (publicFilterInvalid) {
             anonymousPolicyProblems.push({
                 code: 'APP_CONFIG_ANONYMOUS_PUBLIC_POLICY_FILTERS_INVALID',