@chainlink/external-adapter-framework 0.0.10 → 0.0.12

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

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

package/dist/src/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>;

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJWT = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("../../util");
+const logger = (0, util_1.makeLogger)('BankFrickUtil');
+// Used by all endpoints requiring authentication
+const generateJWT = async (config, signingAlgorithm = 'rsa-sha512') => {
+    logger.info("Generating a new JWT because we don't have one in config.token");
+    const { API_KEY, PRIVATE_KEY, API_ENDPOINT } = config;
+    // All of these are required, so validation should have failed prior to this line
+    if (!API_KEY || !PRIVATE_KEY) {
+        throw new Error('API_KEY, PRIVATE_KEY, and PASSWORD all must be defined to get a new token\n' +
+            'Received:  \n' +
+            `API_KEY: ${API_KEY}\n` +
+            `PRIVATE_KEY: ${PRIVATE_KEY}`);
+    }
+    const data = {
+        key: API_KEY,
+    };
+    const signature = crypto_1.default.sign(signingAlgorithm, Buffer.from(JSON.stringify(data)), PRIVATE_KEY);
+    const options = {
+        method: 'POST',
+        baseURL: API_ENDPOINT,
+        url: `authorize`,
+        headers: {
+            Signature: signature.toString('base64'),
+            algorithm: signingAlgorithm,
+        },
+        data,
+    };
+    const response = await axios_1.default.request(options);
+    return response.data.token;
+};
+exports.generateJWT = generateJWT;

package/dist/src/examples/coingecko/batch-warming.d.ts

@@ -0,0 +1,7 @@
+import { AdapterEndpoint } from '../../adapter';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+export declare const batchEndpoint: AdapterEndpoint<AdapterRequestParams, unknown, import("../../config").SettingsMap>;
+export {};

package/dist/src/examples/coingecko/batch-warming.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("../../transports/batch-warming");
+const DEFAULT_URL = 'https://pro-api.coingecko.com/api/v3';
+const inputParameters = {
+    coinid: {
+        description: 'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol or array of symbols of the currency to query',
+        required: true,
+    },
+    quote: {
+        aliases: ['to', 'market'],
+        description: 'The symbol of the currency to convert to',
+        required: true,
+    },
+};
+const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
+    prepareRequest: (params, context) => {
+        return {
+            baseURL: DEFAULT_URL,
+            url: '/simple/price',
+            method: 'GET',
+            params: {
+                ids: [...new Set(params.map((p) => p.base))].join(','),
+                vs_currencies: [...new Set(params.map((p) => p.quote))].join(','),
+                x_cg_pro_api_key: context.adapterConfig.API_KEY,
+            },
+        };
+    },
+    parseResponse: (res) => {
+        const entries = [];
+        for (const [base, entry] of Object.entries(res.data)) {
+            for (const [quote, price] of Object.entries(entry)) {
+                entries.push({
+                    params: { base, quote },
+                    value: price,
+                });
+            }
+        }
+        return entries;
+    },
+});
+exports.batchEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'batch',
+    transport: batchEndpointTransport,
+    inputParameters,
+});

package/dist/src/examples/coingecko/index.d.ts

@@ -0,0 +1,2 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter<import("../../config").SettingsMap>;

package/dist/src/examples/coingecko/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("./batch-warming");
+const rest_1 = require("./rest");
+exports.adapter = new adapter_1.Adapter({
+    name: 'coingecko',
+    defaultEndpoint: 'batch',
+    endpoints: [rest_1.restEndpoint, batch_warming_1.batchEndpoint],
+});

package/dist/src/examples/coingecko/rest.d.ts

@@ -0,0 +1,12 @@
+import { AdapterEndpoint } from '../../adapter';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+interface ProviderResponseBody {
+    [base: string]: {
+        [quote: string]: number;
+    };
+}
+export declare const restEndpoint: AdapterEndpoint<AdapterRequestParams, ProviderResponseBody, import("../../config").SettingsMap>;
+export {};

