@rytass/bpm-core-nestjs-module 0.6.0 → 0.9.0

package/src/lib/form-data-source/form-data-source.service.js

@@ -0,0 +1,646 @@
+"use strict";
+var FormDataSourceService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormDataSourceService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const form_1 = require("@rytass/bpm-core-shared/form");
+const typeorm_2 = require("typeorm");
+const approval_template_version_entity_1 = require("../template/approval-template-version.entity");
+const template_enums_1 = require("../template/template.enums");
+const form_definition_version_entity_1 = require("../form/form-definition-version.entity");
+const form_enums_1 = require("../form/form.enums");
+const form_schema_validator_1 = require("../form/form-schema.validator");
+const workflow_engine_enums_1 = require("../workflow-engine/workflow-engine.enums");
+const workflow_engine_service_1 = require("../workflow-engine/workflow-engine.service");
+const form_data_source_errors_1 = require("./form-data-source.errors");
+const form_data_source_types_1 = require("./form-data-source.types");
+const MAX_PARAMETER_BYTES = 16_384;
+const PROVIDER_TIMEOUT_MS = 5_000;
+const SOURCE_CONTROLS = [
+    'autocomplete',
+    'checkbox',
+    'radio',
+    'select',
+];
+const PARAMETER_TYPES = [
+    'BOOLEAN',
+    'NUMBER',
+    'STRING',
+    'STRING_ARRAY',
+];
+let FormDataSourceService = FormDataSourceService_1 = class FormDataSourceService {
+    constructor(registry, approvalTemplateVersionRepository, formDefinitionVersionRepository, workflowEngineService) {
+        this.registry = registry;
+        this.approvalTemplateVersionRepository = approvalTemplateVersionRepository;
+        this.formDefinitionVersionRepository = formDefinitionVersionRepository;
+        this.workflowEngineService = workflowEngineService;
+        this.logger = new common_1.Logger(FormDataSourceService_1.name);
+    }
+    listDescriptors() {
+        return this.registry.list().flatMap((source) => this.readDescriptorErrors(source.descriptor).length === 0
+            ? [source.descriptor]
+            : []);
+    }
+    lintDefinitionSchemaEnvironment(schema) {
+        return schema.fields.flatMap((field, index) => {
+            if (!(0, form_1.isFormDataSourceFieldDefinition)(field)) {
+                return [];
+            }
+            const path = `schema.fields[${index}].dataSource`;
+            const source = this.registry.get(field.dataSource.key, field.dataSource.version);
+            if (!source) {
+                return [`${path} ${this.readMissingSourceCode(field.dataSource.key)}`];
+            }
+            const descriptorErrors = this.readDescriptorErrors(source.descriptor);
+            const controlErrors = this.readControlErrors(field, source.descriptor, path);
+            const bindingErrors = this.readBindingEnvironmentErrors(field.dataSource, source.descriptor, path);
+            return [...descriptorErrors, ...controlErrors, ...bindingErrors];
+        });
+    }
+    async previewFormFieldOptions(input, authContext) {
+        const { schema } = this.parseSchema(input.schemaJson, input.uiSchemaJson);
+        this.assertEnvironmentSchema(schema);
+        const field = this.readOptionField(schema, input.fieldKey);
+        const formData = this.parseFormData(input.formDataJson);
+        return this.searchFormFieldOptions({
+            authContext,
+            cursor: input.cursor ?? null,
+            field,
+            formData,
+            searchText: input.searchText ?? '',
+        });
+    }
+    async formFieldOptions(input, authContext) {
+        const context = await this.readRuntimeSchema(input, authContext);
+        const field = this.readOptionField(context.schema, input.fieldKey);
+        const formData = this.parseFormData(input.formDataJson);
+        return this.searchFormFieldOptions({
+            authContext,
+            cursor: input.cursor ?? null,
+            field,
+            formData,
+            searchText: input.searchText ?? '',
+        });
+    }
+    async searchFormFieldOptions(input) {
+        const field = this.readDynamicOptionField(input.field);
+        const source = this.readSourceOrThrow(field.dataSource);
+        this.assertControlSupported(field, source.descriptor);
+        const bindings = this.readBindingValues(field, source.descriptor, input.formData);
+        if (bindings.missingParameters.length > 0) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.WAITING_FOR_DEPENDENCIES);
+        }
+        const searchText = input.searchText.trim();
+        this.assertSearchRequest(source.descriptor, searchText, input.cursor);
+        const result = await this.callProvider(source, 'search', (signal) => source.search({
+            authContext: input.authContext,
+            bindings: bindings.values,
+            cursor: input.cursor,
+            searchText,
+            signal,
+        }));
+        const options = this.validateSearchResult(result, source.descriptor);
+        return {
+            dataSourceKey: source.descriptor.key,
+            dataSourceVersion: source.descriptor.version,
+            nextCursor: this.readNextCursor(result, source.descriptor),
+            options,
+        };
+    }
+    async resolveFormFieldOptions(input) {
+        const field = this.readDynamicOptionField(input.field);
+        const source = this.readSourceOrThrow(field.dataSource);
+        this.assertControlSupported(field, source.descriptor);
+        const values = this.validateRequestedValues(input.values, source.descriptor.maximumResultCount);
+        const bindings = this.readBindingValues(field, source.descriptor, input.formData);
+        if (bindings.missingParameters.length > 0) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.WAITING_FOR_DEPENDENCIES);
+        }
+        const result = await this.callProvider(source, 'resolve', (signal) => source.resolve({
+            authContext: input.authContext,
+            bindings: bindings.values,
+            signal,
+            values,
+        }));
+        const options = this.validateResolveResult(result, values, source.descriptor.maximumResultCount);
+        const optionByValue = new Map(options.map((option) => [
+            option.value,
+            option,
+        ]));
+        return values.map((value) => optionByValue.get(value));
+    }
+    async readRuntimeSchema(input, authContext) {
+        const templateId = readOptionalText(input.templateId);
+        const instanceId = readOptionalText(input.instanceId);
+        if (Boolean(templateId) === Boolean(instanceId)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+        }
+        if (templateId) {
+            const launchableTemplates = await this.workflowEngineService.listLaunchableApprovalTemplates(authContext.memberId);
+            const template = launchableTemplates.find((candidate) => candidate.id === templateId);
+            if (!template?.currentVersionId) {
+                throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+            }
+            const templateVersion = await this.approvalTemplateVersionRepository.findOne({
+                where: {
+                    id: template.currentVersionId,
+                    status: template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED,
+                },
+            });
+            if (!templateVersion?.formDefinitionVersionId) {
+                throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+            }
+            return this.readPublishedFormSchema(templateVersion.formDefinitionVersionId);
+        }
+        const instance = await this.workflowEngineService.getApprovalInstance(instanceId, authContext);
+        if (instance.initiatorMemberId !== authContext.memberId ||
+            instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED) {
+            throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+        }
+        const snapshot = instance.formDefinitionSnapshot;
+        const schema = isRecord(snapshot.schema) ? snapshot.schema : null;
+        const uiSchema = isRecord(snapshot.uiSchema) ? snapshot.uiSchema : null;
+        if (!schema || !uiSchema) {
+            throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+        }
+        return this.parseSchema(JSON.stringify(schema), JSON.stringify(uiSchema));
+    }
+    async readPublishedFormSchema(formDefinitionVersionId) {
+        const version = await this.formDefinitionVersionRepository.findOne({
+            where: {
+                id: formDefinitionVersionId,
+                status: form_enums_1.FormDefinitionVersionStatusEnum.PUBLISHED,
+            },
+        });
+        if (!version) {
+            throw new form_data_source_errors_1.BPMFormDataSourceForbiddenException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RUNTIME_CONTEXT_FORBIDDEN);
+        }
+        return this.parseSchema(JSON.stringify(version.schema), JSON.stringify(version.uiSchema));
+    }
+    parseSchema(schemaJson, uiSchemaJson) {
+        try {
+            const parsed = (0, form_schema_validator_1.parseAndValidateFormSchemas)(schemaJson, uiSchemaJson);
+            return {
+                schema: parsed.schema,
+                uiSchemaJson: JSON.stringify(parsed.uiSchema),
+            };
+        }
+        catch {
+            throw new common_1.BadRequestException('Form DataSource schema is invalid');
+        }
+    }
+    assertEnvironmentSchema(schema) {
+        const errors = this.lintDefinitionSchemaEnvironment(schema);
+        if (errors.length === 0) {
+            return;
+        }
+        // Report the code of the FIRST error that carries one, deciding by line
+        // shape: the emitted `<path>.dataSource <CODE>` form, else a binding line
+        // whose code is implied rather than written (its prose quotes a
+        // designer-chosen name that must never be read as a code), else the
+        // descriptor fallback. Scanning the code list with `includes()` instead
+        // made the answer depend on enum declaration order and would misfire the
+        // day one code becomes a substring of another.
+        const [code] = errors.flatMap((error) => {
+            const candidate = readLintLineErrorCode(error);
+            return candidate ? [candidate] : readBindingLintErrorCode(error);
+        });
+        throw new form_data_source_errors_1.BPMFormDataSourceException(code ?? form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_DESCRIPTOR);
+    }
+    parseFormData(formDataJson) {
+        if (!formDataJson?.trim()) {
+            return {};
+        }
+        try {
+            const value = JSON.parse(formDataJson);
+            if (isRecord(value)) {
+                return value;
+            }
+        }
+        catch {
+            // The stable error below deliberately hides parser details.
+        }
+        throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+    }
+    readOptionField(schema, fieldKey) {
+        const field = schema.fields.find((candidate) => candidate.fieldKey === fieldKey);
+        if (!field || !isFormOptionField(field)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.FIELD_NOT_DYNAMIC);
+        }
+        return field;
+    }
+    readDynamicOptionField(field) {
+        if (!(0, form_1.isFormDataSourceFieldDefinition)(field)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.FIELD_NOT_DYNAMIC);
+        }
+        return field;
+    }
+    readSourceOrThrow(reference) {
+        const source = this.registry.get(reference.key, reference.version);
+        if (!source) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(this.readMissingSourceCode(reference.key));
+        }
+        const descriptorErrors = this.readDescriptorErrors(source.descriptor);
+        if (descriptorErrors.length > 0) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_DESCRIPTOR);
+        }
+        return source;
+    }
+    /**
+     * A key the host never registered and a key whose requested version was
+     * dropped are different operational problems, so they keep distinct codes:
+     * the first tells the designer the source is gone, the second that only this
+     * version is.
+     */
+    readMissingSourceCode(key) {
+        const hasKey = this.registry
+            .list()
+            .some((candidate) => candidate.descriptor?.key === key);
+        return hasKey
+            ? form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.DATA_SOURCE_VERSION_MISSING
+            : form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.DATA_SOURCE_MISSING;
+    }
+    assertControlSupported(field, descriptor) {
+        const control = field.type;
+        if (!descriptor.supportedControls.includes(control)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.UNSUPPORTED_CONTROL);
+        }
+        if ((control === 'radio' || control === 'checkbox') &&
+            (!descriptor.returnsCompleteList || descriptor.maximumResultCount > 50)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.UNSUPPORTED_CONTROL);
+        }
+    }
+    assertSearchRequest(descriptor, searchText, cursor) {
+        if (!descriptor.supportsSearch && searchText) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.SEARCH_NOT_SUPPORTED);
+        }
+        if (descriptor.supportsSearch &&
+            searchText.length > 0 &&
+            searchText.length < descriptor.minimumSearchLength) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.SEARCH_TOO_SHORT);
+        }
+        if (cursor && descriptor.paginationMode === 'NONE') {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+        }
+    }
+    readBindingValues(field, descriptor, formData) {
+        const parameterByKey = new Map(descriptor.parameters.map((parameter) => [
+            parameter.key,
+            parameter,
+        ]));
+        const bindingValues = field.dataSource.bindings.reduce((values, binding) => {
+            const parameter = parameterByKey.get(binding.parameter);
+            if (!parameter) {
+                throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+            }
+            const nextValue = binding.from.kind === 'FIELD'
+                ? readFormDataValue(formData[binding.from.fieldKey])
+                : binding.from.value;
+            if (typeof nextValue === 'undefined') {
+                return values;
+            }
+            this.assertParameterValue(parameter, nextValue);
+            return { ...values, [parameter.key]: nextValue };
+        }, {});
+        const missingParameters = descriptor.parameters
+            .filter((parameter) => parameter.required)
+            .filter((parameter) => !isPresentFormDataValue(bindingValues[parameter.key]))
+            .map((parameter) => parameter.key);
+        if (JSON.stringify(bindingValues).length > MAX_PARAMETER_BYTES) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.PARAMETER_LIMIT_EXCEEDED);
+        }
+        return { missingParameters, values: bindingValues };
+    }
+    assertParameterValue(parameter, value) {
+        const valid = (parameter.type === 'BOOLEAN' && typeof value === 'boolean') ||
+            (parameter.type === 'NUMBER' && typeof value === 'number') ||
+            (parameter.type === 'STRING' && typeof value === 'string') ||
+            (parameter.type === 'STRING_ARRAY' && isStringArray(value)) ||
+            value === null;
+        if (!valid) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+        }
+    }
+    validateRequestedValues(values, maximumResultCount) {
+        if (values.length === 0 ||
+            values.some((value) => !value.trim()) ||
+            new Set(values).size !== values.length) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+        }
+        if (values.length > maximumResultCount) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RESULT_LIMIT_EXCEEDED);
+        }
+        return [...values];
+    }
+    validateSearchResult(result, descriptor) {
+        if (!isRecord(result) || !Array.isArray(result.options)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        if (result.options.length > descriptor.pageSize ||
+            result.options.length > descriptor.maximumResultCount) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.RESULT_LIMIT_EXCEEDED);
+        }
+        return this.validateOptions(result.options);
+    }
+    validateResolveResult(result, values, maximumResultCount) {
+        if (!Array.isArray(result) || result.length > maximumResultCount) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        const options = this.validateOptions(result);
+        const requestedValues = new Set(values);
+        // A value the caller never asked for is a provider contract breach.
+        if (options.some((option) => !requestedValues.has(option.value))) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        // Every requested value resolved to exactly one option, or the submitted
+        // value is simply no longer selectable — that is a user-facing failure.
+        if (options.length !== values.length) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.VALUE_NOT_RESOLVED);
+        }
+        return options;
+    }
+    validateOptions(value) {
+        if (!Array.isArray(value)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        const options = value.filter(isFormFieldOption);
+        if (options.length !== value.length ||
+            options.some((option) => !option.label.trim() || !option.value.trim()) ||
+            new Set(options.map((option) => option.value)).size !== options.length) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        return options;
+    }
+    readNextCursor(result, descriptor) {
+        const nextCursor = result.nextCursor ?? null;
+        if ((nextCursor !== null && typeof nextCursor !== 'string') ||
+            (descriptor.paginationMode === 'NONE' && nextCursor !== null)) {
+            throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_PROVIDER_RESULT);
+        }
+        return nextCursor;
+    }
+    async callProvider(source, operation, call) {
+        const controller = new AbortController();
+        let timeoutId;
+        const startedAt = Date.now();
+        try {
+            const result = await Promise.race([
+                call(controller.signal),
+                new Promise((_resolve, reject) => {
+                    timeoutId = setTimeout(() => {
+                        controller.abort();
+                        const timeout = new Error('provider timeout');
+                        Object.assign(timeout, { kind: 'FORM_DATA_SOURCE_TIMEOUT' });
+                        reject(timeout);
+                    }, PROVIDER_TIMEOUT_MS);
+                }),
+            ]);
+            this.logger.log(JSON.stringify({
+                dataSourceKey: source.descriptor.key,
+                dataSourceVersion: source.descriptor.version,
+                durationMs: Date.now() - startedAt,
+                operation,
+                status: 'success',
+            }));
+            return result;
+        }
+        catch (error) {
+            const code = isTimeoutMarker(error)
+                ? form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.TIMEOUT
+                : form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.PROVIDER_FAILURE;
+            this.logger.warn(JSON.stringify({
+                dataSourceKey: source.descriptor.key,
+                dataSourceVersion: source.descriptor.version,
+                durationMs: Date.now() - startedAt,
+                errorCode: code,
+                operation,
+                status: 'error',
+            }));
+            throw new form_data_source_errors_1.BPMFormDataSourceException(code);
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+    readDescriptorErrors(descriptor) {
+        const descriptorValue = isRecord(descriptor)
+            ? descriptor
+            : {};
+        const parameters = Array.isArray(descriptorValue.parameters)
+            ? descriptorValue.parameters
+            : [];
+        const supportedControls = Array.isArray(descriptorValue.supportedControls)
+            ? descriptorValue.supportedControls
+            : [];
+        const version = descriptorValue.version;
+        const maximumResultCount = descriptorValue.maximumResultCount;
+        const pageSize = descriptorValue.pageSize;
+        const minimumSearchLength = descriptorValue.minimumSearchLength;
+        const errors = [
+            ...(typeof descriptorValue.key === 'string' && descriptorValue.key.trim()
+                ? []
+                : ['descriptor.key is required']),
+            ...(typeof descriptorValue.label === 'string' && descriptorValue.label.trim()
+                ? []
+                : ['descriptor.label is required']),
+            ...(isPositiveInteger(version)
+                ? []
+                : ['descriptor.version must be a positive integer']),
+            ...(isPositiveInteger(maximumResultCount)
+                ? []
+                : ['descriptor.maximumResultCount must be positive']),
+            ...(isPositiveInteger(pageSize)
+                ? []
+                : ['descriptor.pageSize must be positive']),
+            ...(isNonNegativeInteger(minimumSearchLength)
+                ? []
+                : ['descriptor.minimumSearchLength must be non-negative']),
+            ...(typeof pageSize === 'number' &&
+                typeof maximumResultCount === 'number' &&
+                pageSize <= maximumResultCount
+                ? []
+                : ['descriptor.pageSize cannot exceed descriptor.maximumResultCount']),
+            ...(descriptorValue.paginationMode === 'CURSOR' ||
+                descriptorValue.paginationMode === 'NONE'
+                ? []
+                : ['descriptor.paginationMode is invalid']),
+            ...(descriptorValue.revalidationPolicy === 'ALWAYS' ||
+                descriptorValue.revalidationPolicy === 'WHEN_VALUE_OR_BINDINGS_CHANGE'
+                ? []
+                : ['descriptor.revalidationPolicy is invalid']),
+            ...(Array.isArray(descriptorValue.parameters)
+                ? []
+                : ['descriptor.parameters must be an array']),
+            ...(typeof descriptorValue.returnsCompleteList === 'boolean'
+                ? []
+                : ['descriptor.returnsCompleteList must be boolean']),
+            ...(typeof descriptorValue.supportsSearch === 'boolean'
+                ? []
+                : ['descriptor.supportsSearch must be boolean']),
+            ...(Array.isArray(descriptorValue.supportedControls) &&
+                supportedControls.every((control) => SOURCE_CONTROLS.includes(control))
+                ? []
+                : ['descriptor.supportedControls contains an invalid control']),
+            ...(new Set(supportedControls).size === supportedControls.length
+                ? []
+                : ['descriptor.supportedControls contains duplicates']),
+        ];
+        const parameterErrors = Array.isArray(descriptorValue.parameters)
+            ? parameters.flatMap((parameter, index) => this.readParameterErrors(parameter, index))
+            : [];
+        const parameterKeys = parameters.flatMap((parameter) => isRecord(parameter) && typeof parameter.key === 'string'
+            ? [parameter.key]
+            : []);
+        const duplicateParameterKeys = Array.isArray(descriptorValue.parameters)
+            ? [
+                ...new Set(parameterKeys
+                    .filter((key, index, keys) => keys.indexOf(key) !== index)),
+            ]
+            : [];
+        const duplicateParameterErrors = duplicateParameterKeys.map((key) => `descriptor.parameters.key is duplicated: ${key}`);
+        return [...errors, ...parameterErrors, ...duplicateParameterErrors];
+    }
+    readParameterErrors(parameter, index) {
+        const parameterValue = isRecord(parameter) ? parameter : {};
+        return [
+            ...(typeof parameterValue.key === 'string' && parameterValue.key.trim()
+                ? []
+                : [`descriptor.parameters[${index}].key is required`]),
+            ...(typeof parameterValue.required === 'boolean'
+                ? []
+                : [`descriptor.parameters[${index}].required must be boolean`]),
+            ...(PARAMETER_TYPES.includes(parameterValue.type)
+                ? []
+                : [`descriptor.parameters[${index}].type is invalid`]),
+        ];
+    }
+    readControlErrors(field, descriptor, path) {
+        const control = field.type;
+        const declaresControl = descriptor.supportedControls.includes(control);
+        const allowsCompleteList = control !== 'radio' && control !== 'checkbox'
+            ? true
+            : descriptor.returnsCompleteList && descriptor.maximumResultCount <= 50;
+        // Both checks fail the same control for the same reason, so report the code
+        // once instead of repeating it in the field-level error list.
+        return declaresControl && allowsCompleteList
+            ? []
+            : [`${path} ${form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.UNSUPPORTED_CONTROL}`];
+    }
+    readBindingEnvironmentErrors(reference, descriptor, path) {
+        const parameterKeys = new Set(descriptor.parameters.map((parameter) => parameter.key));
+        const bindingKeys = new Set(reference.bindings.map((binding) => binding.parameter));
+        const missingRequired = descriptor.parameters
+            .filter((parameter) => parameter.required && !bindingKeys.has(parameter.key))
+            .map((parameter) => `${path}.bindings missing required parameter: ${parameter.key}`);
+        const unknownParameters = reference.bindings
+            .filter((binding) => !parameterKeys.has(binding.parameter))
+            .map((binding) => `${path}.bindings unknown parameter: ${binding.parameter}`);
+        return [...missingRequired, ...unknownParameters];
+    }
+};
+exports.FormDataSourceService = FormDataSourceService;
+exports.FormDataSourceService = FormDataSourceService = FormDataSourceService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)(form_data_source_types_1.BPM_FORM_DATA_SOURCE_REGISTRY)),
+    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(approval_template_version_entity_1.ApprovalTemplateVersionEntity)),
+    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(form_definition_version_entity_1.FormDefinitionVersionEntity)),
+    tslib_1.__metadata("design:paramtypes", [Object, typeorm_2.Repository,
+        typeorm_2.Repository,
+        workflow_engine_service_1.WorkflowEngineService])
+], FormDataSourceService);
+function isFormOptionField(field) {
+    return (field.type === 'select' ||
+        field.type === 'autocomplete' ||
+        field.type === 'radio' ||
+        field.type === 'checkbox');
+}
+function isFormFieldOption(value) {
+    return (isRecord(value) &&
+        typeof value.label === 'string' &&
+        typeof value.value === 'string');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function readFormDataValue(value) {
+    if (value === null ||
+        typeof value === 'boolean' ||
+        typeof value === 'number' ||
+        typeof value === 'string' ||
+        isStringArrayValue(value)) {
+        return value;
+    }
+    if (typeof value === 'undefined') {
+        return undefined;
+    }
+    throw new form_data_source_errors_1.BPMFormDataSourceException(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING);
+}
+function isStringArrayValue(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isPresentFormDataValue(value) {
+    if (typeof value === 'undefined' || value === null) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+function readOptionalText(value) {
+    const text = value?.trim() ?? '';
+    return text || null;
+}
+function isTimeoutMarker(value) {
+    return (value instanceof Error &&
+        value.kind ===
+            'FORM_DATA_SOURCE_TIMEOUT');
+}
+/**
+ * Matches only the code-bearing lint shape `<path>.dataSource <CODE>`. Reading
+ * the trailing token alone would misreport prose such as
+ * `...bindings unknown parameter: FORM_DATA_SOURCE_TIMEOUT`, where the code-like
+ * text is a parameter name — chosen by the host in its descriptor, or by the
+ * designer in a binding — rather than an error code.
+ */
+const LINT_LINE_CODE_PATTERN = /^\S+\.dataSource (FORM_DATA_SOURCE_[A-Z_]+)$/u;
+/**
+ * Binding lint lines stay prose because they quote a parameter name chosen by
+ * the host or the designer, so their code is derived from the line shape
+ * instead of being appended
+ * to the text — appending it would put a raw code back on the designer's lint
+ * panel, which the client formatter deliberately never rewrites inside prose.
+ *
+ * Without this the preview would fall back to `INVALID_DESCRIPTOR` ("contact
+ * your administrator") for a binding the designer can fix themselves.
+ */
+const LINT_BINDING_LINE_PATTERN = /^schema\.fields\[\d+\]\.dataSource\.bindings /u;
+function readBindingLintErrorCode(error) {
+    return LINT_BINDING_LINE_PATTERN.test(error)
+        ? [form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES.INVALID_BINDING]
+        : [];
+}
+function readLintLineErrorCode(error) {
+    const candidate = LINT_LINE_CODE_PATTERN.exec(error)?.[1];
+    return candidate && isFormDataSourceErrorCode(candidate) ? candidate : null;
+}
+function isFormDataSourceErrorCode(value) {
+    return Object.values(form_data_source_errors_1.BPM_FORM_DATA_SOURCE_ERROR_CODES).includes(value);
+}
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+//# sourceMappingURL=form-data-source.service.js.map