@api3/commons 0.6.1 → 0.7.0

package/src/config-hash/index.test.ts

@@ -0,0 +1,93 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { createSha256Hash, serializePlainObject, sortObjectKeysRecursively } from '.';
+
+describe(sortObjectKeysRecursively.name, () => {
+  it('should sort the keys alphabetically', () => {
+    const plainObject = {
+      c: 3,
+      a: 1,
+      b: 2,
+    };
+
+    expect(sortObjectKeysRecursively(plainObject)).toStrictEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  it('should handle nested objects', () => {
+    const plainObject = {
+      c: 3,
+      a: 1,
+      b: {
+        e: 5,
+        d: 4,
+      },
+    };
+
+    expect(sortObjectKeysRecursively(plainObject)).toStrictEqual({ a: 1, b: { d: 4, e: 5 }, c: 3 });
+  });
+
+  it('handles other primitive values', () => {
+    const plainObject = {
+      c: 'c-val',
+      a: 1,
+      F: null,
+      B: false,
+      b: [2, null, 1],
+    };
+
+    expect(sortObjectKeysRecursively(plainObject)).toStrictEqual({
+      B: false,
+      F: null,
+      a: 1,
+      b: [2, null, 1],
+      c: 'c-val',
+    });
+  });
+});
+
+describe(serializePlainObject.name, () => {
+  it('creates the same serialization string for equal objects', () => {
+    const plainObject = {
+      c: 'c-val',
+      a: 1,
+      F: null,
+      B: false,
+      b: [2, null, 1],
+    };
+    const otherPlainObject = {
+      a: 1,
+      F: null,
+      B: false,
+      c: 'c-val',
+      b: [2, null, 1],
+    };
+
+    expect(serializePlainObject(plainObject)).toBe(serializePlainObject(otherPlainObject));
+  });
+});
+
+describe(createSha256Hash.name, () => {
+  it('should create same hash as SubtleCrypto in browser', () => {
+    // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#converting_a_digest_to_a_hex_string
+    const text = 'An obscure body in the S-K System, your majesty. The inhabitants refer to it as the planet Earth.';
+
+    expect(createSha256Hash(text)).toBe('0x6efd383745a964768989b9df420811abc6e5873f874fc22a76fe9258e020c2e1');
+  });
+});
+
+test('can produce the same hash on UNIX', () => {
+  const fixturePath = join(__dirname, '../../test/fixtures/config-hash/file.json');
+
+  // Compute the hash using this module
+  const rawConfig = JSON.parse(readFileSync(fixturePath, 'utf8'));
+  const serializedConfig = serializePlainObject(rawConfig);
+  const hash = createSha256Hash(serializedConfig);
+
+  // Compute the hash using UNIX commands
+  const unixCommand = `jq --sort-keys --compact-output . ${fixturePath} | tr -d '\n' | sha256sum | awk '{ print "0x"$1 }'`;
+  const unixCommandHash = execSync(unixCommand, { encoding: 'utf8' }).trim();
+
+  expect(hash).toBe(unixCommandHash);
+});

package/src/config-hash/index.ts

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+
+import isObject from 'lodash/isObject';
+
+// We need to make sure the object is stringified in the same way every time, so we sort the keys alphabetically.
+export const sortObjectKeysRecursively = (value: any) => {
+  if (value === null) return null;
+  if (!isObject(value) || Array.isArray(value)) return value;
+
+  const sortedKeys = Object.keys(value).sort();
+  const sortedObject: any = {};
+
+  for (const key of sortedKeys) {
+    sortedObject[key] = sortObjectKeysRecursively((value as any)[key]);
+  }
+
+  return sortedObject;
+};
+
+export const serializePlainObject = (plainObject: any) => {
+  const sortedObject = sortObjectKeysRecursively(plainObject);
+  return JSON.stringify(sortedObject);
+};
+
+export const createSha256Hash = (value: string) => `0x${createHash('sha256').update(value).digest('hex')}`;

package/src/config-parsing/README.md

@@ -0,0 +1,48 @@
+# Config parsing
+
+> Node.js module for parsing configuration files with support of interpolating secrets.
+
+## Usage
+
+### Parsing a configuration file and secrets
+
+You can use the following helper functions to read the configuration and secrets file from filesystem:
+
+```ts
+const rawConfig = loadConfig(join(__dirname, 'config.json'));
+const rawSecrets = loadSecrets(join(__dirname, 'secrets.env'));
+```
+
+### Creating the full configuration object
+
+The module defines a `interpolateSecretsIntoConfig` function that takes a config object along with the secrets and
+returns the config with the secrets interpolated into it.
+
+Examples:
+
+```ts
+// Basic interpolation
+const rawConfig = {
+  prop: 'value',
+  secret: '${SECRET}',
+};
+const config = interpolateSecretsIntoConfig(rawConfig, { SECRET: 'secretValue' }); // { prop: 'value', secret: 'secretValue' }
+```
+
+```ts
+// Allows escaping the interpolation syntax
+const rawConfig = {
+  prop: 'value',
+  secret: '\\${SECRET}',
+};
+const config = interpolateSecretsIntoConfig(rawConfig, { SECRET: 'secretValue' }); // { prop: 'value', secret: '${SECRET}' }
+```
+
+```ts
+// Throws an error if something is not right
+const rawConfig = {
+  prop: 'value',
+  secret: '${SECRET}',
+};
+const config = interpolateSecretsIntoConfig(rawConfig); // Error: SECRET is not defined
+```

package/src/config-parsing/index.test.ts

@@ -0,0 +1,158 @@
+import { ZodError } from 'zod';
+
+import { interpolateSecretsIntoConfig } from './index';
+
+const rawConfig = {
+  property: 'value',
+  secretB: '${SECRET_B}',
+  secretA: '${SECRET_A}',
+};
+
+describe(interpolateSecretsIntoConfig.name, () => {
+  it('interpolates secrets into config', () => {
+    const config = interpolateSecretsIntoConfig(rawConfig, {
+      SECRET_A: 'secretValueA',
+      SECRET_B: 'secretValueB',
+    });
+
+    expect(config).toStrictEqual({
+      property: 'value',
+      secretA: 'secretValueA',
+      secretB: 'secretValueB',
+    });
+  });
+
+  it('allows empty secrets by default', () => {
+    const config = interpolateSecretsIntoConfig(rawConfig, {
+      SECRET_A: '',
+      SECRET_B: '',
+    });
+
+    expect(config).toStrictEqual({
+      property: 'value',
+      secretA: '',
+      secretB: '',
+    });
+  });
+
+  it('disallows empty secrets when configured so', () => {
+    expect(() => {
+      interpolateSecretsIntoConfig(
+        rawConfig,
+        {
+          SECRET_A: '',
+          SECRET_B: '',
+        },
+        { allowBlankSecretValue: false }
+      );
+    }).toThrow('Secret cannot be blank');
+  });
+
+  it('can use "\\" to escape interpolation', () => {
+    const escapedConfig = {
+      ...rawConfig,
+      secretA: '\\${SECRET_A}',
+    };
+    const config = interpolateSecretsIntoConfig(escapedConfig, {
+      SECRET_A: 'secretValueA',
+      SECRET_B: 'secretValueB',
+    });
+
+    expect(config).toStrictEqual({
+      property: 'value',
+      secretA: '${SECRET_A}',
+      secretB: 'secretValueB',
+    });
+  });
+
+  it('allows extraneous secrets', () => {
+    const config = interpolateSecretsIntoConfig(rawConfig, {
+      SECRET_A: 'secretValueA',
+      SECRET_B: 'secretValueB',
+      SECRET_C: 'secretValueC',
+    });
+
+    expect(config).toStrictEqual({
+      property: 'value',
+      secretA: 'secretValueA',
+      secretB: 'secretValueB',
+    });
+  });
+
+  it('throws an error when a secret is missing', () => {
+    expect(() => {
+      interpolateSecretsIntoConfig(rawConfig, {
+        SECRET_A: 'secretValueA',
+      });
+    }).toThrow('SECRET_B is not defined');
+  });
+
+  it('allows no secrets', () => {
+    const noSecretsConfig = { value: 'no secrets' };
+
+    expect(interpolateSecretsIntoConfig(noSecretsConfig, {})).toStrictEqual(noSecretsConfig);
+  });
+
+  it('throws when secret name is invalid', () => {
+    expect(() => {
+      interpolateSecretsIntoConfig(rawConfig, {
+        SECRET_A: 'secretValueA',
+        '0_SECRET_STARTING_WITH_NUMBER': 'invalid',
+      });
+    }).toThrow(
+      new ZodError([
+        {
+          validation: 'regex',
+          code: 'invalid_string',
+          message: 'Secret name is not a valid. Secret name must match /^[A-Z][\\dA-Z_]*$/',
+          path: ['0_SECRET_STARTING_WITH_NUMBER'],
+        },
+      ])
+    );
+
+    expect(() => {
+      interpolateSecretsIntoConfig(rawConfig, {
+        SECRET_A: 'secretValueA',
+        'CANNOT-CONTAIN-HYPHEN': 'invalid',
+      });
+    }).toThrow(
+      new ZodError([
+        {
+          validation: 'regex',
+          code: 'invalid_string',
+          message: 'Secret name is not a valid. Secret name must match /^[A-Z][\\dA-Z_]*$/',
+          path: ['CANNOT-CONTAIN-HYPHEN'],
+        },
+      ])
+    );
+  });
+
+  it('provides up to date README examples', () => {
+    // Basic interpolation
+    const basicInterpolationConfig = {
+      prop: 'value',
+      secret: '${SECRET}',
+    };
+    expect(interpolateSecretsIntoConfig(basicInterpolationConfig, { SECRET: 'secretValue' })).toStrictEqual({
+      prop: 'value',
+      secret: 'secretValue',
+    });
+
+    // Allows escaping the interpolation syntax
+    const escapingInterpolationConfig = {
+      prop: 'value',
+      secret: '\\${SECRET}',
+    };
+    expect(interpolateSecretsIntoConfig(escapingInterpolationConfig, { SECRET: 'secretValue' })).toStrictEqual({
+      prop: 'value',
+      secret: '${SECRET}',
+    });
+
+    // Throws an error if something is not right
+    const missingSecretConfig = {
+      prop: 'value',
+      secret: '${SECRET}',
+    };
+    expect(() => interpolateSecretsIntoConfig(missingSecretConfig, {})).toThrow('SECRET is not defined');
+  });
+});

package/src/config-parsing/index.ts

@@ -0,0 +1,75 @@
+import { readFileSync } from 'node:fs';
+
+import dotenv from 'dotenv';
+import reduce from 'lodash/reduce';
+import template from 'lodash/template';
+import { z } from 'zod';
+
+export const secretNamePattern = /^[A-Z][\dA-Z_]*$/;
+
+export const secretNameSchema = z
+  .string()
+  .regex(secretNamePattern, `Secret name is not a valid. Secret name must match ${secretNamePattern.toString()}`);
+
+export const secretsSchema = z.record(secretNameSchema, z.string());
+
+export const nonBlankSecretsSchema = z.record(
+  secretNameSchema,
+  z.string().min(1, { message: 'Secret cannot be blank' })
+);
+
+export type Secrets = Record<string, string>;
+
+// Regular expression that does not match anything, ensuring no escaping or interpolation happens
+// https://github.com/lodash/lodash/blob/4.17.15/lodash.js#L199
+// eslint-disable-next-line prefer-named-capture-group
+const NO_MATCH_REGEXP = /($^)/;
+// Regular expression matching ES template literal delimiter (${}) with escaping
+// https://github.com/lodash/lodash/blob/4.17.15/lodash.js#L175
+// eslint-disable-next-line prefer-named-capture-group
+const ES_MATCH_REGEXP = /(?<!\\)\${([^\\}]*(?:\\.[^\\}]*)*)}/g;
+// Regular expression matching the escaped ES template literal delimiter (${}). We need to use "\\\\" (four backslashes)
+// because "\\" becomes "\\\\" when converted to string
+// eslint-disable-next-line prefer-named-capture-group
+const ESCAPED_ES_MATCH_REGEXP = /\\\\(\${([^\\}]*(?:\\.[^\\}]*)*)})/g;
+
+export interface InterpolationOptions {
+  allowBlankSecretValue: boolean;
+}
+
+export type AnyObject = Record<string, unknown>;
+
+export function interpolateSecretsIntoConfig<T = AnyObject>(
+  config: T,
+  secrets: unknown,
+  options: InterpolationOptions = { allowBlankSecretValue: true }
+) {
+  const { allowBlankSecretValue } = options;
+  const validatedSecrets = (allowBlankSecretValue ? secretsSchema : nonBlankSecretsSchema).parse(secrets);
+
+  const stringifiedSecrets = reduce(
+    validatedSecrets,
+    (acc, value, key) => {
+      return {
+        ...acc,
+        // Convert to value to JSON to encode new lines as "\n". The resulting value will be a JSON string with quotes
+        // which are sliced off.
+        [key]: JSON.stringify(value).slice(1, -1),
+      };
+    },
+    {} as Secrets
+  );
+
+  const interpolatedConfig = template(JSON.stringify(config), {
+    escape: NO_MATCH_REGEXP,
+    evaluate: NO_MATCH_REGEXP,
+    interpolate: ES_MATCH_REGEXP,
+  })(stringifiedSecrets);
+  // Un-escape the escaped config interpolations (e.g. to enable interpolation in processing snippets). Optimistically
+  // assume, the config type has not changed.
+  return JSON.parse(interpolatedConfig.replaceAll(ESCAPED_ES_MATCH_REGEXP, '$1')) as T;
+}
+
+export const loadSecrets = (path: string) => dotenv.parse(readFileSync(path, 'utf8'));
+
+export const loadConfig = (path: string) => JSON.parse(readFileSync(path, 'utf8'));

