@chainlink/external-adapter-framework 0.0.10 → 0.0.14

package/adapter.d.ts

@@ -1,7 +1,26 @@
-import { AdapterConfig, BaseAdapterConfig, SettingsMap } from './config';
-import { AdapterRateLimitTier } from './rate-limiting';
-import { AdapterDependencies, Transport } from './transports';
+import { Cache } from './cache';
+import { AdapterConfig, BaseAdapterConfig, CustomSettingsType, SettingsMap } from './config';
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, RequestRateLimiter } from './rate-limiting';
+import { Transport } from './transports';
+import { SubscriptionSetFactory } from './util';
 import { InputParameters } from './validation/input-params';
+/**
+ * Dependencies that will be injected into the Adapter on startup
+ */
+export interface AdapterDependencies {
+    cache: Cache;
+    requestRateLimiter: RequestRateLimiter;
+    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
+    subscriptionSetFactory: SubscriptionSetFactory;
+}
+/**
+ * Context that will be used on background executions of a Transport.
+ * For example, the endpointName used to log statements or generate Cache keys.
+ */
+export interface AdapterContext<CustomSettings extends CustomSettingsType<CustomSettings> = SettingsMap> {
+    adapterEndpoint: AdapterEndpoint;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}
 /**
  * Structure to describe rate limits specs for the Adapter
  */

package/adapter.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeAdapter = exports.initializeDependencies = void 0;
-const factory_1 = require("./cache/factory");
+const cache_1 = require("./cache");
 const rate_limiting_1 = require("./rate-limiting");
 const util_1 = require("./util");
 const logger = (0, util_1.makeLogger)('Adapter');
