@api3/commons 0.1.0 → 0.2.0

package/dist/processing/unsafe-evaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-evaluate.js","sourceRoot":"","sources":["../../src/processing/unsafe-evaluate.ts"],"names":[],"mappings":"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"}

package/dist/processing/vm-timers.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Timers (setTimeout, setInterval) do not work in Node.js vm, see: https://github.com/nodejs/help/issues/1875
+ *
+ * The API is wrapped in a "create" function so that every processing snippet keeps track of its timers and properly
+ * cleans them up after use.
+ */
+export declare const createTimers: () => {
+    customSetTimeout: (fn: () => void, ms: number) => void;
+    customClearTimeout: (id: NodeJS.Timeout) => void;
+    clearAllTimeouts: () => void;
+    customSetInterval: (fn: () => void, ms: number) => void;
+    customClearInterval: (id: NodeJS.Timeout) => void;
+    clearAllIntervals: () => void;
+    clearAll: () => void;
+};
+//# sourceMappingURL=vm-timers.d.ts.map

package/dist/processing/vm-timers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm-timers.d.ts","sourceRoot":"","sources":["../../src/processing/vm-timers.ts"],"names":[],"mappings":";;;;;AAAA;;;;;GAKG;AACH,eAAO,MAAM,YAAY;2BAGO,MAAM,IAAI,MAAM,MAAM;6BAIpB,OAAO,OAAO;;4BAcf,MAAM,IAAI,MAAM,MAAM;8BAIpB,OAAO,OAAO;;;CA0BhD,CAAC"}

package/dist/processing/vm-timers.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimers = void 0;
+/**
+ * Timers (setTimeout, setInterval) do not work in Node.js vm, see: https://github.com/nodejs/help/issues/1875
+ *
+ * The API is wrapped in a "create" function so that every processing snippet keeps track of its timers and properly
+ * cleans them up after use.
+ */
+const createTimers = () => {
+    let timeouts = [];
+    const customSetTimeout = (fn, ms) => {
+        timeouts.push(setTimeout(fn, ms));
+    };
+    const customClearTimeout = (id) => {
+        timeouts = timeouts.filter((timeoutId) => timeoutId !== id);
+        clearTimeout(id);
+    };
+    const clearAllTimeouts = () => {
+        for (const element of timeouts) {
+            clearTimeout(element);
+        }
+        timeouts = [];
+    };
+    let intervals = [];
+    const customSetInterval = (fn, ms) => {
+        intervals.push(setInterval(fn, ms));
+    };
+    const customClearInterval = (id) => {
+        intervals = intervals.filter((intervalId) => intervalId !== id);
+        clearInterval(id);
+    };
+    const clearAllIntervals = () => {
+        for (const element of intervals) {
+            clearInterval(element);
+        }
+        intervals = [];
+    };
+    const clearAll = () => {
+        clearAllTimeouts();
+        clearAllIntervals();
+    };
+    return {
+        customSetTimeout,
+        customClearTimeout,
+        clearAllTimeouts,
+        customSetInterval,
+        customClearInterval,
+        clearAllIntervals,
+        clearAll,
+    };
+};
+exports.createTimers = createTimers;
+//# sourceMappingURL=vm-timers.js.map