package/src/eslint/react.js

@@ -1,4 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
+// eslint-disable-next-line @typescript-eslint/no-var-requires, lodash/import-scope
 const { merge } = require('lodash');
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires

package/src/http/README.md

@@ -0,0 +1,3 @@
+# Http
+
+> Http is a module that provides a simple way to make http requests.

package/src/http/index.test.ts

@@ -0,0 +1,43 @@
+import { AxiosError, type AxiosResponse } from 'axios';
+
+import { executeRequest, extractAxiosErrorData } from '.';
+
+describe(extractAxiosErrorData.name, () => {
+  it('should return an error response object', () => {
+    const axiosError = new AxiosError('error message', '500', undefined, {}, {
+      data: 'error data',
+      status: 500,
+      statusText: 'Internal Server Error',
+    } as any as AxiosResponse);
+
+    expect(extractAxiosErrorData(axiosError)).toStrictEqual({
+      axiosResponse: {
+        data: 'error data',
+        status: 500,
+      },
+      code: '500',
+      message: 'error message',
+    });
+  });
+});
+
+describe(executeRequest.name, () => {
+  it('fails to call invalid URL', async () => {
+    const request = {
+      method: 'GET',
+      url: 'http://localhost:9999',
+    } as const;
+
+    const response = await executeRequest(request);
+
+    expect(response).toStrictEqual({
+      data: undefined,
+      errorData: {
+        axiosResponse: undefined,
+        code: 'ECONNREFUSED',
+        message: expect.any(String), // The message is empty in node@20, but "connect ECONNREFUSED ::1:9999" on node@18
+      },
+      success: false,
+    });
+  });
+});

