@planet-a/affinity-node/esm/v2/generated/configuration.js

API wrapper for the affinity.co API

import { PromiseMiddlewareWrapper } from "./middleware.js";
import { IsomorphicFetchHttpLibrary as DefaultHttpLibrary } from "./http/isomorphic-fetch.js";
import { server1 } from "./servers.js";
import { configureAuthMethods } from "./auth/auth.js";
/**
 * Provide your `ConfigurationParameters` to this function to get a `Configuration`
 * object that can be used to configure your APIs (in the constructor or
 * for each request individually).
 *
 * If a property is not included in conf, a default is used:
 *    - baseServer: server1
 *    - httpApi: IsomorphicFetchHttpLibrary
 *    - middleware: []
 *    - promiseMiddleware: []
 *    - authMethods: {}
 *
 * @param conf partial configuration
 */
export function createConfiguration(conf = {}) {
    const configuration = {
        baseServer: conf.baseServer !== undefined ? conf.baseServer : server1,
        httpApi: conf.httpApi || new DefaultHttpLibrary(),
        middleware: conf.middleware || [],
        authMethods: configureAuthMethods(conf.authMethods)
    };
    if (conf.promiseMiddleware) {
        conf.promiseMiddleware.forEach(m => configuration.middleware.push(new PromiseMiddlewareWrapper(m)));
    }
    return configuration;
}
/**
 * Merge configuration options into a configuration.
 */
export function mergeConfiguration(conf, options) {
    if (!options) {
        return conf;
    }
    return {
        baseServer: options.baseServer || conf.baseServer,
        httpApi: options.httpApi || conf.httpApi,
        authMethods: options.authMethods || conf.authMethods,
        middleware: mergeMiddleware(conf.middleware, options?.middleware, options?.middlewareMergeStrategy),
    };
}
function mergeMiddleware(staticMiddleware, calltimeMiddleware, strategy = "replace") {
    if (!calltimeMiddleware) {
        return staticMiddleware;
    }
    switch (strategy) {
        case "append":
            return staticMiddleware.concat(calltimeMiddleware);
        case "prepend":
            return calltimeMiddleware.concat(staticMiddleware);
        case "replace":
            return calltimeMiddleware;
        default:
            throw new Error(`Unrecognized middleware merge strategy '${strategy}'`);
    }
}
/**
 * Convert Promise-based configuration options to Observable-based configuration options.
 */
export function wrapOptions(options) {
    if (options) {
        return {
            baseServer: options.baseServer,
            httpApi: options.httpApi,
            middleware: options.middleware?.map(m => new PromiseMiddlewareWrapper(m)),
            middlewareMergeStrategy: options.middlewareMergeStrategy,
            authMethods: options.authMethods,
        };
    }
    return;
}