hono-upload/dist/index.js

A memory efficient upload handler for hono.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var src_exports = {};
__export(src_exports, {
  uploadErrors: () => uploadErrors,
  uploadHandler: () => uploadHandler
});
module.exports = __toCommonJS(src_exports);
var import_busboy = __toESM(require("busboy"));
const uploadErrors = {
  MISSING_BODY: "MISSING_BODY",
  INVALID_CONTENT_TYPE: "INVALID_CONTENT_TYPE",
  CONTENT_LENGTH_MISSING: "CONTENT_LENGTH_MISSING",
  MAX_FILE_SIZE_EXCEEDED: "MAX_FILE_SIZE_EXCEEDED",
  MAX_ONE_FILE_ALLOWED: "MAX_ONE_FILE_ALLOWED"
};
async function uploadHandler({
  queuingStrategy,
  onFile,
  ctx,
  ...params
}) {
  const request = ctx.req.raw;
  const stream = request.body;
  if (!stream) {
    throw new Error(uploadErrors.MISSING_BODY);
  }
  const contentType = request.headers.get("Content-Type") || "";
  if (!contentType.includes("multipart/form-data")) {
    throw new Error(uploadErrors.INVALID_CONTENT_TYPE);
  }
  const maxFileSize = (params.maxFileSize || Infinity) + 2 * 1024 * 1024;
  const requestSize = parseInt(request.headers.get("Content-Length") || "0", 10);
  if (requestSize === 0) {
    throw new Error(uploadErrors.CONTENT_LENGTH_MISSING);
  }
  if (maxFileSize && requestSize > maxFileSize) {
    throw new Error(uploadErrors.MAX_FILE_SIZE_EXCEEDED, {
      cause: new Error(requestSize.toString())
    });
  }
  const headers = Object.fromEntries(ctx.req.raw.headers.entries());
  const queueStrategy = {
    highWaterMark: 3,
    size: () => 1,
    ...queuingStrategy
  };
  return new Promise((resolve, reject) => {
    const busboy = (0, import_busboy.default)({
      headers,
      highWaterMark: queueStrategy.highWaterMark,
      limits: {
        fields: 0,
        files: 1
      }
    });
    const writableStream = new WritableStream(
      {
        abort(reason) {
          reject(reason);
        },
        write(chunk) {
          busboy.write(chunk);
        },
        close() {
          busboy.end();
        }
      },
      queueStrategy
    );
    function cleanup() {
      busboy.removeListener("error", onBusboyError);
      busboy.removeListener("file", onBusboyFile);
    }
    let result;
    function onBusboyError() {
      result = void 0;
      cleanup();
    }
    function onBusboyFile(field, file, fileInfo) {
      try {
        const writeFile = onFile(file, {
          ...fileInfo,
          field
        });
        if (writeFile instanceof Promise) {
          writeFile.then((v) => {
            result = v;
            busboy.emit("close");
          }).catch((err) => {
            reject(err);
          });
        } else {
          result = writeFile;
        }
      } catch (e) {
        reject(e);
      }
    }
    busboy.on("file", onBusboyFile);
    busboy.on("error", onBusboyError);
    busboy.on("close", () => {
      writableStream.close().catch(() => {
      });
      cleanup();
      if (result)
        resolve(result);
    });
    stream.pipeTo(writableStream).catch((e) => {
      reject(e);
    });
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  uploadErrors,
  uploadHandler
});
//# sourceMappingURL=index.js.map