dynamodb-toolbox/dist/esm/schema/actions/format/anyOf.js

Lightweight and type-safe query builder for DynamoDB and TypeScript.

import { DynamoDBToolboxError } from '../../../errors/index.js';
import { formatArrayPath } from '../../../schema/actions/utils/formatArrayPath.js';
import { $discriminators } from '../../../schema/anyOf/constants.js';
import { isObject } from '../../../utils/validation/isObject.js';
import { isString } from '../../../utils/validation/isString.js';
import { schemaFormatter } from './schema.js';
export function* anyOfSchemaFormatter(schema, rawValue, options = {}) {
    const { discriminator } = schema.props;
    const { format = true, transform = true, valuePath } = options;
    let formatter = undefined;
    let _transformedValue = undefined;
    let _formattedValue = undefined;
    const discriminatorSavedAs = discriminator && transform ? schema[$discriminators][discriminator] : discriminator;
    if (discriminatorSavedAs !== undefined &&
        isObject(rawValue) &&
        discriminatorSavedAs in rawValue) {
        const discriminatorValue = rawValue[discriminatorSavedAs];
        const matchingElement = isString(discriminatorValue)
            ? schema.match(discriminatorValue)
            : undefined;
        if (matchingElement !== undefined) {
            formatter = schemaFormatter(matchingElement, rawValue, options);
            if (transform) {
                _transformedValue = formatter.next().value;
            }
            if (format) {
                _formattedValue = formatter.next().value;
            }
        }
    }
    if (formatter === undefined) {
        for (const element of schema.elements) {
            try {
                formatter = schemaFormatter(element, rawValue, options);
                if (transform) {
                    _transformedValue = formatter.next().value;
                }
                if (format) {
                    _formattedValue = formatter.next().value;
                }
                break;
            }
            catch (error) {
                continue;
            }
        }
    }
    const transformedValue = _transformedValue;
    const formattedValue = _formattedValue;
    if ((transform && transformedValue === undefined) || (format && formattedValue === undefined)) {
        const path = valuePath !== undefined ? formatArrayPath(valuePath) : undefined;
        throw new DynamoDBToolboxError('formatter.invalidAttribute', {
            message: `Invalid attribute detected while formatting. Attribute does not match any of the possible sub-types${path !== undefined ? `: '${path}'` : ''}.`,
            path,
            payload: { received: rawValue }
        });
    }
    if (transform) {
        if (format) {
            yield transformedValue;
        }
        else {
            return transformedValue;
        }
    }
    return formattedValue;
}