package/dist/processing/vm-timers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm-timers.js","sourceRoot":"","sources":["../../src/processing/vm-timers.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACI,MAAM,YAAY,GAAG,GAAG,EAAE;IAC/B,IAAI,QAAQ,GAAqB,EAAE,CAAC;IAEpC,MAAM,gBAAgB,GAAG,CAAC,EAAc,EAAE,EAAU,EAAE,EAAE;QACtD,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACpC,CAAC,CAAC;IAEF,MAAM,kBAAkB,GAAG,CAAC,EAAkB,EAAE,EAAE;QAChD,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC;QAC5D,YAAY,CAAC,EAAE,CAAC,CAAC;IACnB,CAAC,CAAC;IAEF,MAAM,gBAAgB,GAAG,GAAG,EAAE;QAC5B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,YAAY,CAAC,OAAO,CAAC,CAAC;SACvB;QACD,QAAQ,GAAG,EAAE,CAAC;IAChB,CAAC,CAAC;IAEF,IAAI,SAAS,GAAqB,EAAE,CAAC;IAErC,MAAM,iBAAiB,GAAG,CAAC,EAAc,EAAE,EAAU,EAAE,EAAE;QACvD,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACtC,CAAC,CAAC;IAEF,MAAM,mBAAmB,GAAG,CAAC,EAAkB,EAAE,EAAE;QACjD,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,KAAK,EAAE,CAAC,CAAC;QAChE,aAAa,CAAC,EAAE,CAAC,CAAC;IACpB,CAAC,CAAC;IAEF,MAAM,iBAAiB,GAAG,GAAG,EAAE;QAC7B,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE;YAC/B,aAAa,CAAC,OAAO,CAAC,CAAC;SACxB;QACD,SAAS,GAAG,EAAE,CAAC;IACjB,CAAC,CAAC;IAEF,MAAM,QAAQ,GAAG,GAAG,EAAE;QACpB,gBAAgB,EAAE,CAAC;QACnB,iBAAiB,EAAE,CAAC;IACtB,CAAC,CAAC;IAEF,OAAO;QACL,gBAAgB;QAChB,kBAAkB;QAClB,gBAAgB;QAChB,iBAAiB;QACjB,mBAAmB;QACnB,iBAAiB;QACjB,QAAQ;KACT,CAAC;AACJ,CAAC,CAAC;AAnDW,QAAA,YAAY,gBAmDvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api3/commons",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "keywords": [],
   "license": "MIT",
   "engines": {
@@ -12,10 +12,13 @@
     "src"
   ],
   "exports": {
+    "./eslint": "./dist/eslint/index.js",
     "./logger": "./dist/logger/index.js",
-    "./eslint": "./dist/logger/index.js"
+    "./processing": "./dist/processing/index.js"
   },
   "dependencies": {
+    "@api3/ois": "^2.2.1",
+    "@api3/promise-utils": "^0.4.0",
     "@typescript-eslint/eslint-plugin": "^6.2.1",
     "@typescript-eslint/parser": "^6.2.1",
     "eslint-config-next": "^13.1.6",
@@ -28,7 +31,6 @@
     "eslint-plugin-jest-formatting": "^3.1.0",
     "eslint-plugin-lodash": "^7.4.0",
     "eslint-plugin-no-only-tests": "^3.1.0",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-react": "^7.32.1",
     "eslint-plugin-react-hooks": "^4.6.0",
@@ -64,7 +66,7 @@
     "eslint:fix": "pnpm run eslint:check --fix",
     "prettier:check": "prettier --check \"./**/*.{js,ts,md,json}\"",
     "prettier:fix": "prettier --write \"./**/*.{js,ts,md,json}\"",
-    "test": "jest --passWithNoTests",
+    "test": "jest",
     "tsc": "tsc --project ."
   }
 }

package/src/eslint/README.md

@@ -58,11 +58,6 @@ The configurations are a collection of various rulesets and the config is quite
 - Fix outdated stuff (avoid `!` ts operator when not necessary)
 - Avoid vulnerabilities and errors (Number.parseInt without radix)
 
-But some stylistical rules are too strict for certain projects, for example:
-
-- Enforce `camelCase` for variables and functions, but `kebab-case` for filenames.
-- Prefer arrow functions everywhere instead of regular `function` functions.
-
 Tip: Some rules do have fixer with multiple variants of the fixes. You need to use the IDE to prompt the fixes and
 choose the one you want.
 

package/src/eslint/jest.js

@@ -29,6 +29,7 @@ module.exports = {
             allow: ['afterEach', 'afterAll'],
           },
         ],
+        'prefer-lowercase-title': 'off', // Sometimes we want to start the test with a capital letter and some words are all uppercase (e.g. AWS).
       },
     },
   ],

package/src/eslint/react.js

