@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/dist/src/config/index.js

@@ -0,0 +1,366 @@
+"use strict";
+// Import { getRandomRequiredEnv, getRandomEnv, getEnv } from '../util'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdapterConfig = exports.BaseSettings = void 0;
+exports.BaseSettings = {
+    // V2 compat
+    // TODO: Remove non used in v3 ones
+    API_ENDPOINT: {
+        description: 'The URL that the certain transports use to retrieve data',
+        type: 'string',
+    },
+    API_KEY: {
+        description: 'Default setting for an EA key',
+        type: 'string',
+    },
+    // API_TIMEOUT: {
+    //   type: 'number',
+    //   default: 30000,
+    // },
+    // API_VERBOSE: {
+    //   type: 'boolean',
+    // },
+    BASE_URL: {
+        description: 'Starting path for the EA handler endpoint',
+        type: 'string',
+        default: '/',
+    },
+    // CACHE_ENABLED: {
+    //   type: 'boolean',
+    //   default: true,
+    // },
+    // CACHE_KEY_GROUP: {
+    //   type: 'string',
+    // },
+    CACHE_MAX_AGE: {
+        description: 'Maximum amount of time (in ms) that a response will stay cached',
+        type: 'number',
+        default: 90000,
+    },
+    // CACHE_MAX_ITEMS: {
+    //   type: 'number',
+    //   default: 1000,
+    // },
+    // CACHE_MIN_AGE: {
+    //   type: 'number',
+    //   default: 30000,
+    // },
+    // CACHE_REDIS_CONNECTION_TIMEOUT: {
+    //   type: 'number',
+    //   default: 15000,
+    // },
+    CACHE_REDIS_HOST: {
+        description: 'Hostname for the Redis instance to be used',
+        type: 'string',
+        default: '127.0.0.1',
+    },
+    // CACHE_REDIS_MAX_QUEUED_ITEMS: {
+    //   type: 'number',
+    //   default: 100,
+    // },
+    // CACHE_REDIS_MAX_RECONNECT_COOLDOWN: {
+    //   type: 'number',
+    //   default: 3000,
+    // },
+    // CACHE_REDIS_PASSWORD: {
+    //   type: 'string',
+    // },
+    // CACHE_REDIS_PATH: {
+    //   type: 'string',
+    // },
+    CACHE_REDIS_PORT: {
+        description: 'Port for the Redis instance to be used',
+        type: 'number',
+        default: 6379,
+    },
+    // CACHE_REDIS_TIMEOUT: {
+    //   type: 'number',
+    //   default: 500,
+    // },
+    // CACHE_REDIS_URL: {
+    //   type: 'string',
+    // },
+    CACHE_TYPE: {
+        description: 'The type of cache to use throughout the EA',
+        type: 'enum',
+        default: 'local',
+        options: ['local', 'redis'],
+    },
+    // CACHE_UPDATE_AGE_ON_GET: {
+    //   type: 'boolean',
+    //   default: false,
+    // },
+    CORRELATION_ID_ENABLED: {
+        description: 'Flag to enable correlation IDs for sent requests in logging',
+        type: 'boolean',
+        default: true,
+    },
+    // DEBUG: {
+    //   type: 'boolean',
+    // },
+    // DEFAULT_WS_HEARTBEAT_INTERVAL: {
+    //   type: 'number',
+    //   default: 30000,
+    // },
+    EA_PORT: {
+        description: 'Port through which the EA will listen for REST requests (if mode is set to "reader" or "reader-writer")',
+        type: 'number',
+        default: 8080,
+    },
+    // ENV_ADAPTER_URL: {
+    //   type: 'string',
+    // },
+    // ERROR_CAPACITY: {
+    //   type: 'number',
+    // },
+    EXPERIMENTAL_METRICS_ENABLED: {
+        description: 'Flag to specify whether or not to collect metrics. Used as fallback for METRICS_ENABLED',
+        type: 'boolean',
+        default: true,
+    },
+    // LEGACY_ENV_ADAPTER_URL: {
+    //   type: 'string',
+    // },
+    LOG_LEVEL: {
+        description: 'Minimum level required for logs to be output',
+        type: 'string',
+        default: 'info',
+    },
+    METRICS_ENABLED: {
+        description: 'Flag to specify whether or not to startup the metrics server',
+        type: 'boolean',
+        default: true,
+    },
+    METRICS_NAME: {
+        description: 'Metrics name',
+        type: 'string',
+    },
+    METRICS_PORT: {
+        description: 'Port metrics will be exposed to',
+        type: 'number',
+        default: 9080,
+    },
+    METRICS_USE_BASE_URL: {
+        description: 'Flag to specify whether or not to prepend the BASE_URL to the metrics endpoint',
+        type: 'boolean',
+    },
+    RATE_LIMIT_API_TIER: {
+        description: 'Rate limiting tier to use from the available options for the adapter. If not present, the adapter will run using the first tier on the list.',
+        type: 'string',
+    },
+    // RATE_LIMIT_CAPACITY_MINUTE: {
+    //   type: 'number',
+    // },
+    // RATE_LIMIT_CAPACITY_SECOND: {
+    //   type: 'number',
+    // },
+    // RATE_LIMIT_CAPACITY: {
+    //   type: 'number',
+    // },
+    // RATE_LIMIT_ENABLED: {
+    //   type: 'boolean',
+    //   default: true,
+    // },
+    // RECORD: {
+    //   type: 'boolean',
+    // },
+    // REQUEST_COALESCING_ENABLED: {
+    //   type: 'boolean',
+    // },
+    // REQUEST_COALESCING_ENTROPY_MAX: {
+    //   type: 'number',
+    //   default: 0,
+    // },
+    // REQUEST_COALESCING_INTERVAL_COEFFICIENT: {
+    //   type: 'number',
+    //   default: 2,
+    // },
+    // REQUEST_COALESCING_INTERVAL_MAX: {
+    //   type: 'number',
+    //   default: 1000,
+    // },
+    // REQUEST_COALESCING_INTERVAL: {
+    //   type: 'number',
+    //   default: 100,
+    // },
+    // REQUEST_COALESCING_MAX_RETRIES: {
+    //   type: 'number',
+    //   default: 5,
+    // },
+    // RETRY: {
+    //   type: 'boolean',
+    //   default: 1,
+    // },
+    // SERVER_RATE_LIMIT_MAX: {
+    //   type: 'number',
+    //   default: 250,
+    // },
+    // SERVER_SLOW_DOWN_AFTER_FACTOR: {
+    //   type: 'number',
+    //   default: 0.8,
+    // },
+    // SERVER_SLOW_DOWN_DELAY_MS: {
+    //   type: 'number',
+    //   default: 500,
+    // },
+    // TIMEOUT: {
+    //   type: 'number',
+    // },
+    // WARMUP_ENABLED: {
+    //   type: 'boolean',
+    //   default: true,
+    // },
+    // WARMUP_INTERVAL: {
+    //   type: 'number',
+    // },
+    WARMUP_SUBSCRIPTION_TTL: {
+        type: 'number',
+        description: 'TTL for batch warmer subscriptions',
+        default: 60000,
+    },
+    // WARMUP_UNHEALTHY_THRESHOLD: {
+    //   type: 'number',
+    //   default: 3,
+    // },
+    // WS_API_ENDPOINT: {
+    //   type: 'string',
+    // },
+    // WS_API_KEY: {
+    //   type: 'string',
+    // },
+    // WS_CONNECTION_KEY: {
+    //   type: 'string',
+    //   default: 1,
+    // },
+    // WS_CONNECTION_LIMIT: {
+    //   type: 'number',
+    //   default: 1,
+    // },
+    // WS_CONNECTION_RETRY_DELAY: {
+    //   type: 'number',
+    //   default: 1000,
+    // },
+    // WS_CONNECTION_RETRY_LIMIT: {
+    //   type: 'number',
+    //   default: 3,
+    // },
+    // WS_CONNECTION_TTL: {
+    //   type: 'number',
+    //   default: 70000,
+    // },
+    // WS_ENABLED: {
+    //   type: 'boolean',
+    //   default: false,
+    // },
+    // WS_SUBSCRIPTION_LIMIT: {
+    //   type: 'number',
+    //   default: 10,
+    // },
+    // WS_SUBSCRIPTION_PRIORITY_LIST: {
+    //   type: 'string',
+    // },
+    // WS_SUBSCRIPTION_TTL: {
+    //   type: 'number',
+    //   default: 120000,
+    // },
+    // WS_SUBSCRIPTION_UNRESPONSIVE_TTL: {
+    //   type: 'number',
+    //   default: false,
+    // },
+    // WS_TIME_UNTIL_HANDLE_NEXT_MESSAGE_OVERRIDE: {
+    //   type: 'number',
+    // },
+    // V3
+    CACHE_POLLING_MAX_RETRIES: {
+        description: 'Max amount of times to attempt to find EA response in the cache after the Transport has been set up',
+        type: 'number',
+        default: 10,
+    },
+    CACHE_POLLING_SLEEP_MS: {
+        description: 'The number of ms to sleep between each retry to fetch the EA response in the cache',
+        type: 'number',
+        default: 200,
+    },
+    DEFAULT_CACHE_KEY: {
+        description: 'Default key to be used when one cannot be determined from request parameters',
+        type: 'string',
+        default: 'DEFAULT_CACHE_KEY',
+    },
+    EA_HOST: {
+        description: 'Host this EA will listen for REST requests on (if mode is set to "reader" or "reader-writer")',
+        type: 'string',
+        default: '::',
+    },
+    EA_MODE: {
+        description: 'Port this EA will listen for REST requests on (if mode is set to "reader" or "reader-writer")',
+        type: 'enum',
+        default: 'reader-writer',
+        options: ['reader', 'writer', 'reader-writer'],
+    },
+    REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES: {
+        description: 'Maximum amount of times the Rest Transport will attempt to set up a request when blocked by the rate limiter',
+        type: 'number',
+        default: 3,
+    },
+    REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES: {
+        description: 'Time that the Rest Transport will wait between retries when blocked by the rate limiter',
+        type: 'number',
+        default: 400,
+    },
+    // CACHE_KEY_IGNORED_PROPS : {
+    //   description: 'Properties to ignore when generating a feed ID for requests',
+    //   type: 'string'
+    // }
+};
+const buildAdapterConfig = ({ overrides = {}, customSettings = {}, }) => {
+    const validationErrors = [];
+    const vars = {};
+    // Iterate base adapter env vars
+    for (const [key, config] of Object.entries(exports.BaseSettings)) {
+        const value = getEnv(key, config) ?? overrides?.[key] ?? config.default;
+        vars[key] = value;
+    }
+    // Iterate custom vars
+    for (const [key, config] of Object.entries(customSettings)) {
+        if (exports.BaseSettings[key]) {
+            throw new Error(`Custom env var "${key}" declared, but a base framework env var with that name already exists.`);
+        }
+        const value = getEnv(key, config) ?? config.default;
+        // Check if a required setting has been provided
+        if (config.required && value === null) {
+            validationErrors.push(`${key}: Value is required, but none was provided`);
+        }
+        else if (config.validate) {
+            // Cast validate to unknown because TS can't select one of multiple variants of the validate function signature
+            const validationRes = config.validate(value);
+            if (validationRes) {
+                validationErrors.push(`${key}: ${validationRes}`);
+            }
+        }
+        vars[key] = value;
+    }
+    if (validationErrors.length > 0) {
+        throw new Error(`Validation failed for the following variables:\n ${validationErrors.join('\n')}`);
+    }
+    return vars;
+};
+exports.buildAdapterConfig = buildAdapterConfig;
+const getEnv = (name, config) => {
+    const value = process.env[name];
+    if (!value) {
+        return null;
+    }
+    switch (config.type) {
+        case 'string':
+            return value;
+        case 'number':
+            return parseInt(value);
+        case 'boolean':
+            return value === 'true';
+        case 'enum':
+            if (!config.options?.includes(value)) {
+                throw new Error(`Env var "${name}" has value "${value}" which is not included in the valid options (${config.options})`);
+            }
+            return value;
+    }
+};

