@whatwg-node/fetch 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @whatwg-node/fetch
+
+## 0.0.1
+
+### Patch Changes
+
+- 889eccf: NEW RELEASES

package/dist/create-node-ponyfill.js

@@ -0,0 +1,281 @@
+const handleFileRequest = require("./handle-file-request");
+
+module.exports = function createNodePonyfill(opts = {}) {
+  const ponyfills = {};
+
+  if (!opts.useNodeFetch) {
+    ponyfills.fetch = globalThis.fetch; // To enable: import {fetch} from 'cross-fetch'
+    ponyfills.Headers = globalThis.Headers;
+    ponyfills.Request = globalThis.Request;
+    ponyfills.Response = globalThis.Response;
+    ponyfills.FormData = globalThis.FormData;
+    ponyfills.File = globalThis.File;
+  }
+
+  ponyfills.AbortController = globalThis.AbortController;
+  ponyfills.ReadableStream = globalThis.ReadableStream;
+  ponyfills.WritableStream = globalThis.WritableStream;
+  ponyfills.TransformStream = globalThis.TransformStream;
+  ponyfills.Blob = globalThis.Blob;
+  ponyfills.crypto = globalThis.crypto;
+
+  if (!ponyfills.AbortController) {
+    const abortControllerModule = require("abort-controller");
+    ponyfills.AbortController =
+      abortControllerModule.default || abortControllerModule;
+  }
+
+  if (!ponyfills.Blob) {
+    const bufferModule = require('buffer')
+    ponyfills.Blob = bufferModule.Blob;
+  }
+
+  if (!ponyfills.Blob) {
+    const formDataModule = require("formdata-node");
+    ponyfills.Blob = formDataModule.Blob
+  }
+
+  if (!ponyfills.ReadableStream) {
+    try {
+      const streamsWeb = require("stream/web");
+
+      ponyfills.ReadableStream = streamsWeb.ReadableStream;
+      ponyfills.WritableStream = streamsWeb.WritableStream;
+      ponyfills.TransformStream = streamsWeb.TransformStream;
+    } catch (e) {
+      const streamsWeb = require("web-streams-polyfill/ponyfill");
+      ponyfills.ReadableStream = streamsWeb.ReadableStream;
+      ponyfills.WritableStream = streamsWeb.WritableStream;
+      ponyfills.TransformStream = streamsWeb.TransformStream;
+    }
+  }
+
+  // ReadableStream doesn't handle aborting properly, so we need to patch it
+  ponyfills.ReadableStream = class PonyfillReadableStream extends ponyfills.ReadableStream {
+    constructor(underlyingSource, ...opts) {
+      super({
+        ...underlyingSource,
+        cancel: (e) => {
+          this.cancelled = true;
+          if (underlyingSource.cancel) {
+            return underlyingSource.cancel(e);
+          }
+        }
+      }, ...opts);
+      this.underlyingSource = underlyingSource;
+    }
+    [Symbol.asyncIterator]() {
+      const asyncIterator = super[Symbol.asyncIterator]();
+      return {
+        next: (...args) => asyncIterator.next(...args),
+        throw: (...args) => asyncIterator.throw(...args),
+        return: async (e) => {
+          const originalResult = await asyncIterator.return(e);
+          if (!this.cancelled) {
+            this.cancelled = true;
+            if (this.underlyingSource.cancel) {
+              await this.underlyingSource.cancel(e);
+            }
+          }
+          return originalResult;
+        }
+      }
+    }
+    async cancel(e) {
+      const originalResult = !super.locked && await super.cancel(e);
+      if (!this.cancelled) {
+        this.cancelled = true;
+        if (this.underlyingSource.cancel) {
+          await this.underlyingSource.cancel(e);
+        }
+      }
+      return originalResult;
+    }
+  }
+
+  if (!ponyfills.crypto) {
+    const cryptoModule = require("crypto");
+    ponyfills.crypto = cryptoModule.webcrypto;
+  }
+
+  // If any of classes of Fetch API is missing, we need to ponyfill them.
+  if (!ponyfills.fetch ||
+    !ponyfills.Request ||
+    !ponyfills.Headers ||
+    !ponyfills.Response ||
+    !ponyfills.FormData ||
+    !ponyfills.File ||
+    opts.useNodeFetch) {
+
+    const [
+      nodeMajorStr,
+      nodeMinorStr
+    ] = process.versions.node.split('.');
+
+    const nodeMajor = parseInt(nodeMajorStr);
+    const nodeMinor = parseInt(nodeMinorStr);
+    const getFormDataMethod = require('./getFormDataMethod');
+
+    if (!opts.useNodeFetch && (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 5))) {
+      const undici = require("undici");
+
+      if (!ponyfills.Headers) {
+        ponyfills.Headers = undici.Headers;
+      }
+
+      const streams = require("stream");
+
+      const OriginalRequest = ponyfills.Request || undici.Request;
+
+      class Request extends OriginalRequest {
+        constructor(requestOrUrl, options) {
+          if (typeof requestOrUrl === "string") {
+            options = options || {};
+            if (options.body != null && options.body.read && options.body.on) {
+              const readable = options.body;
+              options.body = new ponyfills.ReadableStream({
+                pull(controller) {
+                  const chunk = readable.read();
+                  if (chunk != null) {
+                    controller.enqueue(chunk);
+                  } else {
+                    controller.close();
+                  }
+                },
+                close(e) {
+                  readable.destroy(e);
+                }
+              })
+            }
+            super(requestOrUrl, options);
+            const contentType = this.headers.get("content-type");
+            if (contentType && contentType.startsWith("multipart/form-data")) {
+              this.headers.set("content-type", contentType.split(', ')[0]);
+            }
+          } else {
+            super(requestOrUrl);
+          }
+          this.formData = getFormDataMethod(undici.File, opts.formDataLimits);
+        }
+      }
+
+      ponyfills.Request = Request;
+
+      const originalFetch = ponyfills.fetch || undici.fetch;
+
+      const fetch = function (requestOrUrl, options) {
+        if (typeof requestOrUrl === "string") {
+          return fetch(new Request(requestOrUrl, options));
+        }
+        if (requestOrUrl.url.startsWith('file:')) {
+          return handleFileRequest(requestOrUrl.url, ponyfills.Response);
+        }
+        return originalFetch(requestOrUrl);
+      };
+
+      ponyfills.fetch = fetch;
+
+      if (!ponyfills.Response) {
+        ponyfills.Response = undici.Response;
+      }
+
+      if (!ponyfills.FormData) {
+        ponyfills.FormData = undici.FormData;
+      }
+
+      if (!ponyfills.File) {
+        ponyfills.File = undici.File
+      }
+    } else {
+      const nodeFetch = require("node-fetch");
+      const realFetch = ponyfills.fetch || nodeFetch.default || nodeFetch;
+      if (!ponyfills.Headers) {
+        ponyfills.Headers = nodeFetch.Headers;
+        // Sveltekit
+        if (globalThis.Headers) {
+          Object.defineProperty(globalThis.Headers, Symbol.hasInstance, {
+            value(obj) {
+              return obj.get && obj.set && obj.delete && obj.has && obj.append;
+            },
+            configurable: true,
+          })
+        }
+      }
+      const formDataEncoderModule = require("form-data-encoder");
+      const streams = require("stream");
+      const formDataModule = require("formdata-node");
+      if (!ponyfills.FormData) {
+        ponyfills.FormData = formDataModule.FormData
+      }
+      if (!ponyfills.File) {
+        ponyfills.File = formDataModule.File
+      }
+
+      const OriginalRequest = ponyfills.Request || nodeFetch.Request;
+
+      class Request extends OriginalRequest {
+        constructor(requestOrUrl, options) {
+          if (typeof requestOrUrl === "string") {
+            // Support schemaless URIs on the server for parity with the browser.
+            // Ex: //github.com/ -> https://github.com/
+            if (/^\/\//.test(requestOrUrl)) {
+              requestOrUrl = "https:" + requestOrUrl;
+            }
+            options = options || {};
+            options.headers = new ponyfills.Headers(options.headers || {});
+            options.headers.set('Connection', 'keep-alive');
+            if (options.body != null) {
+              if (options.body[Symbol.toStringTag] === 'FormData') {
+                const encoder = new formDataEncoderModule.FormDataEncoder(options.body)
+                for (const headerKey in encoder.headers) {
+                  options.headers.set(headerKey, encoder.headers[headerKey])
+                }
+                options.body = streams.Readable.from(encoder.encode());
+              }
+              if (options.body[Symbol.toStringTag] === 'ReadableStream') {
+                options.body = streams.Readable.fromWeb ? streams.Readable.fromWeb(options.body) : streams.Readable.from(options.body);
+              }
+            }
+            super(requestOrUrl, options);
+          } else {
+            super(requestOrUrl);
+          }
+          this.formData = getFormDataMethod(formDataModule.File, opts.formDataLimits);
+        }
+      }
+      ponyfills.Request = Request;
+      const fetch = function (requestOrUrl, options) {
+        if (typeof requestOrUrl === "string") {
+          return fetch(new Request(requestOrUrl, options));
+        }
+        if (requestOrUrl.url.startsWith('file:')) {
+          return handleFileRequest(requestOrUrl.url, ponyfills.Response);
+        }
+        return realFetch(requestOrUrl);
+      };
+
+      ponyfills.fetch = fetch;
+
+      const OriginalResponse = ponyfills.Response || nodeFetch.Response;
+      ponyfills.Response = function Response(body, init) {
+        if (body != null && body[Symbol.toStringTag] === 'ReadableStream') {
+          const actualBody = streams.Readable.fromWeb ? streams.Readable.fromWeb(body) : streams.Readable.from(body, {
+            emitClose: true,
+            autoDestroy: true,
+          });
+          actualBody.on('pause', () => {
+            body.cancel();
+          })
+          actualBody.on('close', () => {
+            body.cancel();
+          })
+          // Polyfill ReadableStream is not working well with node-fetch's Response
+          return new OriginalResponse(actualBody, init);
+        }
+        return new OriginalResponse(body, init);
+      };
+
+    }
+  }
+  return ponyfills;
+}

