@datastax/astra-db-ts/dist/esm/lib/headers-providers/root/opts-handlers.js

Data API TypeScript client

// Copyright Datastax, Inc
// SPDX-License-Identifier: Apache-2.0
import { HeadersProvider, StaticHeadersProvider } from '../../../lib/headers-providers/index.js';
import { MonoidalOptionsHandler, monoids } from '../../../lib/opts-handlers.js';
import { either, nullish, optional, record, string } from 'decoders';
import { anyInstanceOf, isNullish, oneOrMany } from '../../../lib/utils.js';
const monoid = monoids.object({
    providers: monoids.array(),
});
const decoderFromStr = nullish(either(anyInstanceOf(HeadersProvider), string));
export const StringBasedHeadersProviderOptsHandler = (kleisli) => {
    const transformer = decoderFromStr
        .transform((input) => {
        if (typeof input === 'string') {
            return { providers: [new kleisli(input)] };
        }
        if (isNullish(input)) {
            return monoid.empty;
        }
        return { providers: [input] };
    });
    return new MonoidalOptionsHandler(transformer, monoid);
};
const decoderFromObj = nullish(oneOrMany(either(anyInstanceOf(HeadersProvider), record(optional(string)))));
export const ObjectBasedHeadersProviderOptsHandler = (() => {
    const transformer = decoderFromObj.transform((input) => {
        if (!input) {
            return monoid.empty;
        }
        const asArray = (!Array.isArray(input)) ? [input] : input;
        const providers = asArray.map((value) => {
            if (value instanceof HeadersProvider) {
                return value;
            }
            return new StaticHeadersProvider(value);
        });
        return { providers };
    });
    return new MonoidalOptionsHandler(transformer, monoid);
})();
HeadersProvider.opts = {
    fromStr: StringBasedHeadersProviderOptsHandler,
    fromObj: ObjectBasedHeadersProviderOptsHandler,
    monoid: monoid,
    parsed: null,
};