package/src/http/index.ts

@@ -0,0 +1,61 @@
+import { go } from '@api3/promise-utils';
+import axios, { type Method, type AxiosError, type AxiosResponse } from 'axios';
+import pick from 'lodash/pick';
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+export interface Request {
+  readonly method: Method;
+  readonly url: string;
+  readonly headers?: Record<string, string>;
+  readonly queryParams?: Record<string, any>;
+  readonly timeout?: number;
+  readonly body?: unknown;
+}
+
+export interface ErrorResponse {
+  readonly axiosResponse: Pick<AxiosResponse, 'data' | 'headers' | 'status'> | undefined;
+  readonly message: string;
+  readonly code: string | undefined;
+}
+
+export const extractAxiosErrorData = (error: AxiosError): ErrorResponse => {
+  // Inspired by: https://axios-http.com/docs/handling_errors
+  return {
+    axiosResponse: error.response ? pick(error.response, ['data', 'status']) : undefined,
+    message: error.message,
+    code: error.code,
+  } as ErrorResponse;
+};
+
+interface ExecuteRequestSuccess<T> {
+  success: true;
+  errorData: undefined;
+  data: T;
+}
+interface ExecuteRequestError {
+  success: false;
+  errorData: ErrorResponse;
+  data: undefined;
+}
+
+export type ExecuteRequestResult<T> = ExecuteRequestError | ExecuteRequestSuccess<T>;
+
+export async function executeRequest<T>(request: Request): Promise<ExecuteRequestResult<T>> {
+  const { url, method, body, headers = {}, queryParams = {}, timeout = DEFAULT_TIMEOUT_MS } = request;
+
+  const goAxios = await go<Promise<AxiosResponse<T>>, AxiosError>(async () =>
+    axios({
+      url,
+      method,
+      headers,
+      data: body,
+      params: queryParams,
+      timeout,
+    })
+  );
+  if (!goAxios.success) return { success: false, errorData: extractAxiosErrorData(goAxios.error), data: undefined };
+  const response = goAxios.data;
+
+  return { success: true, errorData: undefined, data: response.data };
+}