package/dist/deno-ponyfill.ts

@@ -0,0 +1,28 @@
+const fetch = globalThis.fetch;
+const Request = globalThis.Request;
+const Response = globalThis.Response;
+const Headers = globalThis.Headers;
+const FormData = globalThis.FormData;
+const AbortController = globalThis.AbortController;
+const ReadableStream = globalThis.ReadableStream;
+const WritableStream = globalThis.WritableStream;
+const TransformStream = globalThis.TransformStream;
+const Blob = globalThis.Blob;
+const File = globalThis.File;
+const crypto = globalThis.crypto;
+
+export const create = () => globalThis;
+export {
+  fetch,
+  Headers,
+  Request,
+  Response,
+  FormData,
+  AbortController,
+  ReadableStream,
+  WritableStream,
+  TransformStream,
+  Blob,
+  File,
+  crypto,
+};

package/dist/getFormDataMethod.js

@@ -0,0 +1,59 @@
+const busboy = require('busboy');
+const streams = require("stream");
+
+module.exports = function getFormDataMethod(File, limits) {
+  return function formData() {
+    if (this.body == null) {
+      return null;
+    }
+    const contentType = this.headers.get('Content-Type');
+    const nodeReadable = this.body.on ? this.body : streams.Readable.from(this.body);
+    const bb = busboy({
+      headers: {
+        'content-type': contentType
+      },
+      limits,
+      defParamCharset: 'utf-8'
+    });
+    return new Promise((resolve, reject) => {
+      const formData = new Map();
+      bb.on('file', (name, fileStream, { filename, mimeType }) => {
+        const chunks = [];
+        fileStream.on('limit', () => {
+          reject(new Error(`File size limit exceeded: ${limits.fileSize} bytes`));
+        })
+        fileStream.on('data', (chunk) => {
+          chunks.push(chunk);
+        })
+        fileStream.on('close', () => {
+          formData.set(name, new File(chunks, filename, { type: mimeType }));
+        });
+      })
+      bb.on('field', (name, value, { nameTruncated, valueTruncated }) => {
+        if (nameTruncated) {
+          reject(new Error(`Field name size exceeded: ${limits.fieldNameSize} bytes`));
+        }
+        if (valueTruncated) {
+          reject(new Error(`Field value size exceeded: ${limits.fieldSize} bytes`));
+        }
+        formData.set(name, value)
+      })
+      bb.on('partsLimit', () => {
+        reject(new Error(`Parts limit exceeded: ${limits.parts}`));
+      })
+      bb.on('filesLimit', () => {
+        reject(new Error(`Files limit exceeded: ${limits.files}`));
+      })
+      bb.on('fieldsLimit', () => {
+        reject(new Error(`Fields limit exceeded: ${limits.fields}`));
+      })
+      bb.on('close', () => {
+        resolve(formData);
+      });
+      bb.on('error', err => {
+        reject(err);
+      })
+      nodeReadable.pipe(bb);
+    })
+  }
+}