package/dist/src/config/provider-limits.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWSLimits = exports.getRateLimit = exports.getHTTPLimit = exports.DEFAULT_WS_SUBSCRIPTIONS = exports.DEFAULT_WS_CONNECTIONS = exports.BURST_UNDEFINED_QUOTA_MULTIPLE = exports.DEFAULT_MINUTE_RATE_LIMIT = void 0;
+const util_1 = require("../util");
+exports.DEFAULT_MINUTE_RATE_LIMIT = 60;
+exports.BURST_UNDEFINED_QUOTA_MULTIPLE = 2;
+exports.DEFAULT_WS_CONNECTIONS = 2;
+exports.DEFAULT_WS_SUBSCRIPTIONS = 10;
+const logger = (0, util_1.makeLogger)('ProviderLimits');
+const getHTTPLimit = (provider, limits, tier, timeframe) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'http');
+    return providerLimit?.[timeframe] || 0;
+};
+exports.getHTTPLimit = getHTTPLimit;
+const getRateLimit = (provider, limits, tier) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'http');
+    return calculateRateLimit(providerLimit);
+};
+exports.getRateLimit = getRateLimit;
+const getWSLimits = (provider, limits, tier) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'ws');
+    return calculateWSLimits(providerLimit);
+};
+exports.getWSLimits = getWSLimits;
+const getProviderLimits = (provider, limits, tier, protocol) => {
+    const providerConfig = parseLimits(limits);
+    if (!providerConfig) {
+        throw new Error(`Rate Limit: Provider: "${provider}" doesn't match any provider spec in limits.json`);
+    }
+    const protocolConfig = providerConfig[protocol];
+    if (!protocolConfig) {
+        throw new Error(`Rate Limit: "${provider}" doesn't have any configuration for ${protocol} in limits.json`);
+    }
+    let limitsConfig = protocolConfig[tier.toLowerCase()];
+    if (!limitsConfig) {
+        logger.debug(`Rate Limit: "${provider} does not have tier ${tier} defined. Falling back to lowest tier"`);
+        limitsConfig = Object.values(protocolConfig)?.[0];
+    }
+    if (!limitsConfig) {
+        throw new Error(`Rate Limit: Provider: "${provider}" has no tiers defined for ${protocol} in limits.json`);
+    }
+    return limitsConfig;
+};
+const parseLimits = (limits) => {
+    const _mapObject = (fn) => (o) => Object.fromEntries(Object.entries(o).map(fn));
+    const _formatProtocol = _mapObject((entry) => {
+        const [tierName, rest] = entry;
+        return [tierName.toLowerCase(), { ...rest }];
+    });
+    const _formatProvider = (ls) => {
+        const http = _formatProtocol(ls.http);
+        const ws = _formatProtocol(ls?.ws);
+        return { http, ws };
+    };
+    return _formatProvider(limits);
+};
+const calculateWSLimits = (providerLimit) => {
+    return {
+        connections: providerLimit.connections,
+        subscriptions: providerLimit.subscriptions,
+    };
+};
+const calculateRateLimit = (providerLimit) => {
+    let quota = providerLimit.rateLimit1m;
+    if (!quota && providerLimit?.rateLimit1h) {
+        quota = providerLimit?.rateLimit1h / 60;
+    }
+    else if (!quota && providerLimit?.rateLimit1s) {
+        quota = providerLimit?.rateLimit1s * 60;
+    }
+    return {
+        second: providerLimit?.rateLimit1s || (quota / 60) * exports.BURST_UNDEFINED_QUOTA_MULTIPLE,
+        minute: quota,
+    };
+};