package/dist/src/examples/coingecko/rest.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const transports_1 = require("../../transports");
+const DEFAULT_URL = 'https://api.coingecko.com/api/v3';
+const inputParameters = {
+    coinid: {
+        description: 'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol or array of symbols of the currency to query',
+        required: true,
+    },
+    quote: {
+        aliases: ['to', 'market'],
+        description: 'The symbol of the currency to convert to',
+        required: true,
+    },
+};
+const restEndpointTransport = new transports_1.RestTransport({
+    prepareRequest: (req) => {
+        return {
+            baseURL: DEFAULT_URL,
+            url: '/simple/price',
+            method: 'GET',
+            params: {
+                ids: req.requestContext.data.base,
+                vs_currencies: req.requestContext.data.quote,
+            },
+        };
+    },
+    parseResponse: (req, res) => {
+        return {
+            data: res.data,
+            statusCode: 200,
+            result: res.data[req.requestContext.data.base]?.[req.requestContext.data.quote],
+        };
+    },
+    options: {
+        coalescing: true,
+    },
+});
+exports.restEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'rest',
+    aliases: ['qwe'],
+    transport: restEndpointTransport,
+    inputParameters,
+});

package/dist/src/examples/ncfx/index.d.ts

@@ -0,0 +1,13 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter<{
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;

package/dist/src/examples/ncfx/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const config_1 = require("./config");
+const websocket_1 = require("./websocket");
+exports.adapter = new adapter_1.Adapter({
+    name: 'ncfx',
+    endpoints: [websocket_1.webSocketEndpoint],
+    customSettings: config_1.customSettings,
+});

package/dist/src/examples/ncfx/websocket.d.ts

@@ -0,0 +1,47 @@
+import { AdapterEndpoint } from '../../adapter';
+import { WebSocketTransport } from '../../transports/websocket';
+import { InputParameters } from '../../validation';
+interface AdapterRequestParams {
+    base: string;
+    quote: string;
+}
+export declare const inputParameters: InputParameters;
+interface ProviderMessage {
+    timestamp: string;
+    currencyPair: string;
+    bid: number;
+    offer: number;
+    mid: number;
+    changes: [
+        {
+            period: string;
+            change: number;
+            percentage: number;
+        }
+    ];
+}
+export declare const websocketTransport: WebSocketTransport<AdapterRequestParams, ProviderMessage[], {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;
+export declare const webSocketEndpoint: AdapterEndpoint<AdapterRequestParams, unknown, {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+}>;
+export {};

package/dist/src/examples/ncfx/websocket.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSocketEndpoint = exports.websocketTransport = exports.inputParameters = void 0;
+const adapter_1 = require("../../adapter");
+const websocket_1 = require("../../transports/websocket");
+const util_1 = require("../../util");
+exports.inputParameters = {
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol of the currency to query',
+        required: true,
+    },
+    quote: {
+        aliases: ['to', 'market'],
+        description: 'The symbol of the currency to convert to',
+        required: true,
+    },
+};
+const logger = (0, util_1.makeLogger)('NcfxWebSocketTransport');
+exports.websocketTransport = new websocket_1.WebSocketTransport({
+    url: 'wss://feed.newchangefx.com/cryptodata',
+    handlers: {
+        open(connection, context) {
+            return new Promise((resolve, reject) => {
+                // Set up listener
+                connection.on('message', (data) => {
+                    const parsed = JSON.parse(data.toString());
+                    if (parsed.Message?.startsWith('Logged in as user')) {
+                        logger.info('Got logged in response, connection is ready');
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Unexpected message after WS connection open'));
+                    }
+                });
+                // Send login payload
+                connection.send(JSON.stringify({
+                    request: 'login',
+                    username: context.adapterConfig.USERNAME,
+                    password: context.adapterConfig.PASSWORD,
+                }));
+            });
+        },
+        message(message) {
+            if (!Array.isArray(message)) {
+                logger.debug('WS message is not array, skipping');
+                return [];
+            }
+            return message.map((m) => {
+                const [base, quote] = m.currencyPair.split('/');
+                return {
+                    params: { base, quote },
+                    value: m.offer,
+                };
+            });
+        },
+    },
+    builders: {
+        subscribeMessage: (params) => ({
+            request: 'subscribe',
+            ccy: `${params.base}/${params.quote}`,
+        }),
+        unsubscribeMessage: (params) => ({
+            request: 'unsubscribe',
+            ccy: `${params.base}/${params.quote}`,
+        }),
+    },
+});
+exports.webSocketEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'websocket',
+    transport: exports.websocketTransport,
+    inputParameters: exports.inputParameters,
+});

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+import { Server } from 'http';
+import { Adapter, AdapterDependencies } from './adapter';
+/**
+ * Main function for the framework.
+ * Initializes config and dependencies, uses those to initialize Transports, and starts listening for requests.
+ *
+ * @param adapter - an object describing an External Adapter
+ * @param dependencies - an optional object with adapter dependencies to inject
+ * @returns a Promise that resolves to the http.Server listening for connections
+ */
+export declare const expose: (adapter: Adapter, dependencies?: Partial<AdapterDependencies>) => Promise<Server | undefined>;

