openxiangda-contracts 2.92.0 → 2.94.0

package/dist/native-compiler/compiler.js

@@ -2510,6 +2510,7 @@ const ANONYMOUS_PUBLIC_OPERATIONS = new Set([
     'own.read',
     'public.list',
     'public.read',
+    'public.query',
 ]);
 function validateAnonymousPublicAccess(value, config, pointer) {
     const access = object(value, pointer);
@@ -2535,6 +2536,7 @@ function validateAnonymousPublicAccess(value, config, pointer) {
             'serverGeneratedFields',
             'schedule',
             'publicSubtableFields',
+            'publicQueries',
             'draft',
             'validations',
         ]);
@@ -2707,19 +2709,148 @@ function validateAnonymousPublicAccess(value, config, pointer) {
                 }
             }
         }
+        const publicRecordFields = Object.prototype.hasOwnProperty.call(policy, 'publicRecordFields')
+            ? uniqueStrings(policy.publicRecordFields, policyPointer + '/publicRecordFields', 64)
+            : [];
         if (operations.some(operation => operation.startsWith('public.'))) {
             if (!Object.prototype.hasOwnProperty.call(policy, 'publicRecordFields')) {
-                fail('NATIVE_PUBLIC_RECORD_FIELDS_REQUIRED', `${policyPointer}/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`);
+                fail('NATIVE_PUBLIC_RECORD_FIELDS_INVALID', policyPointer + '/publicRecordFields');
             }
         }
