openxiangda-devkit-core 2.9.0 → 2.10.0

package/dist/compiler/config.js

@@ -2393,6 +2393,7 @@ function validatePerspectives(rawPerspectives, rawRoles, diagnostics) {
 }
 const CAPABILITY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9:._*-]{0,254}$/;
 const OPERATION_CODE_PATTERN = /^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$/;
+const FIELD_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,62}$/;
 const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
 const RESERVED_NATIVE_KEYS = new Map([
     ['environmentKey', 'environmentKey'],
@@ -2963,6 +2964,8 @@ const ANONYMOUS_PUBLIC_OPERATIONS = new Set([
     'create',
     'own.list',
     'own.read',
+    'public.list',
+    'public.read',
 ]);
 function validateAnonymousPublicAccess(config, diagnostics) {
     const frontend = object(config.frontend);
@@ -2994,6 +2997,13 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             const declaration = object(field);
             return [string(declaration.code), string(declaration.type)];
         }));
+        const subtables = new Map(fields
+            .map(field => object(field))
+            .filter(field => string(field.type) === 'subtable')
+            .map(field => [
+            string(field.code),
+            string(object(field.subtable).resourceCode),
+        ]));
         const surface = object(resource.surface);
         const surfaceFields = object(surface.fields);
         const requiredCreateFields = new Set(fields
@@ -3010,11 +3020,11 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             generated.create !== false;
         return [
             string(resource.code),
-            { fields: fieldMap, requiredCreateFields, nativeCreate },
+            { fields: fieldMap, subtables, requiredCreateFields, nativeCreate },
         ];
     }));
     const policyCodes = new Set();
