@gjsify/fetch 0.0.2

package/lib/esm/body.js

@@ -0,0 +1,255 @@
+import { URLSearchParams } from "@gjsify/deno-runtime/ext/url/00_url";
+import { Blob } from "@gjsify/deno-runtime/ext/web/09_file";
+import { PassThrough, pipeline as pipelineCb, Readable, Stream } from "stream";
+import { ReadableStream as StreamWebReadableStream } from "stream/web";
+import { types, deprecate, promisify } from "util";
+import { Buffer } from "buffer";
+import { FormData, formDataToBlob } from "formdata-polyfill/esm.min.js";
+import { FetchError } from "./errors/fetch-error.js";
+import { FetchBaseError } from "./errors/base.js";
+import { isBlob, isURLSearchParameters } from "./utils/is.js";
+const pipeline = promisify(pipelineCb);
+const INTERNALS = Symbol("Body internals");
+class Body {
+  [INTERNALS] = {
+    body: null,
+    stream: null,
+    boundary: "",
+    disturbed: false,
+    error: null
+  };
+  size = 0;
+  constructor(body, options = { size: 0 }) {
+    this.size = options.size || 0;
+    if (body === null) {
+      this[INTERNALS].body = null;
+    } else if (isURLSearchParameters(body)) {
+      this[INTERNALS].body = Buffer.from(body.toString());
+    } else if (isBlob(body)) {
+    } else if (Buffer.isBuffer(body)) {
+    } else if (types.isAnyArrayBuffer(body)) {
+      this[INTERNALS].body = Buffer.from(body);
+    } else if (ArrayBuffer.isView(body)) {
+      this[INTERNALS].body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    } else if (body instanceof Readable) {
+      this[INTERNALS].body = body;
+    } else if (body instanceof ReadableStream || body instanceof StreamWebReadableStream) {
+      this[INTERNALS].body = Readable.fromWeb(body);
+    } else if (body instanceof FormData) {
+      this[INTERNALS].body = formDataToBlob(body);
+      this[INTERNALS].boundary = this[INTERNALS].body.type.split("=")[1];
+    } else if (typeof body === "string") {
+      this[INTERNALS].body = Buffer.from(body);
+    } else if (body instanceof URLSearchParams) {
+      this[INTERNALS].body = Buffer.from(body.toString());
+    } else {
+      console.warn(`Unknown body type "${typeof body}", try to parse the body to string!`);
+      this[INTERNALS].body = Readable.from(typeof body.toString === "function" ? body.toString() : body);
+    }
+    if (Buffer.isBuffer(body)) {
+      this[INTERNALS].stream = Readable.from(body);
+    } else if (isBlob(body)) {
+      this[INTERNALS].stream = Readable.from(body.stream());
+    } else if (body instanceof Readable) {
+      this[INTERNALS].stream = body;
+    }
+    if (body instanceof Stream) {
+      body.on("error", (error_) => {
+        const error = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
+        this[INTERNALS].error = error;
+      });
+    }
+  }
+  get body() {
+    return Readable.toWeb(this[INTERNALS].stream);
+  }
+  get _stream() {
+    return this[INTERNALS].stream;
+  }
+  get bodyUsed() {
+    return this[INTERNALS].disturbed;
+  }
+  /**
+   * Decode response as ArrayBuffer
+   *
+   * @return  Promise
+   */
+  async arrayBuffer() {
+    const { buffer, byteOffset, byteLength } = await consumeBody(this);
+    return buffer.slice(byteOffset, byteOffset + byteLength);
+  }
+  async formData() {
+    const ct = this.headers?.get("content-type");
+    if (ct.startsWith("application/x-www-form-urlencoded")) {
+      const formData = new FormData();
+      const parameters = new URLSearchParams(await this.text());
+      for (const [name, value] of parameters) {
+        formData.append(name, value);
+      }
+      return formData;
+    }
+    const { toFormData } = await import("./utils/multipart-parser.js");
+    return toFormData(this.body, ct);
+  }
+  /**
+   * Return raw response as Blob
+   *
+   * @return Promise
+   */
+  // @ts-ignore
+  async blob() {
+    const ct = this.headers?.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
+    const buf = await this.arrayBuffer();
+    return new Blob([buf], {
+      type: ct
+    });
+  }
+  /**
+   * Decode response as json
+   *
+   * @return  Promise
+   */
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  /**
+   * Decode response as text
+   *
+   * @return  Promise
+   */
+  async text() {
+    const buffer = await consumeBody(this);
+    return new TextDecoder().decode(buffer);
+  }
+}
+Object.defineProperties(Body.prototype, {
+  body: { enumerable: true },
+  bodyUsed: { enumerable: true },
+  arrayBuffer: { enumerable: true },
+  blob: { enumerable: true },
+  json: { enumerable: true },
+  text: { enumerable: true },
+  data: { get: deprecate(
+    () => {
+    },
+    "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
+    "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
+  ) }
+});
+async function consumeBody(data) {
+  if (data[INTERNALS].disturbed) {
+    throw new TypeError(`body used already for: ${data.url}`);
+  }
+  data[INTERNALS].disturbed = true;
+  if (data[INTERNALS].error) {
+    throw data[INTERNALS].error;
+  }
+  const { _stream: body } = data;
+  if (body === null) {
+    return Buffer.alloc(0);
+  }
+  if (!(body instanceof Stream)) {
+    return Buffer.alloc(0);
+  }
+  const accum = [];
+  let accumBytes = 0;
+  try {
+    for await (const chunk of body) {
+      if (data.size > 0 && accumBytes + chunk.length > data.size) {
+        const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
+        body.destroy(error);
+        throw error;
+      }
+      accumBytes += chunk.length;
+      accum.push(chunk);
+    }
+  } catch (error) {
+    const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, "system", error);
+    throw error_;
+  }
+  if (body.readableEnded === true || body._readableState.ended === true) {
+    try {
+      if (accum.every((c) => typeof c === "string")) {
+        return Buffer.from(accum.join(""));
+      }
+      return Buffer.concat(accum, accumBytes);
+    } catch (error) {
+      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, "system", error);
+    }
+  } else {
+    throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+  }
+}
+const clone = (instance, highWaterMark) => {
+  let p1;
+  let p2;
+  let { body } = instance[INTERNALS];
+  if (instance.bodyUsed) {
+    throw new Error("cannot clone body after it is used");
+  }
+  if (body instanceof Stream && typeof body.getBoundary !== "function") {
+    p1 = new PassThrough({ highWaterMark });
+    p2 = new PassThrough({ highWaterMark });
+    body.pipe(p1);
+    body.pipe(p2);
+    instance[INTERNALS].stream = p1;
+    body = p2;
+  }
+  return body;
+};
+const extractContentType = (body, request) => {
+  if (body === null) {
+    return null;
+  }
+  if (typeof body === "string") {
+    return "text/plain;charset=UTF-8";
+  }
+  if (isURLSearchParameters(body)) {
+    return "application/x-www-form-urlencoded;charset=UTF-8";
+  }
+  if (isBlob(body)) {
+    return body.type || null;
+  }
+  if (Buffer.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+    return null;
+  }
+  if (body instanceof FormData) {
+    return `multipart/form-data; boundary=${request[INTERNALS].boundary}`;
+  }
+  if (body instanceof Stream) {
+    return null;
+  }
+  return "text/plain;charset=UTF-8";
+};
+const getTotalBytes = (request) => {
+  const { body } = request[INTERNALS];
+  if (body === null) {
+    return 0;
+  }
+  if (isBlob(body)) {
+    return body.size;
+  }
+  if (Buffer.isBuffer(body)) {
+    return body.length;
+  }
+  if (body && typeof body.getLengthSync === "function") {
+    const anyBody = body;
+    return anyBody.hasKnownLength && anyBody.hasKnownLength() ? anyBody.getLengthSync() : null;
+  }
+  return null;
+};
+const writeToStream = async (dest, { body }) => {
+  if (body === null) {
+    dest.end();
+  } else {
+    await pipeline(body, dest);
+  }
+};
+export {
+  clone,
+  Body as default,
+  extractContentType,
+  getTotalBytes,
+  writeToStream
+};