package/dist/src/examples/bank-frick/accounts.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountsRestEndpoint = exports.BankFrickAccountsTransport = void 0;
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("./util");
+const util_2 = require("../../util");
+const error_1 = require("../../validation/error");
+const logger = (0, util_2.makeLogger)('BankFrickTransport');
+// Note: this is a shallow pattern that only checks for a country code since IBANs in the sandbox are invalid
+const ibanPattern = /^[A-Z]{2}[A-Z\d]{14,30}$/;
+const inputParameters = {
+    ibanIDs: {
+        description: 'The list of account ids included in the sum of balances',
+        required: true,
+        type: 'array',
+    },
+    signingAlgorithm: {
+        description: 'What signing algorithm is used to sign and verify authorization data, one of rsa-sha256, rsa-sha384, or rsa-sha512',
+        required: false,
+        type: 'string',
+        default: 'rsa-sha512',
+        options: ['rsa-sha256', 'rsa-sha384', 'rsa-sha512'],
+    },
+};
+// See here for all expected error returned by the API: https://developers.bankfrick.li/docs#errors
+const AuthErrors = {
+    401: 'No JWT token provided or token is invalid',
+    403: 'API key is invalid or any other condition is hindering the login', // Unclear if this is fatal or not
+};
+const FatalErrors = {
+    400: "Invalid parameters passed to Bank Frick's API",
+    423: "Authorization is valid, but the user's account is locked",
+};
+/**
+ * RestTransport implementation for Bank Frick, which has unusually complex requirements for an EA
+ * The RestTransport is generally built to make a single request and return a single response.
+ * This transport instead is used to fetch and process pages of data, and also requires a JWT to run
+ *
+ * This transport does all the heavy lifting in setup(), which is where the paging happens, and it
+ * also has complex retry logic that will attempt to refresh the JWT when certain HTTP errors occur
+ */
+class BankFrickAccountsTransport {
+    async initialize(dependencies) {
+        this.cache = dependencies.cache;
+    }
+    async hasBeenSetUp() {
+        return false; // Return false since we aren't coalescing requests
+    }
+    /**
+     * Creates an AxiosRequestConfig object for fetching a page of accounts from the Bank Frick API
+     */
+    prepareRequest(firstPosition, inputParams, config) {
+        const { API_ENDPOINT, BASE_URL, PAGE_SIZE } = config;
+        return {
+            baseURL: API_ENDPOINT + BASE_URL,
+            url: 'accounts',
+            method: 'GET',
+            params: {
+                firstPosition,
+                maxResults: PAGE_SIZE,
+            },
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        };
+    }
+    /**
+     * Request with retry logic for Bank Frick's API. In addition to standard retry logic, this function
+     * compares errors against expected errors from the Bank Frick API, and will throw without retries
+     * on a known fatal error, or try to refresh the JWT on a known auth error
+     **/
+    async makeRequest(axiosRequest, config, signingAlgorithm) {
+        let retryNumber = 0;
+        let response = await axios_1.default.request(axiosRequest);
+        while (response.status !== 200) {
+            retryNumber++;
+            logger.warn('Encountered error when fetching accounts from Bank Frick:', response.status, response.statusText);
+            // Evaluate whether the error was fatal, auth, or transient and whether we've exceeded the max number of retries.
+            // Throw on fatal, refresh token on auth error, pass on transient until we've exhausted our retries
+            if (FatalErrors[response.status]) {
+                throw new error_1.AdapterError({
+                    statusCode: response.status,
+                    message: response.statusText,
+                });
+            }
+            else if (AuthErrors[response.status]) {
+                // We've encountered a known auth error, so try to refresh the token before making another request
+                logger.info('Auth error received from the Bank Frick API, attempting to refresh the token');
+                this.token = await (0, util_1.generateJWT)(config, signingAlgorithm);
+            }
+            else if (retryNumber === config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES) {
+                throw new error_1.AdapterError({
+                    statusCode: 504,
+                    message: `Bank Frick transport hit the max number of retries (${config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES} retries) and aborted`,
+                });
+            }
+            logger.debug(`Sleeping for ${config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES}ms before retrying`);
+            await (0, util_2.sleep)(config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES);
+            response = await axios_1.default.request(axiosRequest);
+        }
+        return response;
+    }
+    validateInputParams(params) {
+        const encounteredIds = {};
+        const errors = [];
+        const { ibanIDs } = params;
+        ibanIDs.forEach((v) => {
+            if (!v.match(ibanPattern)) {
+                errors.push(`Invalid IBAN: ${v}`);
+            }
+            encounteredIds[v] += 1;
+            if (encounteredIds[v] > 1) {
+                errors.push(`The following IBAN appears more than once in the input parameters: ${v}`);
+            }
+        });
+        return errors;
+    }
+    /**
+     * Fetches pages of data from the Bank Frick API, scans for accounts by IBAN, and returns the balance
+     * of all found accounts. Returns a 404 if any IBAN isn't found.
+     */
+    async setup(req, config) {
+        const { ibanIDs, signingAlgorithm } = req.requestContext.data;
+        const { PAGE_SIZE = 500 } = config;
+        logger.debug(`Validating input: ${JSON.stringify(req.requestContext.data)}`);
+        // Scan ibanIDs for duplicates and invalid IBANs
+        const validationErrors = this.validateInputParams(req.requestContext.data);
+        if (validationErrors.length > 0) {
+            throw new error_1.AdapterError({
+                statusCode: 420,
+                message: `Received the following errors when validating inputParameters:\n ${validationErrors.join('\n')}`,
+            });
+        }
+        // Refresh the token if it isn't set
+        if (!this.token) {
+            this.token = await (0, util_1.generateJWT)(config, signingAlgorithm);
+        }
+        let sum = 0;
+        let position = 0;
+        const keys = ibanIDs;
+        logger.info("Fetching accounts from Bank Frick's API...");
+        while (keys.length > 0) {
+            // TODO Fetching and processing pages can be run concurrently
+            const axiosRequest = this.prepareRequest(position, req.requestContext.data, config);
+            const response = await this.makeRequest(axiosRequest, config, signingAlgorithm);
+            logger.debug(`Evaluating accounts from page ${position / PAGE_SIZE}`);
+            response.data.accounts.forEach((v) => {
+                logger.trace(`Evaluating ${v.account} (iban: ${v.iban}, type: ${v.type})`);
+                const index = ibanIDs.indexOf(v.iban);
+                if (index > -1) {
+                    keys.splice(index, 1);
+                    sum += v.balance;
+                    logger.trace(`Found account: ${v.account} (iban: ${v.iban}) with balance of ${v.balance}`);
+                    logger.trace(`Running sum: ${sum}, number of ibans left to find: ${keys.length}/${ibanIDs.length}`);
+                }
+            });
+            if (!response.data.moreResults) {
+                logger.debug('No more results, breaking out of account query loop');
+                break;
+            }
+            position += PAGE_SIZE || 0;
+        }
+        // 404 if one or more accounts were not found
+        if (keys.length > 0) {
+            logger.error(`Could not find all accounts, returning 404: ${keys.join(', ')}`);
+            const res = {
+                data: 0,
+                statusCode: 404,
+                result: 0,
+            };
+            await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE);
+        }
+        logger.debug('Was able to find all accounts, returning balance across all accounts: ', sum);
+        const res = {
+            data: sum,
+            statusCode: 200,
+            result: sum,
+        };
+        await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE);
+        return res;
+    }
+}
+exports.BankFrickAccountsTransport = BankFrickAccountsTransport;
+exports.accountsRestEndpoint = {
+    name: 'accounts',
+    transport: new BankFrickAccountsTransport(),
+    inputParameters,
+};