@@ -42,7 +42,6 @@ module.exports = {
     'react/destructuring-assignment': ['error', 'always', { destructureInSignature: 'ignore' }],
     'react/forbid-component-props': ['error', { forbid: [] }],
     'react/forbid-dom-props': ['error', { forbid: [] }],
-    'react/function-component-definition': 'off', // Arrow functions are managed by other rules.
     'react/jsx-curly-brace-presence': ['error', { props: 'never', children: 'never', propElementValues: 'always' }],
     'react/jsx-curly-newline': 'off', // Conflicts with prettier.
     'react/jsx-filename-extension': 'off', // We use .tsx extension.

package/src/eslint/universal.js

@@ -20,16 +20,7 @@ module.exports = {
     'plugin:promise/recommended',
     'plugin:lodash/recommended',
   ],
-  plugins: [
-    '@typescript-eslint',
-    'deprecation',
-    'functional',
-    'prefer-arrow',
-    'unicorn',
-    'check-file',
-    'import',
-    'lodash',
-  ],
+  plugins: ['@typescript-eslint', 'deprecation', 'functional', 'unicorn', 'check-file', 'import', 'lodash'],
   rules: {
     /* Rule definitions and overrides for standard ESLint rules */
     camelcase: 'error',
@@ -78,16 +69,6 @@ module.exports = {
       },
     ],
 
-    /* Rules to setup enforcement of arrow functions over regular functions */
-    'prefer-arrow/prefer-arrow-functions': [
-      'error',
-      {
-        disallowPrototype: true,
-        singleReturnOnly: false,
-        classPropertiesAllowed: false,
-      },
-    ],
-
     /* Rules to enforce kebab-case folder structure */
     'check-file/folder-naming-convention': [
       'error',
@@ -110,6 +91,7 @@ module.exports = {
     'unicorn/no-array-reduce': 'off', // We are OK with using reduce occasionally, but I agree with the author that the code using reduce can easily get complex.
     'unicorn/no-nested-ternary': 'off', // This rule is smarter than the standard ESLint rule, but conflicts with prettier so it needs to be turned off. Nested ternaries are very unreadable so it's OK if all of them are flagged.
     'unicorn/no-null': 'off', // We use both null and undefined for representing three state objects. We could use a string union instead, but using combination of null and undefined is less verbose.
+    'unicorn/no-object-as-default-parameter': 'off', // Too restrictive. TypeScript can ensure that the default value matches the type.
     'unicorn/no-useless-undefined': ['error', { checkArguments: false }], // We need to disable "checkArguments", because if a function expects a value of type "T | undefined" the undefined value needs to be passed explicitly.
     'unicorn/prefer-module': 'off', // We use CJS for configuration files and tests. There is no rush to migrate to ESM and the configuration files are probably not yet ready for ESM yet.
     'unicorn/prevent-abbreviations': 'off', // This rule reports many false positives and leads to more verbose code.

package/src/processing/README.md

@@ -0,0 +1,49 @@
+# Processing
+
+> Implementation of [OIS processing](https://docs.api3.org/reference/ois/latest/processing.html).
+
+The pre/post processing is only supported for Node.js environments and uses internal Node.js modules.
+
+## Getting started
+
+1. Install `zod` which is a peer dependency of this module. Zod is used for validating the logger configuration.
+
+## Documentation
+
+The processing module exports two main functions:
+
+<!-- NOTE: These are copied over from "processing.d.ts" from "dist" file. -->
+
+```ts
+/**
+ * Pre-processes API call parameters based on the provided endpoint's processing specifications.
+ *
+ * @param endpoint The endpoint containing processing specifications.
+ * @param apiCallParameters The parameters to be pre-processed.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the pre-processed parameters.
+ */
+export declare const preProcessApiCallParameters: (
+  endpoint: Endpoint,
+  apiCallParameters: ApiCallParameters,
+  processingOptions?: GoAsyncOptions
+) => Promise<ApiCallParameters>;
+
+/**
+ * Post-processes the API call response based on the provided endpoint's processing specifications.
+ *
+ * @param apiCallResponse The raw response obtained from the API call.
+ * @param endpoint The endpoint containing processing specifications.
+ * @param apiCallParameters The parameters used in the API call.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the post-processed API call response.
+ */
+export declare const postProcessApiCallResponse: (
+  apiCallResponse: unknown,
+  endpoint: Endpoint,
+  apiCallParameters: ApiCallParameters,
+  processingOptions?: GoAsyncOptions
+) => Promise<unknown>;
+```

package/src/processing/index.ts

@@ -0,0 +1,3 @@
+export * from './processing';
+export * from './schema';
+export * from './unsafe-evaluate';

package/src/processing/processing.test.ts

@@ -0,0 +1,272 @@
+/* eslint-disable jest/prefer-strict-equal */ // Because the errors are thrown from the "vm" module (different context), they are not strictly equal.
+import { createEndpoint } from '../../test/fixtures';
+
+import {
+  addReservedParameters,
+  postProcessApiCallResponse,
+  preProcessApiCallParameters,
+  removeReservedParameters,
+} from './processing';
+
+describe(preProcessApiCallParameters.name, () => {
+  it('valid processing code', async () => {
+    const endpoint = createEndpoint({
+      preProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: 'const output = {...input, from: "ETH"};',
+          timeoutMs: 5000,
+        },
+        {
+          environment: 'Node',
+          value: 'const output = {...input, newProp: "airnode"};',
+          timeoutMs: 5000,
+        },
+      ],
+    });
+    const parameters = { _type: 'int256', _path: 'price' };
+
+    const result = await preProcessApiCallParameters(endpoint, parameters);
+
+    expect(result).toEqual({
+      _path: 'price',
+      _type: 'int256',
+      from: 'ETH',
+      newProp: 'airnode',
+    });
+  });
+
+  it('invalid processing code', async () => {
+    const endpoint = createEndpoint({
+      preProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: 'something invalid; const output = {...input, from: `ETH`};',
+          timeoutMs: 5000,
+        },
+        {
+          environment: 'Node',
+          value: 'const output = {...input, newProp: "airnode"};',
+          timeoutMs: 5000,
+        },
+      ],
+    });
+    const parameters = { _type: 'int256', _path: 'price', from: 'TBD' };
+
+    const throwingFunc = async () => preProcessApiCallParameters(endpoint, parameters);
+
+    await expect(throwingFunc).rejects.toEqual(new Error('SyntaxError: Unexpected identifier'));
+  });
+
+  it('demonstrates access to endpointParameters, but reserved parameters are inaccessible', async () => {
+    const parameters = { _type: 'int256', _path: 'price', to: 'USD' };
+    const endpoint = createEndpoint({
+      preProcessingSpecifications: [
+        {
+          environment: 'Node',
+          // pretend the user is trying to 1) override _path and 2) set a new parameter based on
+          // the presence of the reserved parameter _type (which is inaccessible)
+          value:
+            'const output = {...input, from: "ETH", _path: "price.newpath", myVal: input._type ? "123" : "456", newTo: endpointParameters.to };',
+          timeoutMs: 5000,
+        },
+      ],
+    });
+
+    const result = await preProcessApiCallParameters(endpoint, parameters);
+
+    expect(result).toEqual({
+      _path: 'price', // is not overridden
+      _type: 'int256',
+      from: 'ETH', // originates from the processing code
+      to: 'USD', // should be unchanged from the original parameters
+      myVal: '456', // is set to "456" because _type is not present in the environment
+      newTo: 'USD', // demonstrates access to endpointParameters
+    });
+  });
+
+  it('uses native modules for processing', async () => {
+    const endpoint = createEndpoint({
+      preProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: `
+          const randomValue = crypto.randomBytes(4).toString('hex');
+          const output = {...input, randomValue};
+        `,
+          timeoutMs: 5000,
+        },
+      ],
+    });
+    const parameters = { _type: 'int256', _path: 'price' };
+
+    const result = await preProcessApiCallParameters(endpoint, parameters);
+
+    // Check that the result contains the original parameters and a valid 8-character hex random value.
+    expect(result).toMatchObject({
+      _path: 'price',
+      _type: 'int256',
+    });
+    expect(result.randomValue).toHaveLength(8);
+    expect(/^[\da-f]{8}$/i.test(result.randomValue)).toBe(true);
+  });
+
+  it('throws error due to processing timeout', async () => {
+    const endpoint = createEndpoint({
+      preProcessingSpecifications: [
+        {
+          environment: 'Node async',
+          value: `
+          const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+          delay(5000);
+          const output = {...input, from: 'ETH'};
+        `,
+          timeoutMs: 100, // This timeout is shorter than the delay in the processing code.
+        },
+      ],
+    });
+    const parameters = { _type: 'int256', _path: 'price' };
+
+    const throwingFunc = async () => preProcessApiCallParameters(endpoint, parameters);
+
+    await expect(throwingFunc).rejects.toThrow('Timeout exceeded');
+  });
+});
+
+describe(postProcessApiCallResponse.name, () => {
+  it('processes valid code', async () => {
+    const parameters = { _type: 'int256', _path: 'price' };
+    const endpoint = createEndpoint({
+      postProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: 'const output = parseInt(input.price)*2;',
+          timeoutMs: 5000,
+        },
+        {
+          environment: 'Node',
+          value: 'const output = parseInt(input)*2;',
+          timeoutMs: 5000,
+        },
+      ],
+    });
+
+    const result = await postProcessApiCallResponse({ price: 1000 }, endpoint, parameters);
+
+    expect(result).toBe(4000);
+  });
+
+  it('demonstrates access to endpointParameters, but reserved parameters are inaccessible', async () => {
+    const myMultiplier = 10;
+    const parameters = { _type: 'int256', _path: 'price', myMultiplier };
+    const endpoint = createEndpoint({
+      postProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: `
+            const reservedMultiplier = endpointParameters._times ? 1 : 2;
+            const output = parseInt(input.price) * endpointParameters.myMultiplier * reservedMultiplier
+          `,
+          timeoutMs: 5000,
+        },
+      ],
+    });
+
+    const price = 1000;
+    const result = await postProcessApiCallResponse({ price }, endpoint, parameters);
+
+    // reserved parameters (_times) should be inaccessible to post-processing for the
+    // http-gateway, hence multiplication by 2 instead of 1
+    expect(result).toEqual(price * myMultiplier * 2);
+  });
+
+  it('throws on invalid code', async () => {
+    const parameters = { _type: 'int256', _path: 'price' };
+    const endpoint = createEndpoint({
+      postProcessingSpecifications: [
+        {
+          environment: 'Node',
+          value: 'const output = parseInt(input.price)*1000;',
+          timeoutMs: 5000,
+        },
+        {
+          environment: 'Node',
+          value: `
+            Something Unexpected;
+            const output = parseInt(input)*2;
+          `,
+          timeoutMs: 5000,
+        },
+      ],
+    });
+
+    const throwingFunc = async () => postProcessApiCallResponse({ price: 1000 }, endpoint, parameters);
+
+    await expect(throwingFunc).rejects.toEqual(new Error('SyntaxError: Unexpected identifier'));
+  });
+});
+
+describe(removeReservedParameters.name, () => {
+  it('removes all reserved parameters', () => {
+    const parameters = {
+      normalParam1: 'value1',
+      _type: 'int256',
+      _path: 'price',
+      normalParam2: 'value2',
+    };
+
+    const result = removeReservedParameters(parameters);
+
+    expect(result).toEqual({
+      normalParam1: 'value1',
+      normalParam2: 'value2',
+    });
+  });
+
+  it('returns same object if no reserved parameters found', () => {
+    const parameters = {
+      normalParam1: 'value1',
+      normalParam2: 'value2',
+    };
+
+    const result = removeReservedParameters(parameters);
+
+    expect(result).toEqual(parameters);
+  });
+});
+
+describe(addReservedParameters.name, () => {
+  it('adds reserved parameters from initial to modified parameters', () => {
+    const initialParameters = {
+      _type: 'int256',
+      _path: 'price',
+    };
+    const modifiedParameters = {
+      normalParam1: 'value1',
+      normalParam2: 'value2',
+    };
+
+    const result = addReservedParameters(initialParameters, modifiedParameters);
+
+    expect(result).toEqual({
+      normalParam1: 'value1',
+      normalParam2: 'value2',
+      _type: 'int256',
+      _path: 'price',
+    });
+  });
+
+  it('does not modify modifiedParameters if no reserved parameters in initialParameters', () => {
+    const initialParameters = {
+      normalParam3: 'value3',
+    };
+    const modifiedParameters = {
+      normalParam1: 'value1',
+      normalParam2: 'value2',
+    };
+
+    const result = addReservedParameters(initialParameters, modifiedParameters);
+
+    expect(result).toEqual(modifiedParameters);
+  });
+});