openxiangda-contracts 2.11.0 → 2.12.0

package/dist/native-compiler/compiler.js

@@ -1632,6 +1632,8 @@ const ANONYMOUS_PUBLIC_OPERATIONS = new Set([
     'create',
     'own.list',
     'own.read',
+    'public.list',
+    'public.read',
 ]);
 function validateAnonymousPublicAccess(value, config, pointer) {
     const access = object(value, pointer);
@@ -1645,19 +1647,26 @@ function validateAnonymousPublicAccess(value, config, pointer) {
         resource,
     ]));
     const policyCodes = new Set();
-    const routeCodes = new Set();
+    const declaredPolicyCodes = new Set(policies.map((rawPolicy) => String(rawPolicy?.code || '')));
     policies.forEach((rawPolicy, index) => {
         const policyPointer = `${pointer}/policies/${index}`;
         const policy = object(rawPolicy, policyPointer);
-        exactKeys(policy, ['code', 'routeCode', 'mode', 'resourceCode', 'operations', 'fields'], policyPointer, ['requiredFields', 'ownRecordFields', 'draft', 'validations']);
+        exactKeys(policy, ['code', 'routeCode', 'mode', 'resourceCode', 'operations', 'fields'], policyPointer, [
+            'requiredFields',
+            'ownRecordFields',
+            'publicRecordFields',
+            'publicFilters',
+            'serverGeneratedFields',
+            'schedule',
+            'publicSubtableFields',
+            'draft',
+            'validations',
+        ]);
         const code = stableCode(policy.code, `${policyPointer}/code`);
         if (policyCodes.has(code)) {
             fail('NATIVE_PUBLIC_POLICY_DUPLICATE', `${policyPointer}/code`);
         }
         const routeCode = stableCode(policy.routeCode, `${policyPointer}/routeCode`);
-        if (routeCodes.has(routeCode)) {
-            fail('NATIVE_PUBLIC_ROUTE_DUPLICATE', `${policyPointer}/routeCode`);
-        }
         const route = routes.get(routeCode);
         if (!route ||
             route.surface !== 'user' ||
@@ -1676,7 +1685,7 @@ function validateAnonymousPublicAccess(value, config, pointer) {
             String(field.code),
             String(field.type),
         ]));
-        const operations = uniqueStrings(policy.operations, `${policyPointer}/operations`, 6);
+        const operations = uniqueStrings(policy.operations, `${policyPointer}/operations`, 8);
         if (operations.length < 1 ||
             operations.some(operation => !ANONYMOUS_PUBLIC_OPERATIONS.has(operation))) {
             fail('NATIVE_PUBLIC_OPERATION_INVALID', `${policyPointer}/operations`);
@@ -1688,7 +1697,11 @@ function validateAnonymousPublicAccess(value, config, pointer) {
         if (fields.length < 1 || fields.some(field => !declaredFields.has(field))) {
             fail('NATIVE_PUBLIC_FIELD_INVALID', `${policyPointer}/fields`);
         }
-        for (const optionalFieldSet of ['requiredFields', 'ownRecordFields']) {
+        for (const optionalFieldSet of [
+            'requiredFields',
+            'ownRecordFields',
+            'publicRecordFields',
+        ]) {
             if (!Object.prototype.hasOwnProperty.call(policy, optionalFieldSet))
                 continue;
             const selected = uniqueStrings(policy[optionalFieldSet], `${policyPointer}/${optionalFieldSet}`, 64);
@@ -1696,6 +1709,137 @@ function validateAnonymousPublicAccess(value, config, pointer) {
                 fail('NATIVE_PUBLIC_FIELD_SCOPE_INVALID', `${policyPointer}/${optionalFieldSet}`);
             }
         }
+        const serverGeneratedFields = Object.prototype.hasOwnProperty.call(policy, 'serverGeneratedFields')
+            ? boundedArray(policy.serverGeneratedFields, `${policyPointer}/serverGeneratedFields`, 16)
+            : [];
+        const generatedFieldCodes = new Set();
+        serverGeneratedFields.forEach((rawGenerated, generatedIndex) => {
+            const generatedPointer = `${policyPointer}/serverGeneratedFields/${generatedIndex}`;
+            const generated = object(rawGenerated, generatedPointer);
+            exactKeys(generated, ['field', 'kind'], generatedPointer);
+            const field = fieldCodeValue(generated.field, `${generatedPointer}/field`);
+            if (generatedFieldCodes.has(field) ||
+                !declaredFields.has(field) ||
+                fields.includes(field) ||
+                (declaredFields.get(field) !== 'text.short' &&
+                    declaredFields.get(field) !== 'text.long')) {
+                fail('NATIVE_PUBLIC_SERVER_GENERATED_FIELD_INVALID', `${generatedPointer}/field`);
+            }
+            equal(generated.kind, 'random-token', `${generatedPointer}/kind`);
+            generatedFieldCodes.add(field);
+        });
+        const schedule = Object.prototype.hasOwnProperty.call(policy, 'schedule')
+            ? object(policy.schedule, `${policyPointer}/schedule`)
+            : null;
+        if (schedule) {
+            const scheduleKeys = [
+                'campusPolicyCode',
+                'rulePolicyCode',
+                'campusField',
+                'ruleCampusField',
+                'ruleWeekdaysField',
+                'ruleOpenAtField',
+                'ruleCloseAtField',
+                'ruleSlotMinutesField',
+                'ruleAdvanceHoursField',
+                'ruleAdvanceDaysField',
+                'campusEnabledField',
+                'ruleEnabledField',
+                'dateField',
+                'timeField',
+            ];
+            exactKeys(schedule, scheduleKeys, `${policyPointer}/schedule`);
+            for (const key of ['campusPolicyCode', 'rulePolicyCode']) {
+                stableCode(schedule[key], `${policyPointer}/schedule/${key}`);
+            }
+            for (const key of scheduleKeys.filter(key => !['campusPolicyCode', 'rulePolicyCode'].includes(key))) {
+                fieldCodeValue(schedule[key], `${policyPointer}/schedule/${key}`);
+            }
+            for (const field of [schedule.campusField, schedule.dateField, schedule.timeField]) {
+                if (!fields.includes(String(field))) {
+                    fail('NATIVE_PUBLIC_SCHEDULE_FIELD_INVALID', `${policyPointer}/schedule`);
+                }
+            }
+            if (!declaredPolicyCodes.has(String(schedule.campusPolicyCode)) ||
+                !declaredPolicyCodes.has(String(schedule.rulePolicyCode))) {
+                fail('NATIVE_PUBLIC_SCHEDULE_POLICY_INVALID', `${policyPointer}/schedule`);
+            }
+        }
+        const publicFilters = Object.prototype.hasOwnProperty.call(policy, 'publicFilters')
+            ? boundedArray(policy.publicFilters, `${policyPointer}/publicFilters`, 16)
+            : [];
+        const filterFields = new Set();
+        publicFilters.forEach((rawFilter, filterIndex) => {
+            const filterPointer = `${policyPointer}/publicFilters/${filterIndex}`;
+            const filter = object(rawFilter, filterPointer);
+            exactKeys(filter, ['field', 'operator', 'value'], filterPointer);
+            const field = fieldCodeValue(filter.field, `${filterPointer}/field`);
+            if (filterFields.has(field)) {
+                fail('NATIVE_PUBLIC_FILTER_DUPLICATE', `${filterPointer}/field`);
+            }
+            if (!fields.includes(field)) {
+                fail('NATIVE_PUBLIC_FILTER_FIELD_INVALID', `${filterPointer}/field`);
+            }
+            equal(filter.operator, 'eq', `${filterPointer}/operator`);
+            if (![
+                'boolean',
+                'text.short',
+                'text.long',
+                'number.integer',
+                'number.decimal',
+                'date',
+                'time',
+            ].includes(declaredFields.get(field) || '')) {
+                fail('NATIVE_PUBLIC_FILTER_FIELD_INVALID', `${filterPointer}/field`);
+            }
+            if (filter.value !== null &&
+                typeof filter.value !== 'string' &&
+                typeof filter.value !== 'number' &&
+                typeof filter.value !== 'boolean') {
+                fail('NATIVE_PUBLIC_FILTER_VALUE_INVALID', `${filterPointer}/value`);
+            }
+            filterFields.add(field);
+        });
+        const publicSubtableFields = Object.prototype.hasOwnProperty.call(policy, 'publicSubtableFields')
+            ? object(policy.publicSubtableFields, `${policyPointer}/publicSubtableFields`)
+            : null;
+        if (publicSubtableFields) {
+            if (Object.keys(publicSubtableFields).length > 64) {
+                fail('NATIVE_PUBLIC_SUBTABLE_FIELDS_INVALID', `${policyPointer}/publicSubtableFields`);
+            }
+            for (const [parentFieldCode, rawChildFields] of Object.entries(publicSubtableFields)) {
+                const parentField = resource.schema.fields.find((field) => String(field.code) === parentFieldCode);
+                const childResourceCode = String(parentField?.subtable?.resourceCode || '');
+                const childResource = resources.get(childResourceCode);
+                const childFieldTypes = new Map((childResource?.schema?.fields || []).map((field) => [
+                    String(field.code),
+                    String(field.type),
+                ]));
+                const selected = uniqueStrings(rawChildFields, `${policyPointer}/publicSubtableFields/${parentFieldCode}`, 64);
+                if (!fields.includes(parentFieldCode) ||
+                    declaredFields.get(parentFieldCode) !== 'subtable' ||
+                    !childResource ||
+                    selected.length < 1 ||
+                    selected.some(field => !childFieldTypes.has(field)) ||
+                    selected.some(field => childFieldTypes.get(field) === 'subtable') ||
+                    selected.some(field => childFieldTypes.get(field) === 'signature')) {
+                    fail('NATIVE_PUBLIC_SUBTABLE_FIELDS_INVALID', `${policyPointer}/publicSubtableFields/${parentFieldCode}`);
+                }
+            }
+        }
+        if (operations.some(operation => operation.startsWith('public.'))) {
+            if (!Object.prototype.hasOwnProperty.call(policy, 'publicRecordFields')) {
+                fail('NATIVE_PUBLIC_RECORD_FIELDS_REQUIRED', `${policyPointer}/publicRecordFields`);
+            }
+            const publicRecordFields = uniqueStrings(policy.publicRecordFields, `${policyPointer}/publicRecordFields`, 64);
+            if (publicRecordFields.length < 1 ||
+                publicRecordFields.some(field => !fields.includes(field)) ||
+                publicRecordFields.some(field => declaredFields.get(field) === 'signature' ||
+                    (declaredFields.get(field) === 'subtable' &&
+                        !publicSubtableFields?.[field]))) {
+                fail('NATIVE_PUBLIC_RECORD_FIELDS_INVALID', `${policyPointer}/publicRecordFields`);
+            }
+        }
         const requiredFields = Object.prototype.hasOwnProperty.call(policy, 'requiredFields')
             ? uniqueStrings(policy.requiredFields, `${policyPointer}/requiredFields`, 64)
             : [];
@@ -1709,6 +1853,10 @@ function validateAnonymousPublicAccess(value, config, pointer) {
         if (operations.includes('create') && !nativeCreate) {
             fail('NATIVE_PUBLIC_CREATE_FIELDS_INCOMPLETE', `${policyPointer}/fields`);
         }
+        if (operations.includes('create') &&
+            !Object.prototype.hasOwnProperty.call(policy, 'draft')) {
+            fail('NATIVE_PUBLIC_DRAFT_REQUIRED', `${policyPointer}/draft`);
+        }
         if (operations.includes('create')) {
             for (const fieldCode of requiredCreateFields) {
                 const missingSet = !fields.includes(fieldCode)
@@ -1752,7 +1900,6 @@ function validateAnonymousPublicAccess(value, config, pointer) {
             validationCodes.add(validationCode);
         });
         policyCodes.add(code);
-        routeCodes.add(routeCode);
     });
 }
 function validateAnonymousPublicAccessContract(value, pointer) {
@@ -1777,6 +1924,62 @@ function compileAnonymousPublicAccess(config) {
             ...(policy.ownRecordFields
                 ? { ownRecordFields: uniqueSorted(policy.ownRecordFields) }
                 : {}),
+            ...(policy.publicRecordFields
+                ? { publicRecordFields: uniqueSorted(policy.publicRecordFields) }
+                : {}),
+            ...(policy.publicFilters
+                ? {
+                    publicFilters: policy.publicFilters
+                        .map((filter) => ({
+                        field: filter.field,
+                        operator: filter.operator,
+                        value: filter.value,
+                    }))
+                        .sort((left, right) => compareText(left.field, right.field)),
+                }
+                : {}),
+            ...(policy.publicSubtableFields
+                ? {
+                    publicSubtableFields: Object.fromEntries(Object.entries(policy.publicSubtableFields)
+                        .sort(([left], [right]) => left.localeCompare(right))
+                        .map(([field, childFields]) => [
+                        field,
+                        uniqueSorted(Array.isArray(childFields)
+                            ? childFields.map(String)
+                            : []),
+                    ])),
+                }
+                : {}),
+            ...(policy.serverGeneratedFields
+                ? {
+                    serverGeneratedFields: policy.serverGeneratedFields
+                        .map((generated) => ({
+                        field: generated.field,
+                        kind: generated.kind,
+                    }))
+                        .sort((left, right) => compareText(left.field, right.field)),
+                }
+                : {}),
+            ...(policy.schedule
+                ? {
+                    schedule: {
+                        campusPolicyCode: policy.schedule.campusPolicyCode,
+                        rulePolicyCode: policy.schedule.rulePolicyCode,
+                        campusField: policy.schedule.campusField,
+                        ruleCampusField: policy.schedule.ruleCampusField,
+                        ruleWeekdaysField: policy.schedule.ruleWeekdaysField,
+                        ruleOpenAtField: policy.schedule.ruleOpenAtField,
+                        ruleCloseAtField: policy.schedule.ruleCloseAtField,
+                        ruleSlotMinutesField: policy.schedule.ruleSlotMinutesField,
+                        ruleAdvanceHoursField: policy.schedule.ruleAdvanceHoursField,
+                        ruleAdvanceDaysField: policy.schedule.ruleAdvanceDaysField,
+                        campusEnabledField: policy.schedule.campusEnabledField,
+                        ruleEnabledField: policy.schedule.ruleEnabledField,
+                        dateField: policy.schedule.dateField,
+                        timeField: policy.schedule.timeField,
+                    },
+                }
+                : {}),
             ...(policy.draft ? { draft: { ...policy.draft } } : {}),
             ...(policy.validations
                 ? {