package/dist/src/examples/bank-frick/config/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customSettings = exports.signingAlgorithms = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("../../../util");
+const logger = (0, util_1.makeLogger)('BankFrickConfig');
+// Used for enum options and validation
+exports.signingAlgorithms = ['rsa-sha256', 'rsa-sha384', 'rsa-sha512'];
+const MAX_PAGE_SIZE = 500;
+exports.customSettings = {
+    PAGE_SIZE: {
+        description: 'The number of accounts to fetch per call to /accounts. Must be >= 1 and <= 500.',
+        type: 'enum',
+        required: false,
+        default: MAX_PAGE_SIZE.toString(),
+        options: [...Array(MAX_PAGE_SIZE).keys()].map((i) => (i + 1).toString()), // 1..MAX_PAGE_SIZE
+    },
+    PRIVATE_KEY: {
+        description: '',
+        type: 'string',
+        required: true,
+        validate: (value) => {
+            if (!value) {
+                return 'PRIVATE_KEY is a required variable, was undefined or empty';
+            }
+            else if (typeof value !== 'string') {
+                return `PRIVATE_KEY must be a string, was ${typeof value}`;
+            }
+            for (const algorithm of exports.signingAlgorithms) {
+                const body = { example: 123 };
+                try {
+                    crypto_1.default.sign(algorithm, Buffer.from(JSON.stringify(body)), value);
+                    return ''; // Any successful sign means the key is valid
+                }
+                catch {
+                    logger.debug(`Failed to sign a dummy body using PRIVATE_KEY with algorithm ${algorithm}`);
+                }
+            }
+            return `PRIVATE_KEY could not be used to sign a dummy body using any of ${exports.signingAlgorithms}`;
+        },
+    },
+};

package/dist/src/examples/bank-frick/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const accounts_1 = require("./accounts");
+const config_1 = require("./config");
+exports.adapter = {
+    name: 'bank-frick',
+    defaultEndpoint: 'accounts',
+    endpoints: [accounts_1.accountsRestEndpoint],
+    customSettings: config_1.customSettings,
+    envDefaultOverrides: {
+        API_ENDPOINT: 'https://olbsandbox.bankfrick.li/webapi/v2',
+    },
+};