package/dist/src/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const background_executor_1 = require("./background-executor");
+const cache_1 = require("./cache");
+const metrics_1 = require("./metrics");
+const transports_1 = require("./transports");
+const util_1 = require("./util");
+const test_payload_loader_1 = require("./util/test-payload-loader");
+const validation_1 = require("./validation");
+const logger = (0, util_1.makeLogger)('Main');
+const VERSION = process.env['npm_package_version'];
+/**
+ * Main function for the framework.
+ * Initializes config and dependencies, uses those to initialize Transports, and starts listening for requests.
+ *
+ * @param adapter - an object describing an External Adapter
+ * @param dependencies - an optional object with adapter dependencies to inject
+ * @returns a Promise that resolves to the http.Server listening for connections
+ */
+const expose = async (adapter, dependencies) => {
+    // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
+    await adapter.initialize(dependencies);
+    let server = undefined;
+    if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+        (0, metrics_1.setupMetricsServer)(adapter.name, adapter.config);
+    }
+    if (adapter.config.EA_MODE === 'reader' || adapter.config.EA_MODE === 'reader-writer') {
+        // Main REST API server to handle incoming requests
+        const app = await buildRestApi(adapter);
+        // Start listening for incoming requests
+        try {
+            await app.listen(adapter.config.EA_PORT, adapter.config.EA_HOST);
+        }
+        catch (err) {
+            logger.fatal(`There was an error when starting the EA server: ${err}`);
+            process.exit();
+        }
+        logger.info(`Listening on port ${app.server.address().port}`);
+        server = app.server;
+    }
+    else {
+        logger.info('REST API is disabled; this instance will not process incoming requests.');
+    }
+    if (adapter.config.EA_MODE === 'writer' || adapter.config.EA_MODE === 'reader-writer') {
+        // Start background loop that will take care of calling any async Transports
+        logger.info('Starting background execution loop');
+        (0, background_executor_1.callBackgroundExecutes)(adapter, server);
+    }
+    else {
+        logger.info('Background executor is disabled; this instance will not perform async background executes.');
+    }
+    return server;
+};
+exports.expose = expose;
+async function buildRestApi(adapter) {
+    const { config } = adapter;
+    const app = (0, fastify_1.default)();
+    // Add healthcheck endpoint before middlewares to bypass them
+    app.get((0, path_1.join)(config.BASE_URL, 'health'), (req, res) => {
+        res.status(200).send({ message: 'OK', version: VERSION });
+    });
+    // Use global error handling
+    app.setErrorHandler(validation_1.errorCatchingMiddleware);
+    const transportHandler = await (0, transports_1.buildTransportHandler)(adapter);
+    app.register(async (router) => {
+        // Set up "middlewares" (hooks in fastify)
+        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(adapter));
+        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(adapter));
+        if (config['CORRELATION_ID_ENABLED']) {
+            router.addHook('onRequest', util_1.loggingContextMiddleware);
+        }
+        router.route({
+            url: config.BASE_URL,
+            method: 'POST',
+            handler: transportHandler,
+        });
+        if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
+            router.addHook('onResponse', metrics_1.buildMetricsMiddleware);
+        }
+    });
+    // Add smoke endpoint after middleware which are needed for tests
+    buildSmokeEndpoint(app, config);
+    return app;
+}
+/**
+ * Adds the /smoke endpoint to the API for smoke testing the adapter
+ *
+ * @param app - the Fastify instance
+ * @param config - the initialized adapter config
+ */
+function buildSmokeEndpoint(app, config) {
+    const testPayload = (0, test_payload_loader_1.loadTestPayload)(config.SMOKE_TEST_PAYLOAD_FILE_NAME);
+    app.get((0, path_1.join)(config.BASE_URL, 'smoke'), async (_, res) => {
+        if (testPayload.isDefault) {
+            return res.status(200).send('OK');
+        }
+        const errors = [];
+        for (const index in testPayload.requests) {
+            try {
+                const request = { id: index, data: testPayload.requests[index] };
+                // Use Fastify's app inject to pass smoke requests internally
+                const response = await app.inject({
+                    method: 'POST',
+                    url: '/',
+                    payload: request,
+                });
+                const parsedResponse = JSON.parse(response.body);
+                // Throw error if not 2xx status code
+                if (parsedResponse.statusCode < 200 || parsedResponse.statusCode > 299) {
+                    throw Error('Smoke test request failed');
+                }
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        if (errors.length > 0) {
+            return res.status(500).send(errors);
+        }
+        return res.status(200).send('OK');
+    });
+}

package/dist/src/metrics/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequestDurationSeconds = exports.httpRequestsTotal = exports.buildMetricsMiddleware = exports.setupMetrics = exports.setupMetricsServer = void 0;
+const client = __importStar(require("prom-client"));
+const constants_1 = require("./constants");
+const util_1 = require("../util");
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const error_1 = require("../validation/error");
+const logger = (0, util_1.makeLogger)('Metrics');
+function setupMetricsServer(name, config) {
+    const metricsApp = (0, fastify_1.default)({
+        logger: false,
+    });
+    const metricsPort = config.METRICS_PORT;
+    const endpoint = config.METRICS_USE_BASE_URL ? (0, path_1.join)(config.BASE_URL, 'metrics') : '/metrics';
+    const eaHost = config.EA_HOST;
+    (0, exports.setupMetrics)(name, config);
+    metricsApp.get(endpoint, async (_, res) => {
+        res.type('txt');
+        res.send(await client.register.metrics());
+    });
+    metricsApp.listen(metricsPort, eaHost, () => logger.info(`Monitoring listening on port ${metricsPort}!`));
+}
+exports.setupMetricsServer = setupMetricsServer;
+const setupMetrics = (name, config) => {
+    client.collectDefaultMetrics();
+    client.register.setDefaultLabels({
+        app_name: config.METRICS_NAME || name || 'N/A',
+        app_version: config['npm_package_version'],
+    });
+};
+exports.setupMetrics = setupMetrics;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+const buildMetricsMiddleware = (req, res, done) => {
+    const feedId = req.requestContext.meta?.metrics?.feedId || 'N/A';
+    const labels = buildHttpRequestMetricsLabel(feedId, req.requestContext.meta?.error, req.requestContext.meta?.metrics?.cacheHit);
+    // Record number of requests sent to EA
+    exports.httpRequestsTotal.labels(labels).inc();
+    // Record response time of request through entire EA
+    exports.httpRequestDurationSeconds.observe(res.getResponseTime());
+    logger.debug(`Response time for ${feedId}: ${res.getResponseTime()}ms`);
+    done();
+};
+exports.buildMetricsMiddleware = buildMetricsMiddleware;
+const buildHttpRequestMetricsLabel = (feedId, error, cacheHit) => {
+    const labels = {};
+    labels.method = 'POST';
+    labels.feed_id = feedId;
+    if (error instanceof error_1.AdapterError) {
+        // If error present and an instace of AdapterError, build label from error info
+        labels.type = error?.metricsLabel || constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = error?.statusCode;
+        labels.provider_status_code = error?.providerStatusCode;
+    }
+    else if (error instanceof Error) {
+        // If error present and not instance of generic Error, unexpected failure occurred
+        labels.type = constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = 500;
+    }
+    else {
+        // If no error present, request went as expected
+        labels.status_code = 200;
+        if (cacheHit) {
+            labels.type = constants_1.HttpRequestType.CACHE_HIT;
+        }
+        else {
+            labels.type = constants_1.HttpRequestType.DATA_PROVIDER_HIT;
+            labels.provider_status_code = 200;
+        }
+    }
+    return labels;
+};
+exports.httpRequestsTotal = new client.Counter({
+    name: 'http_requests_total',
+    help: 'The number of http requests this external adapter has serviced for its entire uptime',
+    labelNames: [
+        'method',
+        'status_code',
+        'retry',
+        'type',
+        'is_cache_warming',
+        'feed_id',
+        'provider_status_code',
+    ],
+});
+exports.httpRequestDurationSeconds = new client.Histogram({
+    name: 'http_request_duration_seconds',
+    help: 'A histogram bucket of the distribution of http request durations',
+    buckets: constants_1.requestDurationBuckets,
+});

package/dist/src/metrics/util.d.ts

@@ -0,0 +1,7 @@
+import { AdapterMetricsMeta, AdapterRequestData } from '../util';
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig, SettingsMap } from '../config';
+export declare const getMetricsMeta: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: AdapterRequestData) => AdapterMetricsMeta;

package/dist/src/metrics/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricsMeta = void 0;
+const cache_1 = require("../cache");
+const getMetricsMeta = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const feedId = (0, cache_1.calculateFeedId)({ adapterEndpoint, adapterConfig }, data);
+    return { feedId };
+};
+exports.getMetricsMeta = getMetricsMeta;