package/dist/global-ponyfill.js

@@ -0,0 +1,13 @@
+module.exports.fetch = globalThis.fetch; // To enable: import {fetch} from 'cross-fetch'
+module.exports.Headers = globalThis.Headers;
+module.exports.Request = globalThis.Request;
+module.exports.Response = globalThis.Response;
+module.exports.FormData = globalThis.FormData;
+module.exports.AbortController = globalThis.AbortController;
+module.exports.ReadableStream = globalThis.ReadableStream;
+module.exports.WritableStream = globalThis.WritableStream;
+module.exports.TransformStream = globalThis.TransformStream;
+module.exports.Blob = globalThis.Blob;
+module.exports.File = globalThis.File;
+module.exports.crypto = globalThis.crypto;
+module.exports.createFetch = () => globalThis;

package/dist/handle-file-request.js

@@ -0,0 +1,7 @@
+const { fileURLToPath } = require('url');
+const { createReadStream } = require('fs');
+module.exports = function handleFileRequest(url, Response) {
+    return new Response(
+        createReadStream(fileURLToPath(url)),
+    )
+}

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+/// <reference lib="dom" />
+
+declare const _fetch: typeof fetch;
+declare const _Request: typeof Request;
+declare const _Response: typeof Response;
+declare const _Headers: typeof Headers;
+declare const _FormData: typeof FormData;
+declare const _AbortController: typeof AbortController;
+declare const _ReadableStream: typeof ReadableStream;
+declare const _WritableStream: typeof WritableStream;
+declare const _TransformStream: typeof TransformStream;
+declare const _Blob: typeof Blob;
+declare const _File: typeof File;
+declare const _crypto: typeof crypto;
+
+declare module "@whatwg-node/fetch" {
+  export const fetch: typeof _fetch;
+  export const Request: typeof _Request;
+  export const Response: typeof _Response;
+  export const Headers: typeof _Headers;
+  export const FormData: typeof _FormData;
+  export const AbortController: typeof _AbortController;
+  export const ReadableStream: typeof _ReadableStream;
+  export const WritableStream: typeof _WritableStream;
+  export const TransformStream: typeof _TransformStream;
+  export const Blob: typeof _Blob;
+  export const File: typeof _File;
+  export const crypto: typeof _crypto;
+  export interface FormDataLimits {
+    /* Max field name size (in bytes). Default: 100. */
+    fieldNameSize?: number;
+    /* Max field value size (in bytes). Default: 1MB. */
+    fieldSize?: number;
+    /* Max number of fields. Default: Infinity. */
+    fields?: number;
+    /* For multipart forms, the max file size (in bytes). Default: Infinity. */
+    fileSize?: number;
+    /* For multipart forms, the max number of file fields. Default: Infinity. */
+    files?: number;
+    /* For multipart forms, the max number of parts (fields + files). Default: Infinity. */
+    parts?: number;
+    /* For multipart forms, the max number of header key-value pairs to parse. Default: 2000. */
+    headerSize?: number;
+  }
+  export const create: (opts?: { useNodeFetch?: boolean; formDataLimits?: FormDataLimits }) => ({
+    fetch: typeof _fetch,
+    Request: typeof _Request,
+    Response: typeof _Response,
+    Headers: typeof _Headers,
+    FormData: typeof _FormData,
+    AbortController: typeof _AbortController,
+    ReadableStream: typeof _ReadableStream,
+    WritableStream: typeof _WritableStream,
+    TransformStream: typeof _TransformStream,
+    Blob: typeof _Blob,
+    File: typeof _File,
+    crypto: typeof _crypto
+  });
+}
+

