@chainlink/external-adapter-framework 2.3.0 → 2.5.0

package/generator-adapter/node_modules/mem-fs-editor/node_modules/undici-types/webidl.d.ts

@@ -0,0 +1,222 @@
+// These types are not exported, and are only used internally
+
+/**
+ * Take in an unknown value and return one that is of type T
+ */
+type Converter<T> = (object: unknown) => T
+
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
+
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
+
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
+interface WebidlErrors {
+  exception (opts: { header: string, message: string }): TypeError
+  /**
+   * @description Throw an error when conversion from one type to another has failed
+   */
+  conversionFailed (opts: {
+    prefix: string
+    argument: string
+    types: string[]
+  }): TypeError
+  /**
+   * @description Throw an error when an invalid argument is provided
+   */
+  invalidArgument (opts: {
+    prefix: string
+    value: string
+    type: string
+  }): TypeError
+}
+
+interface WebidlUtil {
+  /**
+   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+   */
+  Type (object: unknown):
+    | 'Undefined'
+    | 'Boolean'
+    | 'String'
+    | 'Symbol'
+    | 'Number'
+    | 'BigInt'
+    | 'Null'
+    | 'Object'
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  ConvertToInt (
+    V: unknown,
+    bitLength: number,
+    signedness: 'signed' | 'unsigned',
+    opts?: ConvertToIntOpts
+  ): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
+}
+
+interface WebidlConverters {
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-DOMString
+   */
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-ByteString
+   */
+  ByteString (V: unknown, prefix: string, argument: string): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-USVString
+   */
+  USVString (V: unknown): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-boolean
+   */
+  boolean (V: unknown): boolean
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-any
+   */
+  any <Value>(V: Value): Value
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-long-long
+   */
+  ['long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
+   */
+  ['unsigned long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+   */
+  ['unsigned long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+   */
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+   */
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource (
+    V: unknown,
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
+
+  ['sequence<ByteString>']: SequenceConverter<string>
+  
+  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
+
+  ['record<ByteString, ByteString>']: RecordConverter<string, string>
+
+  [Key: string]: (...args: any[]) => unknown
+}
+
+export interface Webidl {
+  errors: WebidlErrors
+  util: WebidlUtil
+  converters: WebidlConverters
+
+  /**
+   * @description Performs a brand-check on {@param V} to ensure it is a
+   * {@param cls} object.
+   */
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-sequence
+   * @description Convert a value, V, to a WebIDL sequence type.
+   */
+  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
+
+  illegalConstructor (): never
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-to-record
+   * @description Convert a value, V, to a WebIDL record type.
+   */
+  recordConverter <K extends string, V>(
+    keyConverter: Converter<K>,
+    valueConverter: Converter<V>
+  ): RecordConverter<K, V>
+
+  /**
+   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
+   * interfaces are allowed.
+   */
+  interfaceConverter <Interface>(cls: Interface): (
+    V: unknown,
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
+
+  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
+  // from the converters given?
+  /**
+   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
+   * allowed, values allowed, optional and required keys. Auto converts the value to
+   * a type given a converter.
+   */
+  dictionaryConverter (converters: {
+    key: string,
+    defaultValue?: () => unknown,
+    required?: boolean,
+    converter: (...args: unknown[]) => unknown,
+    allowedValues?: unknown[]
+  }[]): (V: unknown) => Record<string, unknown>
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
+   * @description allows a type, V, to be null
+   */
+  nullableConverter <T>(
+    converter: Converter<T>
+  ): (V: unknown) => ReturnType<typeof converter> | null
+
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
+}

package/generator-adapter/node_modules/mem-fs-editor/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,150 @@
+/// <reference types="node" />
+
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+  
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: any
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}

package/generator-adapter/node_modules/undici-types/dispatcher.d.ts

@@ -244,6 +244,7 @@ declare namespace Dispatcher {
     readonly bodyUsed: boolean;
     arrayBuffer(): Promise<ArrayBuffer>;
     blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
     formData(): Promise<never>;
     json(): Promise<unknown>;
     text(): Promise<string>;

package/generator-adapter/node_modules/undici-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "6.20.0",
+  "version": "6.21.0",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/generator-adapter/node_modules/undici-types/readable.d.ts

@@ -25,6 +25,11 @@ declare class BodyReadable extends Readable {
    */
   blob(): Promise<Blob>
 
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>
+
   /** Consumes and returns the body as an ArrayBuffer
    *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
    */

package/generator-adapter/node_modules/undici-types/webidl.d.ts

@@ -67,6 +67,12 @@ interface WebidlUtil {
    * Stringifies {@param V}
    */
   Stringify (V: any): string
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
 }
 
 interface WebidlConverters {

package/generator-adapter/package.json

@@ -15,6 +15,6 @@
     "@yeoman/types": "1.5.0",
     "mem-fs": "4.1.2",
     "@yeoman/adapter": "2.0.0",
-    "@types/node": "22.13.10"
+    "@types/node": "22.14.0"
   }
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
     "ajv": "8.17.1",
-    "axios": "1.8.2",
+    "axios": "1.8.4",
     "eventsource": "2.0.2",
-    "fastify": "5.2.1",
+    "fastify": "5.2.2",
     "ioredis": "5.6.0",
     "mock-socket": "9.3.1",
     "pino": "9.6.0",
@@ -22,8 +22,8 @@
     "build-generator": "mkdir -p ./dist/src/generator-adapter/generators/app/templates && cp -R scripts/generator-adapter/generators/app/templates dist/src/generator-adapter/generators/app && cp scripts/generator-adapter/package.json dist/src/generator-adapter && cp -R scripts/generator-adapter/node_modules dist/src/generator-adapter && tsc --project scripts/generator-adapter/tsconfig.json && tsc scripts/adapter-generator.ts --outDir dist/src",
     "generate-docs": "typedoc src/**/*.ts",
     "generate-ref-tables": "ts-node scripts/metrics-table.ts > docs/reference-tables/metrics.md && ts-node scripts/ea-settings-table.ts > docs/reference-tables/ea-settings.md && yarn prettier --write docs/reference-tables",
-    "lint-fix": "eslint --max-warnings=0 --fix . && prettier --write ./src/**/*.ts ./test/**/*.ts ./*.{json,yaml}",
-    "lint": "eslint --max-warnings=0 . && prettier --check ./src/**/*.ts ./test/**/*.ts ./*.{json,yaml}",
+    "lint-fix": "eslint --max-warnings=0 --fix . && prettier --write '**/*.{ts,md,json,yaml}'",
+    "lint": "eslint --max-warnings=0 . && prettier --check '**/*.{ts,md,json,yaml}'",
     "portal-path": "echo \"portal:$(readlink -f ./dist/src)\"",
     "test-debug": "EA_HOST=localhost LOG_LEVEL=trace DEBUG=true EA_PORT=0 c8 ava --verbose",
     "test": "tsc -p test/tsconfig.json --noEmit && yarn ava",
@@ -37,15 +37,15 @@
   "devDependencies": {
     "@sinonjs/fake-timers": "14.0.0",
     "@types/eventsource": "1.1.15",
-    "@types/node": "22.13.10",
+    "@types/node": "22.14.0",
     "@types/sinonjs__fake-timers": "8.1.5",
-    "@types/ws": "8.18.0",
-    "@typescript-eslint/eslint-plugin": "8.27.0",
-    "@typescript-eslint/parser": "8.27.0",
+    "@types/ws": "8.18.1",
+    "@typescript-eslint/eslint-plugin": "8.29.0",
+    "@typescript-eslint/parser": "8.29.0",
     "ava": "6.2.0",
     "axios-mock-adapter": "2.1.0",
     "c8": "10.1.3",
-    "eslint": "9.22.0",
+    "eslint": "9.24.0",
     "eslint-config-prettier": "10.1.1",
     "eslint-plugin-tsdoc": "0.4.0",
     "mocksse": "1.0.4",
@@ -53,7 +53,7 @@
     "ts-node": "10.9.2",
     "ts-node-dev": "2.0.0",
     "typedoc": "0.28.1",
-    "typescript": "5.8.2"
+    "typescript": "5.8.3"
   },
   "prettier": {
     "semi": false,

package/util/group-runner.d.ts

@@ -0,0 +1,12 @@
+type Callback<T> = () => Promise<T>;
+type Resolve<T> = (arg: T | Promise<T>) => void;
+export declare class GroupRunner {
+    private groupSize;
+    private currentGroup;
+    private previousStartRunning;
+    constructor(groupSize: number);
+    run<T>(callback: Callback<T>): Promise<T>;
+    startRunning<T>(callback: Callback<T>, resolve: Resolve<T>): Promise<void>;
+    wrapFunction<Args extends unknown[], Return>(func: (...args: Args) => Promise<Return>): (...args: Args) => Promise<Return>;
+}
+export {};

package/util/group-runner.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupRunner = void 0;
+// Runs tasks in groups of a fixed size.
+// The next group won't be started until the previous group is finished.
+//
+// Example usage:
+//
+// const fetchBalances(addresses: string[]): Promise<number[]> {
+//    // addresses can contain thousands of addresses
+//    const groupRunner = new GroupRunner(10)
+//    const getBalance = groupRunner.wrapFunction(fetchBalance)
+//    const balancePromises: Promise<number>[] = []
+//    for (const address of addresses) {
+//      // There will be at most 10 concurrent calls to fetchBalance.
+//      // fetchBalance might do an RPC and we don't want to get rate limited.
+//      balancePromises.push(getBalance(address)))
+//    }
+//    return Promise.all(balancePromises)
+// }
+//
+//
+// Implementation note:
+// Once the size has been reached, we wait for all previous tasks to finish
+// before running the new task.
+// Alternatively, we could run more tasks as soon as some (rather than all)
+// tasks have finished, to make progress sooner, but the former is what's
+// currently used in multiple places in the external-adapters-js repo so we
+// chose that behavior.
+class GroupRunner {
+    constructor(groupSize) {
+        this.groupSize = groupSize;
+        this.currentGroup = [];
+        this.previousStartRunning = Promise.resolve();
+    }
+    // Calls the given callback eventually but makes sure any previous group of
+    // groupSize size has settled before calling and subsequent callbacks.
+    run(callback) {
+        return new Promise((resolve) => {
+            // This creates an implicit queue which guarantees that there are no
+            // concurrent calls into startRunning. This is necessary to avoid having
+            // currentGroup being cleared concurrently.
+            this.previousStartRunning = this.previousStartRunning.then(() => {
+                return this.startRunning(callback, resolve);
+            });
+        });
+    }
+    // Waits for a previous group to finish, if necessary, and then runs the
+    // given callback. When this method resolves, the callback has been called
+    // but not necessarily resolved.
+    async startRunning(callback, resolve) {
+        if (this.currentGroup.length >= this.groupSize) {
+            await Promise.allSettled(this.currentGroup);
+            this.currentGroup = [];
+        }
+        const promise = callback();
+        this.currentGroup.push(promise);
+        resolve(promise);
+    }
+    wrapFunction(func) {
+        return (...args) => {
+            return this.run(() => func(...args));
+        };
+    }
+}
+exports.GroupRunner = GroupRunner;
+//# sourceMappingURL=group-runner.js.map

package/util/group-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-runner.js","sourceRoot":"","sources":["../../../src/util/group-runner.ts"],"names":[],"mappings":";;;AAGA,wCAAwC;AACxC,wEAAwE;AACxE,EAAE;AACF,iBAAiB;AACjB,EAAE;AACF,gEAAgE;AAChE,qDAAqD;AACrD,6CAA6C;AAC7C,+DAA+D;AAC/D,mDAAmD;AACnD,wCAAwC;AACxC,qEAAqE;AACrE,8EAA8E;AAC9E,kDAAkD;AAClD,OAAO;AACP,yCAAyC;AACzC,IAAI;AACJ,EAAE;AACF,EAAE;AACF,uBAAuB;AACvB,2EAA2E;AAC3E,+BAA+B;AAC/B,2EAA2E;AAC3E,yEAAyE;AACzE,2EAA2E;AAC3E,uBAAuB;AACvB,MAAa,WAAW;IAItB,YAAoB,SAAiB;QAAjB,cAAS,GAAT,SAAS,CAAQ;QAH7B,iBAAY,GAAuB,EAAE,CAAA;QACrC,yBAAoB,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAA;IAEvB,CAAC;IAEzC,2EAA2E;IAC3E,sEAAsE;IACtE,GAAG,CAAI,QAAqB;QAC1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,oEAAoE;YACpE,wEAAwE;YACxE,2CAA2C;YAC3C,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC9D,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;YAC7C,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,wEAAwE;IACxE,0EAA0E;IAC1E,gCAAgC;IAChC,KAAK,CAAC,YAAY,CAAI,QAAqB,EAAE,OAAmB;QAC9D,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/C,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;YAC3C,IAAI,CAAC,YAAY,GAAG,EAAE,CAAA;QACxB,CAAC;QACD,MAAM,OAAO,GAAG,QAAQ,EAAE,CAAA;QAC1B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAC/B,OAAO,CAAC,OAAO,CAAC,CAAA;IAClB,CAAC;IAED,YAAY,CACV,IAAwC;QAExC,OAAO,CAAC,GAAG,IAAU,EAAE,EAAE;YACvB,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAA;QACtC,CAAC,CAAA;IACH,CAAC;CACF;AAvCD,kCAuCC"}

package/util/index.d.ts

@@ -34,7 +34,7 @@ export declare class DoubleLinkedList {
  * @returns the result of the promise
  */
 export declare const timeoutPromise: <T>(label: string, promise: Promise<T>, timeout: number) => Promise<T>;
-type DeferredResolve<T> = (value: T) => void;
+type DeferredResolve<T> = (value: T | PromiseLike<T>) => void;
 type DeferredReject = (reason?: unknown) => void;
 /**
  * This function will create a promise, and synchronously return both the promise itself and

package/util/testing-utils.d.ts

@@ -121,3 +121,5 @@ export declare function setEnvVariables(envVariables: NodeJS.ProcessEnv): void;
  * @param provider - singleton WebSocketClassProvider
  */
 export declare const mockWebSocketProvider: (provider: typeof WebSocketClassProvider) => void;
+export declare function makeStub<T>(name: string, obj: T): T;
+export declare const allowedUndefinedStubProps: string[];

package/util/testing-utils.js

@@ -33,13 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockWebSocketProvider = exports.TestAdapter = exports.RedisMock = exports.MockCache = exports.NopTransport = exports.MockWebsocketServer = exports.MockWebsocket = void 0;
+exports.allowedUndefinedStubProps = exports.mockWebSocketProvider = exports.TestAdapter = exports.RedisMock = exports.MockCache = exports.NopTransport = exports.MockWebsocketServer = exports.MockWebsocket = void 0;
 exports.runPeriodicAsyncBackgroundExecution = runPeriodicAsyncBackgroundExecution;
 exports.runAllUntil = runAllUntil;
 exports.runAllUntilTime = runAllUntilTime;
 exports.assertEqualResponses = assertEqualResponses;
 exports.waitUntilResolved = waitUntilResolved;
 exports.setEnvVariables = setEnvVariables;
+exports.makeStub = makeStub;
 const mock_socket_1 = require("mock-socket");
 const client = __importStar(require("prom-client"));
 const cache_1 = require("../cache");
@@ -374,5 +375,68 @@ const mockWebSocketProvider = (provider) => {
     provider.set(MockWebSocket); // eslint-disable-line @typescript-eslint/no-explicit-any
 };
 exports.mockWebSocketProvider = mockWebSocketProvider;
+// Wraps an object such that accessing properties that do not exist will throw
+// an error instead of returning undefined.
+//
+// This is useful during unit test creation, as it makes it clear which
+// properties are missing rather than giving an error later on that undefined
+// doesn't have some other property.
+//
+// Once a test is passing, you can remove the wrapping and the test will still
+// pass. But it might be useful to keep it for when the code under test is
+// changed later on.
+//
+// Example usage:
+//
+// In code under test:
+//
+//   function doThing(obj) {
+//     const baz = obj.foo.baz
+//     ...
+//   }
+//
+// In test code:
+//
+//   const obj = makeStub('obj', { foo: { bar: 1 } })
+//   doThing(obj)
+//
+// Throws (and logs, in case the error is caught by the code under test):
+// Error: Property 'obj.foo.baz' does not exist
+function makeStub(name, obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    return new Proxy(obj, {
+        get: (target, prop) => {
+            const propName = `${name}.${String(prop)}`;
+            if (!(prop in target) && !isStubPropAllowedUndefined(prop)) {
+                const message = `Property '${propName}' does not exist`;
+                // eslint-disable-next-line no-console
+                console.error(message);
+                throw new Error(message);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return makeStub(propName, target[prop]);
+        },
+    });
+}
+// Properties checked by jest which don't need to be defined:
+exports.allowedUndefinedStubProps = [
+    '$$typeof',
+    'nodeType',
+    'tagName',
+    'hasAttribute',
+    '@@__IMMUTABLE_ITERABLE__@@',
+    '@@__IMMUTABLE_RECORD__@@',
+    'toJSON',
+    'asymmetricMatch',
+    'then',
+];
+const isStubPropAllowedUndefined = (prop) => {
+    if (typeof prop === 'symbol') {
+        return true;
+    }
+    return exports.allowedUndefinedStubProps.includes(prop);
+};
 /* c8 ignore stop */ // eslint-disable-line
 //# sourceMappingURL=testing-utils.js.map