package/lib/esm/errors/abort-error.js

@@ -0,0 +1,9 @@
+import { FetchBaseError } from "./base.js";
+class AbortError extends FetchBaseError {
+  constructor(message, type = "aborted") {
+    super(message, type);
+  }
+}
+export {
+  AbortError
+};

package/lib/esm/errors/base.js

@@ -0,0 +1,17 @@
+class FetchBaseError extends Error {
+  type;
+  constructor(message, type) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.type = type;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+}
+export {
+  FetchBaseError
+};

package/lib/esm/errors/fetch-error.js

@@ -0,0 +1,21 @@
+import { FetchBaseError } from "./base.js";
+class FetchError extends FetchBaseError {
+  code;
+  errno;
+  erroredSysCall;
+  /**
+   * @param message Error message for human
+   * @param type Error type for machine
+   * @param systemError For Node.js system error
+   */
+  constructor(message, type, systemError) {
+    super(message, type);
+    if (systemError) {
+      this.code = this.errno = systemError.code;
+      this.erroredSysCall = systemError.syscall;
+    }
+  }
+}
+export {
+  FetchError
+};

package/lib/esm/headers.js

@@ -0,0 +1,202 @@
+import Soup from "@girs/soup-3.0";
+import { URLSearchParams } from "@gjsify/deno-runtime/ext/url/00_url";
+import { types } from "util";
+import * as http from "http";
+const validateHeaderName = http.validateHeaderName;
+const validateHeaderValue = http.validateHeaderValue;
+class Headers extends URLSearchParams {
+  /**
+   * Headers class
+   *
+   * @constructor
+   * @param init Response headers
+   */
+  constructor(init) {
+    let result = [];
+    if (init instanceof Headers) {
+      const raw = init.raw();
+      for (const [name, values] of Object.entries(raw)) {
+        result.push(...values.map((value) => [name, value]));
+      }
+    } else if (init == null) {
+    } else if (typeof init === "object" && !types.isBoxedPrimitive(init)) {
+      const method = init[Symbol.iterator];
+      if (method == null) {
+        result.push(...Object.entries(init));
+      } else {
+        if (typeof method !== "function") {
+          throw new TypeError("Header pairs must be iterable");
+        }
+        result = [...init].map((pair) => {
+          if (typeof pair !== "object" || types.isBoxedPrimitive(pair)) {
+            throw new TypeError("Each header pair must be an iterable object");
+          }
+          return [...pair];
+        }).map((pair) => {
+          if (pair.length !== 2) {
+            throw new TypeError("Each header pair must be a name/value tuple");
+          }
+          return [...pair];
+        });
+      }
+    } else {
+      throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
+    }
+    result = result.length > 0 ? result.map(([name, value]) => {
+      validateHeaderName(name);
+      validateHeaderValue(name, String(value));
+      return [String(name).toLowerCase(), String(value)];
+    }) : void 0;
+    super(result);
+    return new Proxy(this, {
+      get(target, p, receiver) {
+        switch (p) {
+          case "append":
+          case "set":
+            return (name, value) => {
+              validateHeaderName(name);
+              validateHeaderValue(name, String(value));
+              return URLSearchParams.prototype[p].call(
+                target,
+                String(name).toLowerCase(),
+                String(value)
+              );
+            };
+          case "delete":
+          case "has":
+          case "getAll":
+            return (name) => {
+              validateHeaderName(name);
+              return URLSearchParams.prototype[p].call(
+                target,
+                String(name).toLowerCase()
+              );
+            };
+          case "keys":
+            return () => {
+              target.sort();
+              return new Set(URLSearchParams.prototype.keys.call(target)).keys();
+            };
+          default:
+            return Reflect.get(target, p, receiver);
+        }
+      }
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+  toString() {
+    return Object.prototype.toString.call(this);
+  }
+  _appendToSoupMessage(message, type = Soup.MessageHeadersType.REQUEST) {
+    const soupHeaders = message ? message.get_request_headers() : new Soup.MessageHeaders(type);
+    for (const header in this.entries()) {
+      soupHeaders.append(header, this.get(header));
+    }
+    return soupHeaders;
+  }
+  static _newFromSoupMessage(message, type = Soup.MessageHeadersType.RESPONSE) {
+    let soupHeaders;
+    const headers = new Headers();
+    if (type === Soup.MessageHeadersType.RESPONSE) {
+      soupHeaders = message.get_response_headers();
+    } else if (type === Soup.MessageHeadersType.REQUEST) {
+      soupHeaders = message.get_request_headers();
+    } else {
+      for (const header in message.get_request_headers()) {
+        headers.append(header, soupHeaders[header]);
+      }
+      soupHeaders = message.get_response_headers();
+    }
+    for (const header in soupHeaders) {
+      headers.append(header, soupHeaders[header]);
+    }
+    return headers;
+  }
+  get(name) {
+    const values = this.getAll(name);
+    if (values.length === 0) {
+      return null;
+    }
+    let value = values.join(", ");
+    if (/^content-encoding$/i.test(name)) {
+      value = value.toLowerCase();
+    }
+    return value;
+  }
+  forEach(callback, thisArg = void 0) {
+    for (const name of this.keys()) {
+      Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+    }
+  }
+  *values() {
+    for (const name of this.keys()) {
+      yield this.get(name);
+    }
+  }
+  /**
+   * 
+   */
+  *entries() {
+    for (const name of this.keys()) {
+      yield [name, this.get(name)];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Node-fetch non-spec method
+   * returning all headers and their values as array
+   */
+  raw() {
+    return [...this.keys()].reduce((result, key) => {
+      result[key] = this.getAll(key);
+      return result;
+    }, {});
+  }
+  /**
+   * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this.keys()].reduce((result, key) => {
+      const values = this.getAll(key);
+      if (key === "host") {
+        result[key] = values[0];
+      } else {
+        result[key] = values.length > 1 ? values : values[0];
+      }
+      return result;
+    }, {});
+  }
+}
+Object.defineProperties(
+  Headers.prototype,
+  ["get", "entries", "forEach", "values"].reduce((result, property) => {
+    result[property] = { enumerable: true };
+    return result;
+  }, {})
+);
+function fromRawHeaders(headers = []) {
+  return new Headers(
+    headers.reduce((result, value, index, array) => {
+      if (index % 2 === 0) {
+        result.push(array.slice(index, index + 2));
+      }
+      return result;
+    }, []).filter(([name, value]) => {
+      try {
+        validateHeaderName(name);
+        validateHeaderValue(name, String(value));
+        return true;
+      } catch {
+        return false;
+      }
+    })
+  );
+}
+export {
+  Headers as default,
+  fromRawHeaders
+};