@chainlink/external-adapter-framework 1.7.6 → 2.0.0

package/generator-adapter/node_modules/form-data-encoder/package.json

@@ -1,70 +0,0 @@
-{
-  "type": "module",
-  "name": "form-data-encoder",
-  "version": "2.1.4",
-  "description": "Encode FormData content into the multipart/form-data format",
-  "repository": "octet-stream/form-data-encoder",
-  "sideEffects": false,
-  "engines": {
-    "node": ">= 14.17"
-  },
-  "keywords": [
-    "form-data",
-    "encoder",
-    "multipart",
-    "files-upload",
-    "async-iterator",
-    "spec-compatible",
-    "form"
-  ],
-  "main": "./lib/index.js",
-  "module": "./lib/index.js",
-  "exports": {
-    "types": "./@type/index.d.ts",
-    "default": "./lib/index.js"
-  },
-  "types": "./@type/index.d.ts",
-  "scripts": {
-    "eslint": "eslint src/**/*.ts",
-    "staged": "lint-staged",
-    "coverage": "c8 npm test",
-    "ci": "c8 npm test && c8 report --reporter=json",
-    "build:types": "tsc --project tsconfig.d.ts.json",
-    "build": "tsc && npm run build:types",
-    "test": "ava --fail-fast",
-    "cleanup": "del-cli @type lib",
-    "prepare": "npm run cleanup && npm run build",
-    "_postinstall": "husky install",
-    "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable"
-  },
-  "author": "Nick K.",
-  "license": "MIT",
-  "devDependencies": {
-    "@octetstream/eslint-config": "6.2.2",
-    "@types/mime-types": "2.1.1",
-    "@types/node": "18.11.9",
-    "@types/sinon": "^10.0.13",
-    "@typescript-eslint/eslint-plugin": "5.44.0",
-    "@typescript-eslint/parser": "5.44.0",
-    "ava": "5.1.0",
-    "c8": "7.12.0",
-    "del-cli": "5.0.0",
-    "eslint": "8.28.0",
-    "eslint-config-airbnb-typescript": "17.0.0",
-    "eslint-import-resolver-typescript": "3.5.2",
-    "eslint-plugin-ava": "13.2.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jsx-a11y": "6.6.1",
-    "eslint-plugin-react": "7.31.11",
-    "formdata-node": "5.0.0",
-    "husky": "8.0.2",
-    "lint-staged": "13.0.3",
-    "pinst": "3.0.0",
-    "sinon": "^14.0.2",
-    "ts-node": "10.9.1",
-    "ttypescript": "1.5.13",
-    "typescript": "4.9.3",
-    "web-streams-polyfill": "4.0.0-beta.3"
-  }
-}

package/generator-adapter/node_modules/form-data-encoder/readme.md