+        const publicQueries = Object.prototype.hasOwnProperty.call(policy, 'publicQueries')
+            ? boundedArray(policy.publicQueries, policyPointer + '/publicQueries', 16)
+            : [];
+        const queryCodes = new Set();
+        publicQueries.forEach((rawQuery, queryIndex) => {
+            const queryPointer = policyPointer + '/publicQueries/' + queryIndex;
+            const query = object(rawQuery, queryPointer);
+            exactKeys(query, ['code', 'kind', 'resourceCode', 'fields', 'defaultLimit', 'maxLimit'], queryPointer, ['sort', 'parameters', 'aggregate']);
+            const queryCode = stableCode(query.code, queryPointer + '/code');
+            if (queryCodes.has(queryCode)) {
+                fail('NATIVE_PUBLIC_QUERY_DUPLICATE', queryPointer + '/code');
+            }
+            queryCodes.add(queryCode);
+            if (!['records', 'aggregate'].includes(String(query.kind))) {
+                fail('NATIVE_PUBLIC_QUERY_KIND_INVALID', queryPointer + '/kind');
+            }
+            if (String(query.resourceCode) !== declaredResourceCode) {
+                fail('NATIVE_PUBLIC_QUERY_RESOURCE_INVALID', queryPointer + '/resourceCode');
+            }
+            const queryFields = uniqueStrings(query.fields, queryPointer + '/fields', 64);
+            if (queryFields.length < 1 ||
+                queryFields.some(field => !fields.includes(field)) ||
+                queryFields.some(field => !publicRecordFields?.includes(field))) {
+                fail('NATIVE_PUBLIC_QUERY_FIELDS_INVALID', queryPointer + '/fields');
+            }
+            const defaultLimit = Number(query.defaultLimit);
+            const maxLimit = Number(query.maxLimit);
+            if (!Number.isSafeInteger(defaultLimit) ||
+                !Number.isSafeInteger(maxLimit) ||
+                defaultLimit < 1 ||
+                maxLimit < defaultLimit ||
+                maxLimit > 100) {
+                fail('NATIVE_PUBLIC_QUERY_LIMIT_INVALID', queryPointer + '/maxLimit');
+            }
+            if (Object.prototype.hasOwnProperty.call(query, 'sort')) {
+                const sort = boundedArray(query.sort, queryPointer + '/sort', 4);
+                const sortFields = new Set();
+                sort.forEach((rawSort, sortIndex) => {
+                    const sortPointer = queryPointer + '/sort/' + sortIndex;
+                    const item = object(rawSort, sortPointer);
+                    exactKeys(item, ['field', 'direction'], sortPointer);
+                    const field = fieldCodeValue(item.field, sortPointer + '/field');
+                    if (!queryFields.includes(field) || sortFields.has(field) || !['asc', 'desc'].includes(String(item.direction))) {
+                        fail('NATIVE_PUBLIC_QUERY_SORT_INVALID', sortPointer);
+                    }
+                    sortFields.add(field);
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(query, 'parameters')) {
+                const parameters = boundedArray(query.parameters, queryPointer + '/parameters', 8);
+                const names = new Set();
+                parameters.forEach((rawParameter, parameterIndex) => {
+                    const parameterPointer = queryPointer + '/parameters/' + parameterIndex;
+                    const parameter = object(rawParameter, parameterPointer);
+                    exactKeys(parameter, ['name', 'field', 'operator', 'type'], parameterPointer);
+                    const name = stableCode(parameter.name, parameterPointer + '/name');
+                    const field = fieldCodeValue(parameter.field, parameterPointer + '/field');
+                    if (names.has(name) ||
+                        !queryFields.includes(field) ||
+                        !['eq', 'contains', 'in'].includes(String(parameter.operator)) ||
+                        !['string', 'number', 'boolean', 'string[]'].includes(String(parameter.type))) {
+                        fail('NATIVE_PUBLIC_QUERY_PARAMETER_INVALID', parameterPointer);
+                    }
+                    names.add(name);
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(query, 'aggregate')) {
+                if (String(query.kind) !== 'aggregate') {
+                    fail('NATIVE_PUBLIC_QUERY_AGGREGATE_KIND_INVALID', queryPointer + '/aggregate');
+                }
+                const aggregatePointer = queryPointer + '/aggregate';
+                const aggregate = object(query.aggregate, aggregatePointer);
+                exactKeys(aggregate, ['measures'], aggregatePointer, ['dimensions', 'order']);
+                const aliases = new Set();
+                const aggregateAlias = (value, pointer) => {
+                    const normalized = String(value || '').trim();
+                    if (!/^[A-Za-z][A-Za-z0-9_]{0,62}$/.test(normalized) || aliases.has(normalized)) {
+                        fail('NATIVE_PUBLIC_QUERY_AGGREGATE_ALIAS_INVALID', pointer);
+                    }
+                    aliases.add(normalized);
+                    return normalized;
+                };
+                const dimensions = Object.prototype.hasOwnProperty.call(aggregate, 'dimensions')
+                    ? boundedArray(aggregate.dimensions, aggregatePointer + '/dimensions', 3)
+                    : [];
+                dimensions.forEach((rawDimension, dimensionIndex) => {
+                    const pointer = `${aggregatePointer}/dimensions/${dimensionIndex}`;
+                    const dimension = object(rawDimension, pointer);
+                    exactKeys(dimension, ['field', 'as'], pointer, ['bucket']);
+                    const field = fieldCodeValue(dimension.field, pointer + '/field');
+                    if (!queryFields.includes(field))
+                        fail('NATIVE_PUBLIC_QUERY_AGGREGATE_FIELD_INVALID', pointer + '/field');
+                    aggregateAlias(dimension.as, pointer + '/as');
+                    if (dimension.bucket !== undefined && !['day', 'week', 'month', 'quarter', 'year'].includes(String(dimension.bucket))) {
+                        fail('NATIVE_PUBLIC_QUERY_AGGREGATE_BUCKET_INVALID', pointer + '/bucket');
+                    }
+                });
+                const measures = boundedArray(aggregate.measures, aggregatePointer + '/measures', 8);
+                if (measures.length < 1)
+                    fail('NATIVE_PUBLIC_QUERY_AGGREGATE_MEASURES_INVALID', aggregatePointer + '/measures');
+                measures.forEach((rawMeasure, measureIndex) => {
+                    const pointer = `${aggregatePointer}/measures/${measureIndex}`;
+                    const measure = object(rawMeasure, pointer);
+                    exactKeys(measure, ['type', 'as'], pointer, ['field']);
+                    const type = String(measure.type);
+                    const field = measure.field === undefined ? undefined : fieldCodeValue(measure.field, pointer + '/field');
+                    if (!['count', 'countDistinct', 'sum', 'avg', 'min', 'max'].includes(type) ||
+                        (type === 'count' ? field !== undefined : !field || !queryFields.includes(field))) {
+                        fail('NATIVE_PUBLIC_QUERY_AGGREGATE_MEASURE_INVALID', pointer);
+                    }
+                    aggregateAlias(measure.as, pointer + '/as');
+                });
+                if (Object.prototype.hasOwnProperty.call(aggregate, 'order')) {
+                    const order = boundedArray(aggregate.order, aggregatePointer + '/order', 10);
+                    order.forEach((rawOrder, orderIndex) => {
+                        const pointer = `${aggregatePointer}/order/${orderIndex}`;
+                        const item = object(rawOrder, pointer);
+                        exactKeys(item, ['field'], pointer, ['direction', 'nulls']);
+                        if (!aliases.has(String(item.field)) ||
+                            (item.direction !== undefined && !['asc', 'desc'].includes(String(item.direction))) ||
+                            (item.nulls !== undefined && !['first', 'last'].includes(String(item.nulls)))) {
+                            fail('NATIVE_PUBLIC_QUERY_AGGREGATE_ORDER_INVALID', pointer);
+                        }
+                    });
+                }
+            }
+        });
         const requiredFields = Object.prototype.hasOwnProperty.call(policy, 'requiredFields')
             ? uniqueStrings(policy.requiredFields, `${policyPointer}/requiredFields`, 64)
             : [];
@@ -2818,6 +2949,75 @@ function compileAnonymousPublicAccess(config) {
                         .sort((left, right) => compareText(left.field, right.field)),
                 }
                 : {}),
+            ...(policy.publicQueries
+                ? {
+                    publicQueries: sorted(policy.publicQueries.map((query) => ({
+                        code: query.code,
+                        kind: query.kind,
+                        resourceCode: query.resourceCode,
+                        fields: uniqueSorted(query.fields),
+                        defaultLimit: Number(query.defaultLimit),
+                        maxLimit: Number(query.maxLimit),
+                        ...(query.sort
+                            ? {
+                                sort: query.sort
+                                    .map((item) => ({
+                                    field: item.field,
+                                    direction: item.direction,
+                                }))
+                                    .sort((left, right) => compareText(left.field, right.field)),
+                            }
+                            : {}),
+                        ...(query.parameters
+                            ? {
+                                parameters: query.parameters
+                                    .map((parameter) => ({
+                                    name: parameter.name,
+                                    field: parameter.field,
+                                    operator: parameter.operator,
+                                    type: parameter.type,
+                                }))
+                                    .sort((left, right) => compareText(left.name, right.name)),
+                            }
+                            : {}),
+                        ...(query.aggregate
+                            ? {
+                                aggregate: {
+                                    ...(query.aggregate.dimensions
+                                        ? {
+                                            dimensions: query.aggregate.dimensions
+                                                .map((dimension) => ({
+                                                field: dimension.field,
+                                                as: dimension.as,
+                                                ...(dimension.bucket ? { bucket: dimension.bucket } : {}),
+                                            }))
+                                                .sort((left, right) => left.as.localeCompare(right.as)),
+                                        }
+                                        : {}),
+                                    measures: query.aggregate.measures
+                                        .map((measure) => ({
+                                        type: measure.type,
+                                        ...(measure.field ? { field: measure.field } : {}),
+                                        as: measure.as,
+                                    }))
+                                        .sort((left, right) => left.as.localeCompare(right.as)),
+                                    ...(query.aggregate.order
+                                        ? {
+                                            order: query.aggregate.order
+                                                .map((item) => ({
+                                                field: item.field,
+                                                ...(item.direction ? { direction: item.direction } : {}),
+                                                ...(item.nulls ? { nulls: item.nulls } : {}),
+                                            }))
+                                                .sort((left, right) => left.field.localeCompare(right.field)),
+                                        }
+                                        : {}),
+                                },
+                            }
+                            : {}),
+                    })), (query) => String(query.code)),
+                }
+                : {}),
             ...(policy.publicSubtableFields
                 ? {
                     publicSubtableFields: Object.fromEntries(Object.entries(policy.publicSubtableFields)