-    const routeCodes = new Set();
+    const declaredPolicyCodes = new Set(policies.map(rawPolicy => string(object(rawPolicy).code)));
     policies.forEach((raw, index) => {
         const policy = object(raw);
         const path = `frontend.publicAccess.policies[${index}]`;
@@ -3034,6 +3044,76 @@ function validateAnonymousPublicAccess(config, diagnostics) {
         const ownRecordFields = Array.isArray(policy.ownRecordFields)
             ? policy.ownRecordFields.map(string)
             : fields;
+        const publicSubtableFields = object(policy.publicSubtableFields);
+        const publicFilters = Array.isArray(policy.publicFilters)
+            ? policy.publicFilters
+            : [];
+        const serverGeneratedFields = Array.isArray(policy.serverGeneratedFields)
+            ? policy.serverGeneratedFields
+            : [];
+        const generatedFieldInvalid = serverGeneratedFields.length > 16 ||
+            new Set(serverGeneratedFields.map(item => string(object(item).field))).size !==
+                serverGeneratedFields.length ||
+            serverGeneratedFields.some(rawGenerated => {
+                const generated = object(rawGenerated);
+                const field = string(generated.field);
+                return (Object.keys(generated).some(key => !['field', 'kind'].includes(key)) ||
+                    !resourceFields?.has(field) ||
+                    fields.includes(field) ||
+                    !['text.short', 'text.long'].includes(resourceFields?.get(field) || '') ||
+                    generated.kind !== 'random-token');
+            });
+        const schedule = object(policy.schedule);
+        const schedulePolicyKeys = ['campusPolicyCode', 'rulePolicyCode'];
+        const scheduleFieldKeys = [
+            'campusField', 'ruleCampusField', 'ruleWeekdaysField', 'ruleOpenAtField',
+            'ruleCloseAtField', 'ruleSlotMinutesField', 'ruleAdvanceHoursField',
+            'ruleAdvanceDaysField', 'campusEnabledField', 'ruleEnabledField',
+            'dateField', 'timeField',
+        ];
+        const scheduleKeys = [...schedulePolicyKeys, ...scheduleFieldKeys];
+        const scheduleInvalid = policy.schedule !== undefined && (Object.keys(schedule).some(key => !scheduleKeys.includes(key)) ||
+            schedulePolicyKeys.some(key => !OPERATION_CODE_PATTERN.test(string(schedule[key]))) ||
+            scheduleFieldKeys.some(key => !FIELD_CODE_PATTERN.test(string(schedule[key]))) ||
+            !fields.includes(string(schedule.campusField)) ||
+            !fields.includes(string(schedule.dateField)) ||
+            !fields.includes(string(schedule.timeField)) ||
+            !declaredPolicyCodes.has(string(schedule.campusPolicyCode)) ||
+            !declaredPolicyCodes.has(string(schedule.rulePolicyCode)));
+        const publicFilterInvalid = publicFilters.length > 16 ||
+            new Set(publicFilters.map(item => string(object(item).field))).size !==
+                publicFilters.length ||
+            publicFilters.some(rawFilter => {
+                const filter = object(rawFilter);
+                const field = string(filter.field);
+                const type = resourceFields?.get(field);
+                const value = filter.value;
+                return (Object.keys(filter).some(key => !['field', 'operator', 'value'].includes(key)) ||
+                    !resourceFields?.has(field) ||
+                    filter.operator !== 'eq' ||
+                    !['boolean', 'text.short', 'text.long', 'number.integer', 'number.decimal', 'date', 'time'].includes(type || '') ||
+                    !(value === null ||
+                        typeof value === 'string' ||
+                        typeof value === 'number' ||
+                        typeof value === 'boolean'));
+            });
+        const publicSubtableInvalid = Object.entries(publicSubtableFields).some(([parentFieldCode, rawChildFields]) => {
+            const childResourceCode = resource?.subtables.get(parentFieldCode);
+            const childResource = childResourceCode
+                ? resourceMap.get(childResourceCode)
+                : undefined;
+            const childFields = Array.isArray(rawChildFields)
+                ? rawChildFields.map(string)
+                : [];
+            return (!fields.includes(parentFieldCode) ||
+                !childResourceCode ||
+                !childResource ||
+                childFields.length < 1 ||
+                childFields.length > 64 ||
+                new Set(childFields).size !== childFields.length ||
+                childFields.some(field => !childResource.fields.has(field)) ||
+                childFields.some(field => ['signature', 'subtable'].includes(childResource.fields.get(field) || '')));
+        });
         const draft = object(policy.draft);
         const validations = Array.isArray(policy.validations)
             ? policy.validations
@@ -3047,13 +3127,17 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             'fields',
             'requiredFields',
             'ownRecordFields',
+            'publicRecordFields',
+            'publicFilters',
+            'serverGeneratedFields',
+            'schedule',
+            'publicSubtableFields',
             'draft',
             'validations',
         ];
         const invalid = Object.keys(policy).some(key => !exactRootKeys.includes(key)) ||
             !OPERATION_CODE_PATTERN.test(code) ||
             policyCodes.has(code) ||
-            routeCodes.has(routeCode) ||
             policy.mode !== 'anonymous' ||
             !route ||
             route.surface !== 'user' ||
@@ -3072,8 +3156,23 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             new Set(requiredFields).size !== requiredFields.length ||
             requiredFields.some(field => !fields.includes(field)) ||
             (operations.includes('create') && !resource?.nativeCreate) ||
+            (operations.includes('create') && policy.draft === undefined) ||
             new Set(ownRecordFields).size !== ownRecordFields.length ||
             ownRecordFields.some(field => !fields.includes(field)) ||
+            Object.keys(publicSubtableFields).length > 64 ||
+            publicSubtableInvalid ||
+            publicFilterInvalid ||
+            generatedFieldInvalid ||
+            scheduleInvalid ||
+            (operations.some(operation => operation.startsWith('public.')) &&
+                (!Array.isArray(policy.publicRecordFields) ||
+                    policy.publicRecordFields.length < 1 ||
+                    new Set(policy.publicRecordFields.map(string)).size !==
+                        policy.publicRecordFields.length ||
+                    policy.publicRecordFields.some((field) => !fields.includes(string(field)) ||
+                        resourceFields?.get(string(field)) === 'signature' ||
+                        (resourceFields?.get(string(field)) === 'subtable' &&
+                            !Array.isArray(publicSubtableFields[string(field)]))))) ||
             (operations.includes('draft.read') !== operations.includes('draft.update')) ||
             (operations.some(operation => operation.startsWith('draft.')) &&
                 (policy.draft === undefined || draft.enabled !== true)) ||
@@ -3121,7 +3220,6 @@ function validateAnonymousPublicAccess(config, diagnostics) {
             validationCodes.add(validationCode);
         });
         policyCodes.add(code);
-        routeCodes.add(routeCode);
     });
 }
 function validateApplicationAuthentication(config, diagnostics) {