@@ -1,368 +0,0 @@
-# form-data-encoder
-
-Encode `FormData` content into the `multipart/form-data` format
-
-[![Code Coverage](https://codecov.io/github/octet-stream/form-data-encoder/coverage.svg?branch=master)](https://codecov.io/github/octet-stream/form-data-encoder?branch=master)
-[![CI](https://github.com/octet-stream/form-data-encoder/workflows/CI/badge.svg)](https://github.com/octet-stream/form-data-encoder/actions/workflows/ci.yml)
-[![ESLint](https://github.com/octet-stream/form-data-encoder/workflows/ESLint/badge.svg)](https://github.com/octet-stream/form-data-encoder/actions/workflows/eslint.yml)
-
-## Requirements
-
-- Node.js v14.17 or higher;
-- Runtime should support `TextEncoder`, `TextDecoder`, `WeakMap`, `WeakSet` and async generator functions;
-- For TypeScript users: tsc v4.3 or higher.
-
-## Installation
-
-You can install this package using npm:
-
-```sh
-npm install form-data-encoder
-```
-
-Or yarn:
-
-```sh
-yarn add form-data-encoder
-```
-
-Or pnpm:
-
-```sh
-pnpm add form-data-encoder
-```
-
-## Usage
-
-1. To start the encoding process, you need to create a new Encoder instance with the FormData you want to encode:
-
-```js
-import {Readable} from "stream"
-
-import {FormData, File} from "formdata-node"
-import {FormDataEncoder} from "form-data-encoder"
-
-import fetch from "node-fetch"
-
-const form = new FormData()
-
-form.set("greeting", "Hello, World!")
-form.set("file", new File(["On Soviet Moon landscape see binoculars through YOU"], "file.txt"))
-
-const encoder = new FormDataEncoder(form)
-
-const options = {
-  method: "post",
-
-  // Set request headers provided by the Encoder.
-  // The `headers` property has `Content-Type` and `Content-Length` headers.
-  headers: encoder.headers,
-
-  // Create a Readable stream from the Encoder.
-  // You can omit usage of `Readable.from` for HTTP clients whose support async iterables in request body.
-  // The Encoder will yield FormData content portions encoded into the multipart/form-data format as node-fetch consumes the stream.
-  body: Readable.from(encoder.encode()) // or just Readable.from(encoder)
-}
-
-const response = await fetch("https://httpbin.org/post", options)
-
-console.log(await response.json())
-```
-
-2. Encoder support different spec-compatible FormData implementations. Let's try it with [`formdata-polyfill`](https://github.com/jimmywarting/FormData):
-
-```js
-import {Readable} from "stream"
-
-import {FormDataEncoder} from "form-data-encoder"
-import {FormData} from "formdata-polyfill/esm-min.js"
-import {File} from "fetch-blob" // v3
-
-const form = new FormData()
-
-form.set("field", "Some value")
-form.set("file", new File(["File content goes here"], "file.txt"))
-
-const encoder = new FormDataEncoder(form)
-
-const options = {
-  method: "post",
-  headers: encoder.headers,
-  body: Readable.from(encoder)
-}
-
-await fetch("https://httpbin.org/post", options)
-```
-
-3. Because the Encoder is iterable (it has both Symbol.asyncIterator and Symbol.iterator methods), you can use it with different targets. Let's say you want to convert FormData content into `Blob`, for that you can write a function like this:
-
-```js
-import {Readable} from "stream"
-
-import {FormDataEncoder} from "form-data-encoder"
-
-import {FormData, File, Blob, fileFromPath} from "formdata-node"
-
-import fetch from "node-fetch"
-
-const form = new FormData()
-
-form.set("field", "Just a random string")
-form.set("file", new File(["Using files is class amazing"], "file.txt"))
-form.set("fileFromPath", await fileFromPath("path/to/a/file.txt"))
-
-// Note 1: When using with native Blob or fetch-blob@2 you might also need to generate boundary string for your FormDataEncoder instance
-// because Blob will lowercase value of the `type` option and default boundary generator produces a string with both lower and upper cased alphabetical characters. Math.random() should be enough to fix this:
-// const encoder = new FormDataEncoder(form, String(Math.random()))
-const encoder = new FormDataEncoder(form)
-
-const options = {
-  method: "post",
-
-  // Note 2: To use this approach with fetch-blob@2 you probably gonna need to convert the encoder parts output to an array first:
-  // new Blob([...encoder], {type: encoder.contentType})
-  body: new Blob(encoder, {type: encoder.contentType})
-}
-
-const response = await fetch("https://httpbin.org/post", options)
-
-console.log(await response.json())
-```
-
-4. Here's FormData to Blob conversion with async-iterator approach:
-
-```js
-import {FormData} from "formdata-polyfill/esm-min.js"
-import {blobFrom} from "fetch-blob/from.js"
-import {FormDataEncoder} from "form-data-encoder"
-
-import Blob from "fetch-blob"
-import fetch from "node-fetch"
-
-// This approach may require much more RAM compared to the previous one, but it works too.
-async function toBlob(form) {
-  const encoder = new Encoder(form)
-  const chunks = []
-
-  for await (const chunk of encoder) {
-    chunks.push(chunk)
-  }
-
-  return new Blob(chunks, {type: encoder.contentType})
-}
-
-const form = new FormData()
-
-form.set("name", "John Doe")
-form.set("avatar", await blobFrom("path/to/an/avatar.png"), "avatar.png")
-
-const options = {
-  method: "post",
-  body: await toBlob(form)
-}
-
-await fetch("https://httpbin.org/post", options)
-```
-
-5. Another way to convert FormData parts to blob using `form-data-encoder` is making a Blob-ish class:
-
-```js
-import {Readable} from "stream"
-
-import {FormDataEncoder} from "form-data-encoder"
-import {FormData} from "formdata-polyfill/esm-min.js"
-import {blobFrom} from "fetch-blob/from.js"
-
-import Blob from "fetch-blob"
-import fetch from "node-fetch"
-
-class BlobDataItem {
-  constructor(encoder) {
-    this.#encoder = encoder
-    this.#size = encoder.headers["Content-Length"]
-    this.#type = encoder.headers["Content-Type"]
-  }
-
-  get type() {
-    return this.#type
-  }
-
-  get size() {
-    return this.#size
-  }
-
-  stream() {
-    return Readable.from(this.#encoder)
-  }
-
-  get [Symbol.toStringTag]() {
-    return "Blob"
-  }
-}
-
-const form = new FormData()
-
-form.set("name", "John Doe")
-form.set("avatar", await blobFrom("path/to/an/avatar.png"), "avatar.png")
-
-const encoder = new FormDataEncoder(form)
-
-// Note that node-fetch@2 performs more strictness tests for Blob objects, so you may need to do extra steps before you set up request body (like, maybe you'll need to instaniate a Blob with BlobDataItem as one of its blobPart)
-const blob = new BlobDataItem(enocoder) // or new Blob([new BlobDataItem(enocoder)], {type: encoder.contentType})
-
-const options = {
-  method: "post",
-  body: blob
-}
-
-await fetch("https://httpbin.org/post", options)
-```
-
-6. In this example we will pull FormData content into the ReadableStream:
-
-```js
- // This module is only necessary when you targeting Node.js or need web streams that implement Symbol.asyncIterator
-import {ReadableStream} from "web-streams-polyfill/ponyfill/es2018"
-
-import {FormDataEncoder} from "form-data-encoder"
-import {FormData} from "formdata-node"
-
-import fetch from "node-fetch"
-
-function toReadableStream(encoder) {
-  const iterator = encoder.encode()
-
-  return new ReadableStream({
-    async pull(controller) {
-      const {value, done} = await iterator.next()
-
-      if (done) {
-        return controller.close()
-      }
-
-      controller.enqueue(value)
-    }
-  })
-}
-
-const form = new FormData()
-
-form.set("field", "My hovercraft is full of eels")
-
-const encoder = new FormDataEncoder(form)
-
-const options = {
-  method: "post",
-  headers: encoder.headers,
-  body: toReadableStream(encoder)
-}
-
-// Note that this example requires `fetch` to support Symbol.asyncIterator, which node-fetch lacks of (but will support eventually)
-await fetch("https://httpbin.org/post", options)
-```
-
-7. Speaking of async iterables - if HTTP client supports them, you can use encoder like this:
-
-```js
-import {FormDataEncoder} from "form-data-encoder"
-import {FormData} from "formdata-node"
-
-import fetch from "node-fetch"
-
-const form = new FormData()
-
-form.set("field", "My hovercraft is full of eels")
-
-const encoder = new FormDataEncoder(form)
-
-const options = {
-  method: "post",
-  headers: encoder.headers,
-  body: encoder
-}
-
-await fetch("https://httpbin.org/post", options)
-```
-
-8. ...And for those client whose supporting form-data-encoder out of the box, the usage will be much, much more simpler:
-
-```js
-import {FormData} from "formdata-node" // Or any other spec-compatible implementation
-
-import fetch from "node-fetch"
-
-const form = new FormData()
-
-form.set("field", "My hovercraft is full of eels")
-
-const options = {
-  method: "post",
-  body: form
-}
-
-// Note that node-fetch does NOT support form-data-encoder
-await fetch("https://httpbin.org/post", options)
-```
-
-## API
-
-### `class FormDataEncoder`
-
-##### `constructor(form[, boundary, options]) -> {FormDataEncoder}`
-
-  - **{FormDataLike}** form - FormData object to encode. This object must be a spec-compatible FormData implementation.
-  - **{string}** [boundary] - An optional boundary string that will be used by the encoder. If there's no boundary string is present, FormDataEncoder will generate it automatically.
-  - **{object}** [options] - FormDataEncoder options.
-  - **{boolean}** [options.enableAdditionalHeaders = false] - When enabled, the encoder will emit additional per part headers, such as `Content-Length`. Please note that the web clients do not include these, so when enabled this option might cause an error if `multipart/form-data` does not consider additional headers.
-
-Creates a `multipart/form-data` encoder.
-
-#### Instance properties
-
-##### `boundary -> {string}`
-
-Returns boundary string.
-
-##### `contentType -> {string}`
-
-Returns Content-Type header.
-
-##### `contentLength -> {string}`
-
-Return Content-Length header.
-
-##### `headers -> {object}`
-
-Returns headers object with Content-Type and Content-Length header.
-
-#### Instance methods
-
-##### `values() -> {Generator<Uint8Array | FileLike, void, undefined>}`
-
-Creates an iterator allowing to go through form-data parts (with metadata).
-This method **will not** read the files.
-
-##### `encode() -> {AsyncGenerator<Uint8Array, void, undefined>}`
-
-Creates an async iterator allowing to perform the encoding by portions.
-This method **will** also read files.
-
-##### `[Symbol.iterator]() -> {Generator<Uint8Array | FileLike, void, undefined>}`
-
-An alias for `Encoder#values()` method.
-
-##### `[Symbol.asyncIterator]() -> {AsyncGenerator<Uint8Array, void, undefined>}`
-
-An alias for `Encoder#encode()` method.
-
-### `isFile(value) -> {boolean}`
-
-Check if a value is File-ish object.
-
-  - **{unknown}** value - a value to test
-
-### `isFormData(value) -> {boolean}`
-
-Check if a value is FormData-ish object.
-
-  - **{unknown}** value - a value to test

package/generator-adapter/node_modules/get-stream/buffer-stream.js

@@ -1,52 +0,0 @@
-'use strict';
-const {PassThrough: PassThroughStream} = require('stream');
-
-module.exports = options => {
-	options = {...options};
-
-	const {array} = options;
-	let {encoding} = options;
-	const isBuffer = encoding === 'buffer';
-	let objectMode = false;
-
-	if (array) {
-		objectMode = !(encoding || isBuffer);
-	} else {
-		encoding = encoding || 'utf8';
-	}
-
-	if (isBuffer) {
-		encoding = null;
-	}
-
-	const stream = new PassThroughStream({objectMode});
-
-	if (encoding) {
-		stream.setEncoding(encoding);
-	}
-
-	let length = 0;
-	const chunks = [];
-
-	stream.on('data', chunk => {
-		chunks.push(chunk);
-
-		if (objectMode) {
-			length = chunks.length;
-		} else {
-			length += chunk.length;
-		}
-	});
-
-	stream.getBufferedValue = () => {
-		if (array) {
-			return chunks;
-		}
-
-		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-	};
-
-	stream.getBufferedLength = () => length;
-
-	return stream;
-};

package/generator-adapter/node_modules/get-stream/index.d.ts

@@ -1,105 +0,0 @@
-/// <reference types="node"/>
-import {Stream} from 'stream';
-
-declare class MaxBufferErrorClass extends Error {
-	readonly name: 'MaxBufferError';
-	constructor();
-}
-
-declare namespace getStream {
-	interface Options {
-		/**
-		Maximum length of the returned string. If it exceeds this value before the stream ends, the promise will be rejected with a `MaxBufferError` error.
-
-		@default Infinity
-		*/
-		readonly maxBuffer?: number;
-	}
-
-	interface OptionsWithEncoding<EncodingType = BufferEncoding> extends Options {
-		/**
-		[Encoding](https://nodejs.org/api/buffer.html#buffer_buffer) of the incoming stream.
-
-		@default 'utf8'
-		*/
-		readonly encoding?: EncodingType;
-	}
-
-	type MaxBufferError = MaxBufferErrorClass;
-}
-
-declare const getStream: {
-	/**
-	Get the `stream` as a string.
-
-	@returns A promise that resolves when the end event fires on the stream, indicating that there is no more data to be read. The stream is switched to flowing mode.
-
-	@example
-	```
-	import * as fs from 'fs';
-	import getStream = require('get-stream');
-
-	(async () => {
-		const stream = fs.createReadStream('unicorn.txt');
-
-		console.log(await getStream(stream));
-		//               ,,))))))));,
-		//            __)))))))))))))),
-		// \|/       -\(((((''''((((((((.
-		// -*-==//////((''  .     `)))))),
-		// /|\      ))| o    ;-.    '(((((                                  ,(,
-		//          ( `|    /  )    ;))))'                               ,_))^;(~
-		//             |   |   |   ,))((((_     _____------~~~-.        %,;(;(>';'~
-		//             o_);   ;    )))(((` ~---~  `::           \      %%~~)(v;(`('~
-		//                   ;    ''''````         `:       `:::|\,__,%%    );`'; ~
-		//                  |   _                )     /      `:|`----'     `-'
-		//            ______/\/~    |                 /        /
-		//          /~;;.____/;;'  /          ___--,-(   `;;;/
-		//         / //  _;______;'------~~~~~    /;;/\    /
-		//        //  | |                        / ;   \;;,\
-		//       (<_  | ;                      /',/-----'  _>
-		//        \_| ||_                     //~;~~~~~~~~~
-		//            `\_|                   (,~~
-		//                                    \~\
-		//                                     ~~
-	})();
-	```
-	*/
-	(stream: Stream, options?: getStream.OptionsWithEncoding): Promise<string>;
-
-	/**
-	Get the `stream` as a buffer.
-
-	It honors the `maxBuffer` option as above, but it refers to byte length rather than string length.
-	*/
-	buffer(
-		stream: Stream,
-		options?: getStream.Options
-	): Promise<Buffer>;
-
-	/**
-	Get the `stream` as an array of values.
-
-	It honors both the `maxBuffer` and `encoding` options. The behavior changes slightly based on the encoding chosen:
-
-	- When `encoding` is unset, it assumes an [object mode stream](https://nodesource.com/blog/understanding-object-streams/) and collects values emitted from `stream` unmodified. In this case `maxBuffer` refers to the number of items in the array (not the sum of their sizes).
-	- When `encoding` is set to `buffer`, it collects an array of buffers. `maxBuffer` refers to the summed byte lengths of every buffer in the array.
-	- When `encoding` is set to anything else, it collects an array of strings. `maxBuffer` refers to the summed character lengths of every string in the array.
-	*/
-	array<StreamObjectModeType>(
-		stream: Stream,
-		options?: getStream.Options
-	): Promise<StreamObjectModeType[]>;
-	array(
-		stream: Stream,
-		options: getStream.OptionsWithEncoding<'buffer'>
-	): Promise<Buffer[]>;
-	array(
-		stream: Stream,
-		options: getStream.OptionsWithEncoding<BufferEncoding>
-	): Promise<string[]>;
-
-	MaxBufferError: typeof MaxBufferErrorClass;
-};
-
-export = getStream;

package/generator-adapter/node_modules/get-stream/index.js

@@ -1,61 +0,0 @@
-'use strict';
-const {constants: BufferConstants} = require('buffer');
-const stream = require('stream');
-const {promisify} = require('util');
-const bufferStream = require('./buffer-stream');
-
-const streamPipelinePromisified = promisify(stream.pipeline);
-
-class MaxBufferError extends Error {
-	constructor() {
-		super('maxBuffer exceeded');
-		this.name = 'MaxBufferError';
-	}
-}
-
-async function getStream(inputStream, options) {
-	if (!inputStream) {
-		throw new Error('Expected a stream');
-	}
-
-	options = {
-		maxBuffer: Infinity,
-		...options
-	};
-
-	const {maxBuffer} = options;
-	const stream = bufferStream(options);
-
-	await new Promise((resolve, reject) => {
-		const rejectPromise = error => {
-			// Don't retrieve an oversized buffer.
-			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-				error.bufferedData = stream.getBufferedValue();
-			}
-
-			reject(error);
-		};
-
-		(async () => {
-			try {
-				await streamPipelinePromisified(inputStream, stream);
-				resolve();
-			} catch (error) {
-				rejectPromise(error);
-			}
-		})();
-
-		stream.on('data', () => {
-			if (stream.getBufferedLength() > maxBuffer) {
-				rejectPromise(new MaxBufferError());
-			}
-		});
-	});
-
-	return stream.getBufferedValue();
-}
-
-module.exports = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
-module.exports.MaxBufferError = MaxBufferError;

package/generator-adapter/node_modules/got/dist/source/as-promise/index.d.ts

@@ -1,3 +0,0 @@
-import Request from '../core/index.js';
-import { type CancelableRequest } from './types.js';
-export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;