package/dist/node-ponyfill.js

@@ -0,0 +1,17 @@
+
+const createNodePonyfill = require('./create-node-ponyfill');
+const ponyfills = createNodePonyfill();
+
+module.exports.fetch = ponyfills.fetch;
+module.exports.Headers = ponyfills.Headers;
+module.exports.Request = ponyfills.Request;
+module.exports.Response = ponyfills.Response;
+module.exports.FormData = ponyfills.FormData;
+module.exports.AbortController = ponyfills.AbortController;
+module.exports.ReadableStream = ponyfills.ReadableStream;
+module.exports.WritableStream = ponyfills.WritableStream;
+module.exports.TransformStream = ponyfills.TransformStream;
+module.exports.Blob = ponyfills.Blob;
+module.exports.File = ponyfills.File;
+module.exports.crypto = ponyfills.crypto;
+exports.createFetch = createNodePonyfill;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@whatwg-node/fetch",
+  "version": "0.0.1",
+  "description": "Cross Platform Smart Fetch Ponyfill",
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/fetch"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/node-ponyfill.js",
+  "browser": "dist/global-ponyfill.js",
+  "react-native": "dist/global-ponyfill.js",
+  "types": "dist/index.d.ts",
+  "denoify": {
+    "index": "dist/deno-ponyfill.ts"
+  },
+  "dependencies": {
+    "abort-controller": "^3.0.0",
+    "busboy": "^1.6.0",
+    "form-data-encoder": "^1.7.1",
+    "formdata-node": "^4.3.1",
+    "node-fetch": "^2.6.7",
+    "undici": "5.5.1",
+    "web-streams-polyfill": "^3.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}