@@ -47,7 +47,7 @@ const calculateRateLimitAllocations = (adapter) => {
 const initializeDependencies = (adapter, config, inputDependencies) => {
     const dependencies = inputDependencies || {};
     if (!dependencies.cache) {
-        dependencies.cache = factory_1.CacheFactory.buildCache(config);
+        dependencies.cache = cache_1.CacheFactory.buildCache(config);
     }
     // In the future we might want something more complex, but for now it's better to simplify
     // and just use the same rate limiting for everything. Once we have a more complex use case we
@@ -59,6 +59,9 @@ const initializeDependencies = (adapter, config, inputDependencies) => {
     if (!dependencies.backgroundExecuteRateLimiter) {
         dependencies.backgroundExecuteRateLimiter = new rate_limiting_1.FixedFrequencyRateLimiter().initialize(adapter.endpoints, rateLimitingTier);
     }
+    if (!dependencies.subscriptionSetFactory) {
+        dependencies.subscriptionSetFactory = new util_1.SubscriptionSetFactory(config);
+    }
     return dependencies;
 };
 exports.initializeDependencies = initializeDependencies;

package/cache/factory.js

@@ -48,8 +48,6 @@ class CacheFactory {
             redis.on('connect', () => {
                 cacheMetrics.redisConnectionsOpen.inc();
             });
-            // TODO: Maybe track active redis connections instead of just total count of connections created
-            // Use a Gauge and track with a combo of connect/end events listeners
             return new redis_1.RedisCache(redis);
         }
     }

package/cache/index.d.ts

@@ -3,6 +3,7 @@ import { AdapterConfig } from '../config';
 import { AdapterMiddlewareBuilder, AdapterResponse, sleep } from '../util';
 export * from './local';
 export * from './redis';
+export * from './factory';
 /**
  * An object describing an entry in the cache.
  * @typeParam T - the type of the entry's value
@@ -52,7 +53,10 @@ export declare const calculateCacheKey: ({ adapterEndpoint, adapterConfig, }: {
     adapterEndpoint: AdapterEndpoint;
     adapterConfig: AdapterConfig;
 }, data: unknown) => string;
-export declare const calculateFeedId: (adapterEndpoint: AdapterEndpoint, data: unknown) => string;
+export declare const calculateFeedId: ({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint;
+    adapterConfig: AdapterConfig;
+}, data: unknown) => string;
 /**
  * Calculates a unique key from the provided data.
  *
@@ -66,7 +70,7 @@ export declare const calculateFeedId: (adapterEndpoint: AdapterEndpoint, data: u
  * // equals `|base:eth|quote:btc`
  * ```
  */
-export declare const calculateKey: (data: unknown, paramNames: string[]) => string;
+export declare const calculateKey: (data: unknown, paramNames: string[], adapterConfig: AdapterConfig) => string;
 /**
  * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
  * amount of retries is exceeded, it returns undefined instead.

package/cache/index.js

@@ -31,6 +31,7 @@ const util_1 = require("../util");
 const cacheMetrics = __importStar(require("./metrics"));
 __exportStar(require("./local"), exports);
 __exportStar(require("./redis"), exports);
+__exportStar(require("./factory"), exports);
 const logger = (0, util_1.makeLogger)('Cache');
 // Uses calculateKey to generate a unique key from the endpoint name, data, and input parameters
 const calculateCacheKey = ({ adapterEndpoint, adapterConfig, }, data) => {
@@ -39,16 +40,16 @@ const calculateCacheKey = ({ adapterEndpoint, adapterConfig, }, data) => {
         logger.trace(`Using default cache key ${adapterConfig.DEFAULT_CACHE_KEY}`);
         return adapterConfig.DEFAULT_CACHE_KEY;
     }
-    return `${adapterEndpoint.name}-${(0, exports.calculateKey)(data, paramNames)}`;
+    return `${adapterEndpoint.name}-${(0, exports.calculateKey)(data, paramNames, adapterConfig)}`;
 };
 exports.calculateCacheKey = calculateCacheKey;
-const calculateFeedId = (adapterEndpoint, data) => {
+const calculateFeedId = ({ adapterEndpoint, adapterConfig, }, data) => {
     const paramNames = Object.keys(adapterEndpoint.inputParameters);
     if (paramNames.length === 0) {
         logger.trace(`Cannot generate Feed ID without input parameters`);
         return 'N/A';
     }
-    return (0, exports.calculateKey)(data, paramNames);
+    return (0, exports.calculateKey)(data, paramNames, adapterConfig);
 };
 exports.calculateFeedId = calculateFeedId;
 /**
@@ -64,15 +65,14 @@ exports.calculateFeedId = calculateFeedId;
  * // equals `|base:eth|quote:btc`
  * ```
  */
-const calculateKey = (data, paramNames) => {
+const calculateKey = (data, paramNames, adapterConfig) => {
     if (data && typeof data !== 'object') {
         throw new Error('Data to calculate cache key should be an object');
     }
     const params = data;
-    let cacheKey = ''; // TODO: Maybe there's a faster String Builder
+    let cacheKey = '';
     for (const paramName of paramNames) {
         // Ignore overrides param when generating cache keys
-        // TODO: expand support for ignoring `includes` and `tokenOverrides` params when generating keys
         if (paramName === 'overrides') {
             continue;
         }
@@ -90,11 +90,15 @@ const calculateKey = (data, paramNames) => {
                 cacheKey += param.toString();
                 break;
             case 'object':
-                // TODO: Implement object sorting for deterministic cache key generation
-                cacheKey += JSON.stringify(param);
+                // Force cache keys to only use performant properties of the input params.
+                // If the object were to be used, we'd have to sort its properties.
+                logger.debug(`Property "${paramName}" in request parameters is of type object, and won't be used in the cacheKey`);
         }
     }
-    // TODO: Check max size, potential issue
+    if (cacheKey.length > adapterConfig.MAX_COMMON_KEY_SIZE) {
+        logger.warn(`Generated cache key for adapter request is bigger than the MAX_COMMON_KEY_SIZE and will be truncated`);
+        cacheKey = cacheKey.slice(0, adapterConfig.MAX_COMMON_KEY_SIZE);
+    }
     logger.trace(`Generated cache key for request: "${cacheKey}"`);
     return cacheKey;
 };

package/cache/redis.js

@@ -33,7 +33,6 @@ const logger = (0, util_1.makeLogger)('RedisCache');
  *
  * @typeParam T - the type for the entries' values
  */
-// TODO: Add error handling for redis command failures
 class RedisCache {
     constructor(client) {
         this.client = client;
@@ -49,7 +48,7 @@ class RedisCache {
             logger.debug(`No entry in redis cache for key "${key}", returning undefined`);
             return undefined;
         }
-        return JSON.parse(value); // TODO: Check for invalid parsing
+        return JSON.parse(value);
     }
     async delete(key) {
         logger.trace(`Deleting key ${key}`);
@@ -61,7 +60,6 @@ class RedisCache {
     }
     async set(key, value, ttl) {
         logger.trace(`Setting key ${key}`);
-        // TODO: Check for invalid stringify
         await this.client.set(key, JSON.stringify(value), 'PX', ttl);
         // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
         const feedId = value.meta?.metrics?.feedId;
@@ -81,7 +79,10 @@ class RedisCache {
         let chain = this.client.multi();
         for (const entry of entries) {
             chain = chain.set(entry.key, JSON.stringify(entry.value), 'PX', ttl);
-            // TODO: Move to after error handling once implemented to avoid recording cache sets that failed
+        }
+        await chain.exec();
+        // Loop again, but this time to record these in metrics
+        for (const entry of entries) {
             // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
             const feedId = entry.value.meta?.metrics?.feedId;
             if (feedId) {
@@ -90,7 +91,6 @@ class RedisCache {
                 cacheMetrics.cacheSet(label, ttl);
             }
         }
-        await chain.exec();
         // Record setMany command sent to Redis
         cacheMetrics.redisCommandsSentCount
             .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'exec' })

package/config/index.d.ts

@@ -1,4 +1,8 @@
 export declare const BaseSettings: {
+    readonly API_ENDPOINT: {
+        readonly description: "The URL that the certain transports use to retrieve data";
+        readonly type: "string";
+    };
     readonly API_KEY: {
         readonly description: "Default setting for an EA key";
         readonly type: "string";
@@ -73,7 +77,7 @@ export declare const BaseSettings: {
     };
     readonly WARMUP_SUBSCRIPTION_TTL: {
         readonly type: "number";
-        readonly description: "";
+        readonly description: "TTL for batch warmer subscriptions";
         readonly default: 10000;
     };
     readonly CACHE_POLLING_MAX_RETRIES: {
@@ -112,6 +116,16 @@ export declare const BaseSettings: {
         readonly type: "number";
         readonly default: 400;
     };
+    readonly MAX_COMMON_KEY_SIZE: {
+        readonly description: "Maximum amount of characters that the common part of the cache key or feed ID can have";
+        readonly type: "number";
+        readonly default: 300;
+        readonly validate: (value?: number) => "MAX_COMMON_KEY_SIZE must be a number between 150 and 500" | undefined;
+    };
+    readonly SMOKE_TEST_PAYLOAD_FILE_NAME: {
+        readonly description: "Name of the test payload file used for the smoke endpoint";
+        readonly type: "string";
+    };
 };
 export declare const buildAdapterConfig: <CustomSettings extends CustomSettingsType<CustomSettings> = EmptySettings>({ overrides, customSettings, }: {
     overrides?: Partial<BaseAdapterConfig> | undefined;

package/config/index.js

@@ -5,9 +5,10 @@ exports.buildAdapterConfig = exports.BaseSettings = void 0;
 exports.BaseSettings = {
     // V2 compat
     // TODO: Remove non used in v3 ones
-    // API_ENDPOINT: {
-    //   type: 'string',
-    // },
+    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',
@@ -214,7 +215,7 @@ exports.BaseSettings = {
     // },
     WARMUP_SUBSCRIPTION_TTL: {
         type: 'number',
-        description: '',
+        description: 'TTL for batch warmer subscriptions',
         default: 10000,
     },
     // WARMUP_UNHEALTHY_THRESHOLD: {
@@ -306,10 +307,24 @@ exports.BaseSettings = {
         type: 'number',
         default: 400,
     },
+    MAX_COMMON_KEY_SIZE: {
+        description: 'Maximum amount of characters that the common part of the cache key or feed ID can have',
+        type: 'number',
+        default: 300,
+        validate: (value) => {
+            if (!(value && value >= 150 && value <= 500)) {
+                return 'MAX_COMMON_KEY_SIZE must be a number between 150 and 500';
+            }
+        },
+    },
     // CACHE_KEY_IGNORED_PROPS : {
     //   description: 'Properties to ignore when generating a feed ID for requests',
     //   type: 'string'
     // }
+    SMOKE_TEST_PAYLOAD_FILE_NAME: {
+        description: 'Name of the test payload file used for the smoke endpoint',
+        type: 'string',
+    },
 };
 const buildAdapterConfig = ({ overrides = {}, customSettings = {}, }) => {
     const validationErrors = [];

package/config/provider-limits.js

@@ -42,7 +42,11 @@ const getProviderLimits = (provider, limits, tier, protocol) => {
     return limitsConfig;
 };
 const parseLimits = (limits) => {
-    const _mapObject = (fn) => (o) => Object.fromEntries([]);
+    const _mapObject = (fn) => (o) => {
+        const entries = Object.entries(o);
+        const mapped = entries.map(fn);
+        return Object.fromEntries(mapped);
+    };
     const _formatProtocol = _mapObject((entry) => {
         const [tierName, rest] = entry;
         return [tierName.toLowerCase(), { ...rest }];

package/examples/bank-frick/accounts.d.ts

@@ -0,0 +1,39 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { AdapterInputParameters, BankFrickAccountsRequestSchema, BankFrickAccountsResponseSchema, SigningAlgorithm } from './types';
+import { customSettings } from './config';
+import { Transport } from '../../transports';
+import { AdapterRequest, AdapterResponse } from '../../util';
+import { AdapterConfig } from '../../config';
+import { Cache } from '../../cache';
+import { AdapterDependencies, AdapterEndpoint } from '../../adapter';
+/**
+ * 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
+ */
+export declare class BankFrickAccountsTransport implements Transport<AdapterInputParameters, number, typeof customSettings> {
+    token: string;
+    cache: Cache;
+    initialize(dependencies: AdapterDependencies): Promise<void>;
+    hasBeenSetUp(): Promise<boolean>;
+    /**
+     * Creates an AxiosRequestConfig object for fetching a page of accounts from the Bank Frick API
+     */
+    prepareRequest(firstPosition: number, inputParams: AdapterInputParameters, config: AdapterConfig<typeof customSettings>): AxiosRequestConfig<BankFrickAccountsRequestSchema>;
+    /**
+     * 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
+     **/
+    makeRequest(axiosRequest: AxiosRequestConfig<BankFrickAccountsRequestSchema>, config: AdapterConfig<typeof customSettings>, signingAlgorithm?: SigningAlgorithm): Promise<AxiosResponse<BankFrickAccountsResponseSchema>>;
+    validateInputParams(params: AdapterInputParameters): string[];
+    /**
+     * 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.
+     */
+    setup(req: AdapterRequest<AdapterInputParameters>, config: AdapterConfig<typeof customSettings>): Promise<AdapterResponse<number>>;
+}
+export declare const accountsRestEndpoint: AdapterEndpoint;

package/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/examples/bank-frick/config/index.d.ts

@@ -0,0 +1,4 @@
+import { SettingsMap } from '../../../config';
+import { SigningAlgorithm } from '../types';
+export declare const signingAlgorithms: SigningAlgorithm[];
+export declare const customSettings: SettingsMap;

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

@@ -0,0 +1,54 @@
+"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: 'number',
+        required: false,
+        default: MAX_PAGE_SIZE,
+        validate: (value) => {
+            if (!value) {
+                return '';
+            }
+            else if (value < 1) {
+                return `PAGE_SIZE must be at least >= 1, was ${value}`;
+            }
+            else if (value > MAX_PAGE_SIZE) {
+                return `PAGE_SIZE must be <= 500, was ${value}`;
+            }
+        },
+    },
+    PRIVATE_KEY: {
+        description: '',
+        type: 'string',
+        required: true,
+        validate: (value) => {
+            const failedAlgos = [];
+            for (const algorithm of exports.signingAlgorithms) {
+                const body = { example: 123 };
+                try {
+                    crypto_1.default.sign(algorithm, Buffer.from(JSON.stringify(body)), value);
+                    logger.trace("Successfully tested PRIVATE_KEY by signing with algorithm '%s'", algorithm);
+                }
+                catch {
+                    logger.trace("PRIVATE_KEY failed to sign message with algorithm '%s'", algorithm);
+                    failedAlgos.push(algorithm);
+                }
+            }
+            if (failedAlgos.length > 0) {
+                return `Failed to sign a dummy body using $PRIVATE_KEY with the following algorithms ${failedAlgos.join(',')}`;
+            }
+            logger.debug('$PRIVATE_KEY successfully signed a dummy body with all supported algorithms');
+        },
+    },
+};

package/examples/bank-frick/index.d.ts

@@ -0,0 +1,2 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter;

package/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',
+    },
+};

package/examples/bank-frick/util.d.ts

@@ -0,0 +1,4 @@
+import { SigningAlgorithm } from './types';
+import { customSettings } from './config';
+import { AdapterConfig } from '../../config';
+export declare const generateJWT: (config: AdapterConfig<typeof customSettings>, signingAlgorithm?: SigningAlgorithm) => Promise<string>;