package/src/logger/index.test.ts

@@ -1,4 +1,4 @@
-import { noop } from 'lodash';
+import noop from 'lodash/noop';
 
 import { type LogConfig, createBaseLogger, wrapper } from '.';
 
@@ -29,9 +29,9 @@ describe('log context', () => {
       logger.debug('parent end');
     });
 
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { requestId: 'parent' });
-    expect(baseLogger.debug).toHaveBeenCalledWith('child', { requestId: 'child' });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { requestId: 'parent' });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
   });
 
   it('works with async functions', async () => {
@@ -48,9 +48,9 @@ describe('log context', () => {
     });
 
     expect(baseLogger.debug).toHaveBeenCalledTimes(3);
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { requestId: 'parent' });
-    expect(baseLogger.debug).toHaveBeenCalledWith('child', { requestId: 'child' });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { requestId: 'parent' });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { requestId: 'parent' } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('child', { ctx: { requestId: 'child' } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { requestId: 'parent' } });
   });
 
   it('works with deeply nested functions', async () => {
@@ -78,14 +78,14 @@ describe('log context', () => {
     });
 
     expect(baseLogger.debug).toHaveBeenCalledTimes(8);
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { parent: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('A start', { parent: true, A: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('C', { parent: true, A: true, B: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('D', { parent: true, A: true, B: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('E', { parent: true, A: true, B: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('B end', { parent: true, A: true, B: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('A end', { parent: true, A: true });
-    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { parent: true });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent start', { ctx: { parent: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('A start', { ctx: { parent: true, A: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('C', { ctx: { parent: true, A: true, B: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('D', { ctx: { parent: true, A: true, B: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('E', { ctx: { parent: true, A: true, B: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('B end', { ctx: { parent: true, A: true, B: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('A end', { ctx: { parent: true, A: true } });
+    expect(baseLogger.debug).toHaveBeenCalledWith('parent end', { ctx: { parent: true } });
   });
 
   it('throws if the sync callback function throws', () => {
@@ -118,10 +118,12 @@ describe('log context', () => {
     logger.error('message, error and context', new Error('some-error'), { requestId: 'parent' });
 
     expect(baseLogger.error).toHaveBeenNthCalledWith(1, 'only message', undefined);
-    expect(baseLogger.error).toHaveBeenNthCalledWith(2, 'message and context', { requestId: 'parent' });
+    expect(baseLogger.error).toHaveBeenNthCalledWith(2, 'message and context', { ctx: { requestId: 'parent' } });
     expect(baseLogger.error).toHaveBeenNthCalledWith(3, 'message and error', new Error('some-error'), undefined);
     expect(baseLogger.error).toHaveBeenNthCalledWith(4, 'message, error and context', new Error('some-error'), {
-      requestId: 'parent',
+      ctx: {
+        requestId: 'parent',
+      },
     });
   });
 });

package/src/logger/index.ts

@@ -61,7 +61,6 @@ export const createBaseLogger = (config: LogConfig) => {
     // This format is recommended by the "winston-console-format" package.
     format: winston.format.combine(
       winston.format.timestamp(),
-      winston.format.ms(),
       winston.format.errors({ stack: true }),
       winston.format.splat(),
       winston.format.json()
@@ -88,36 +87,36 @@ export interface Logger {
   child: (options: { name: string }) => Logger;
 }
 
+const createFullContext = (localContext: LogContext | undefined) => {
+  const globalContext = getAsyncLocalStorage().getStore();
+  if (!globalContext && !localContext) return;
+  const fullContext = { ...globalContext, ...localContext };
+
+  // If the context contains a `name` or `message` field, it will override the `name` and `message` fields of the log
+  // entry. To avoid this, we return the context as a separate field.
+  return { ctx: fullContext };
+};
+
 // Winston by default merges content of `context` among the rest of the fields for the JSON format.
 // That's causing an override of fields `name` and `message` if they are present.
 export const wrapper = (logger: winston.Logger): Logger => {
   return {
     debug: (message, localContext) => {
-      const globalContext = getAsyncLocalStorage().getStore();
-      const fullContext = globalContext || localContext ? { ...globalContext, ...localContext } : undefined;
-      logger.debug(message, fullContext);
+      logger.debug(message, createFullContext(localContext));
     },
     info: (message, localContext) => {
-      const globalContext = getAsyncLocalStorage().getStore();
-      const fullContext = globalContext || localContext ? { ...globalContext, ...localContext } : undefined;
-      logger.info(message, fullContext);
+      logger.info(message, createFullContext(localContext));
     },
     warn: (message, localContext) => {
-      const globalContext = getAsyncLocalStorage().getStore();
-      const fullContext = globalContext || localContext ? { ...globalContext, ...localContext } : undefined;
-      logger.warn(message, fullContext);
+      logger.warn(message, createFullContext(localContext));
     },
     // We need to handle both overloads of the `error` function
     error: (message, errorOrLocalContext: Error | LogContext, localContext?: LogContext) => {
-      const globalContext = getAsyncLocalStorage().getStore();
       // eslint-disable-next-line lodash/prefer-lodash-typecheck
       if (errorOrLocalContext instanceof Error) {
-        const fullContext = globalContext || localContext ? { ...globalContext, ...localContext } : undefined;
-        logger.error(message, errorOrLocalContext, fullContext);
+        logger.error(message, errorOrLocalContext, createFullContext(localContext));
       } else {
-        const fullContext =
-          globalContext || errorOrLocalContext ? { ...globalContext, ...errorOrLocalContext } : undefined;
-        logger.error(message, fullContext);
+        logger.error(message, createFullContext(errorOrLocalContext));
       }
     },
     child: (options) => wrapper(logger.child(options)),

package/src/{index.ts → node-index.ts}

@@ -1,4 +1,6 @@
 // NOTE: Not exporting ESLint rules because they need to be imported in a special way inside .eslintrc.js config.
+export * from './universal-index';
 export * from './logger';
 export * from './processing';
-export * from './blockchain-utilities';
+export * from './config-parsing';
+export * from './config-hash';

package/src/processing/processing.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable jest/prefer-strict-equal */ // Because the errors are thrown from the "vm" module (different context), they are not strictly equal.
 import { ZodError } from 'zod';
 
-import { createEndpoint } from '../../test/fixtures';
+import { createEndpoint } from '../../test/fixtures/processing';
 
 import {
   addReservedParameters,

package/src/processing/unsafe-evaluate.test.ts

@@ -143,7 +143,6 @@ describe(unsafeEvaluateV2.name, () => {
       'string_decoder',
       'timers',
       'tls',
-      'trace_events',
       'tty',
       'url',
       'util',