@remix-run/node 1.4.3 → 1.5.0-pre.2

package/upload/fileUploadHandler.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="node" />
-import type { UploadHandler } from "../formData";
+import type { UploadHandler } from "@remix-run/server-runtime";
 export declare type FileUploadHandlerFilterArgs = {
     filename: string;
-    encoding: string;
-    mimetype: string;
+    contentType: string;
+    name: string;
 };
 export declare type FileUploadHandlerPathResolverArgs = {
     filename: string;
-    encoding: string;
-    mimetype: string;
+    contentType: string;
+    name: string;
 };
 /**
  * Chooses the path of the file to be uploaded. If a string is not
@@ -34,7 +34,7 @@ export declare type FileUploadHandlerOptions = {
      * The maximum upload size allowed. If the size is exceeded an error will be thrown.
      * Defaults to 3000000B (3MB).
      */
-    maxFileSize?: number;
+    maxPartSize?: number;
     /**
      *
      * @param filename
@@ -43,18 +43,23 @@ export declare type FileUploadHandlerOptions = {
      */
     filter?(args: FileUploadHandlerFilterArgs): boolean | Promise<boolean>;
 };
-export declare function createFileUploadHandler({ directory, avoidFileConflicts, file, filter, maxFileSize, }: FileUploadHandlerOptions): UploadHandler;
+export declare function createFileUploadHandler({ directory, avoidFileConflicts, file, filter, maxPartSize, }?: FileUploadHandlerOptions): UploadHandler;
 export declare class NodeOnDiskFile implements File {
     private filepath;
-    size: number;
     type: string;
+    private slicer?;
     name: string;
     lastModified: number;
     webkitRelativePath: string;
-    constructor(filepath: string, size: number, type: string);
+    constructor(filepath: string, type: string, slicer?: {
+        start: number;
+        end: number;
+    } | undefined);
+    get size(): number;
+    slice(start?: number, end?: number, type?: string): Blob;
     arrayBuffer(): Promise<ArrayBuffer>;
-    slice(start?: any, end?: any, contentType?: any): Blob;
     stream(): ReadableStream<any>;
     stream(): NodeJS.ReadableStream;
     text(): Promise<string>;
+    get [Symbol.toStringTag](): string;
 }

package/upload/fileUploadHandler.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/node v1.4.3
+ * @remix-run/node v1.5.0-pre.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -17,7 +17,31 @@ var fs = require('fs');
 var promises = require('fs/promises');
 var os = require('os');
 var path = require('path');
-var meter = require('./meter.js');
+var stream = require('stream');
+var util = require('util');
+var serverRuntime = require('@remix-run/server-runtime');
+var streamSlice = require('stream-slice');
+var stream$1 = require('../stream.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var streamSlice__namespace = /*#__PURE__*/_interopNamespace(streamSlice);
 
 let defaultFilePathResolver = ({
   filename
@@ -42,45 +66,41 @@ function createFileUploadHandler({
   avoidFileConflicts = true,
   file = defaultFilePathResolver,
   filter,
-  maxFileSize = 3000000
-}) {
+  maxPartSize = 3000000
+} = {}) {
   return async ({
     name,
-    stream,
     filename,
-    encoding,
-    mimetype
+    contentType,
+    data
   }) => {
-    if (filter && !(await filter({
+    if (!filename || filter && !(await filter({
+      name,
       filename,
-      encoding,
-      mimetype
+      contentType
     }))) {
-      stream.resume();
-      return;
+      return undefined;
     }
 
     let dir = typeof directory === "string" ? directory : directory({
+      name,
       filename,
-      encoding,
-      mimetype
+      contentType
     });
 
     if (!dir) {
-      stream.resume();
-      return;
+      return undefined;
     }
 
     let filedir = path.resolve(dir);
     let path$1 = typeof file === "string" ? file : file({
+      name,
       filename,
-      encoding,
-      mimetype
+      contentType
     });
 
     if (!path$1) {
-      stream.resume();
-      return;
+      return undefined;
     }
 
     let filepath = path.resolve(filedir, path$1);
@@ -92,47 +112,76 @@ function createFileUploadHandler({
     await promises.mkdir(path.dirname(filepath), {
       recursive: true
     }).catch(() => {});
-    let meter$1 = new meter.Meter(name, maxFileSize);
-    await new Promise((resolve, reject) => {
-      let writeFileStream = fs.createWriteStream(filepath);
-      let aborted = false;
-
-      async function abort(error) {
-        if (aborted) return;
-        aborted = true;
-        stream.unpipe();
-        meter$1.unpipe();
-        stream.removeAllListeners();
-        meter$1.removeAllListeners();
-        writeFileStream.removeAllListeners();
-        await promises.rm(filepath, {
-          force: true
-        }).catch(() => {});
-        reject(error);
+    let writeFileStream = fs.createWriteStream(filepath);
+    let size = 0;
+    let deleteFile = false;
+
+    try {
+      for await (let chunk of data) {
+        size += chunk.byteLength;
+
+        if (size > maxPartSize) {
+          deleteFile = true;
+          throw new serverRuntime.MaxPartSizeExceededError(name, maxPartSize);
+        }
+
+        writeFileStream.write(chunk);
       }
+    } finally {
+      writeFileStream.end();
+      await util.promisify(stream.finished)(writeFileStream);
 
-      stream.on("error", abort);
-      meter$1.on("error", abort);
-      writeFileStream.on("error", abort);
-      writeFileStream.on("finish", resolve);
-      stream.pipe(meter$1).pipe(writeFileStream);
-    });
-    return new NodeOnDiskFile(filepath, meter$1.bytes, mimetype);
+      if (deleteFile) {
+        await promises.rm(filepath).catch(() => {});
+      }
+    }
+
+    return new NodeOnDiskFile(filepath, contentType);
   };
 }
 class NodeOnDiskFile {
   lastModified = 0;
   webkitRelativePath = "";
 
-  constructor(filepath, size, type) {
+  constructor(filepath, type, slicer) {
     this.filepath = filepath;
-    this.size = size;
     this.type = type;
+    this.slicer = slicer;
     this.name = path.basename(filepath);
   }
 
+  get size() {
+    let stats = fs.statSync(this.filepath);
+
+    if (this.slicer) {
+      let slice = this.slicer.end - this.slicer.start;
+      return slice < 0 ? 0 : slice > stats.size ? stats.size : slice;
+    }
+
+    return stats.size;
+  }
+
+  slice(start, end, type) {
+    var _this$slicer;
+
+    if (typeof start === "number" && start < 0) start = this.size + start;
+    if (typeof end === "number" && end < 0) end = this.size + end;
+    let startOffset = ((_this$slicer = this.slicer) === null || _this$slicer === void 0 ? void 0 : _this$slicer.start) || 0;
+    start = startOffset + (start || 0);
+    end = startOffset + (end || this.size);
+    return new NodeOnDiskFile(this.filepath, typeof type === "string" ? type : this.type, {
+      start,
+      end
+    });
+  }
+
   async arrayBuffer() {
     let stream = fs.createReadStream(this.filepath);
+
+    if (this.slicer) {
+      stream = stream.pipe(streamSlice__namespace.slice(this.slicer.start, this.slicer.end));
+    }
+
     return new Promise((resolve, reject) => {
       let buf = [];
       stream.on("data", chunk => buf.push(chunk));
@@ -141,16 +190,22 @@ class NodeOnDiskFile {
     });
   }
 
-  slice(start, end, contentType) {
-    throw new Error("Method not implemented.");
+  stream() {
+    let stream = fs.createReadStream(this.filepath);
+
+    if (this.slicer) {
+      stream = stream.pipe(streamSlice__namespace.slice(this.slicer.start, this.slicer.end));
+    }
+
+    return stream$1.createReadableStreamFromReadable(stream);
   }
 
-  stream() {
-    return fs.createReadStream(this.filepath);
+  async text() {
+    return stream$1.readableStreamToString(this.stream());
   }
 
-  text() {
-    return promises.readFile(this.filepath, "utf-8");
+  get [Symbol.toStringTag]() {
+    return "File";
   }
 
 }

package/formData.d.ts

@@ -1,27 +0,0 @@
-/// <reference types="node" />
-import type { Readable } from "stream";
-export declare type UploadHandlerArgs = {
-    name: string;
-    stream: Readable;
-    filename: string;
-    encoding: string;
-    mimetype: string;
-};
-export declare type UploadHandler = (args: UploadHandlerArgs) => Promise<string | File | undefined>;
-export declare function isFile(blob: Blob): blob is File;
-declare class NodeFormData implements FormData {
-    private _fields;
-    constructor(form?: any);
-    append(name: string, value: string | Blob, fileName?: string): void;
-    delete(name: string): void;
-    get(name: string): FormDataEntryValue | null;
-    getAll(name: string): FormDataEntryValue[];
-    has(name: string): boolean;
-    set(name: string, value: string | Blob, fileName?: string): void;
-    forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
-    entries(): IterableIterator<[string, FormDataEntryValue]>;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<FormDataEntryValue>;
-    [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
-}
-export { NodeFormData as FormData };

package/formData.js

@@ -1,108 +0,0 @@
-/**
- * @remix-run/node v1.4.3
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function isBlob(value) {
-  return typeof value === "object" && (typeof value.arrayBuffer === "function" || typeof value.size === "number" || typeof value.slice === "function" || typeof value.stream === "function" || typeof value.text === "function" || typeof value.type === "string");
-}
-
-function isFile(blob) {
-  let file = blob;
-  return typeof file.name === "string";
-}
-
-class NodeFormData {
-  constructor(form) {
-    if (typeof form !== "undefined") {
-      throw new Error("Form data on the server is not supported.");
-    }
-
-    this._fields = {};
-  }
-
-  append(name, value, fileName) {
-    if (typeof value !== "string" && !isBlob(value)) {
-      throw new Error("formData.append can only accept a string or Blob");
-    }
-
-    this._fields[name] = this._fields[name] || [];
-
-    if (typeof value === "string" || isFile(value)) {
-      this._fields[name].push(value);
-    } else {
-      this._fields[name].push(new File([value], fileName || "unknown"));
-    }
-  }
-
-  delete(name) {
-    delete this._fields[name];
-  }
-
-  get(name) {
-    let arr = this._fields[name];
-    return (arr === null || arr === void 0 ? void 0 : arr.slice(-1)[0]) ?? null;
-  }
-
-  getAll(name) {
-    let arr = this._fields[name];
-    return arr || [];
-  }
-
-  has(name) {
-    return name in this._fields;
-  }
-
-  set(name, value, fileName) {
-    if (typeof value !== "string" && !isBlob(value)) {
-      throw new Error("formData.set can only accept a string or Blob");
-    }
-
-    if (typeof value === "string" || isFile(value)) {
-      this._fields[name] = [value];
-    } else {
-      this._fields[name] = [new File([value], fileName || "unknown")];
-    }
-  }
-
-  forEach(callbackfn, thisArg) {
-    Object.entries(this._fields).forEach(([name, values]) => {
-      values.forEach(value => callbackfn(value, name, thisArg), thisArg);
-    });
-  }
-
-  entries() {
-    return Object.entries(this._fields).reduce((entries, [name, values]) => {
-      values.forEach(value => entries.push([name, value]));
-      return entries;
-    }, []).values();
-  }
-
-  keys() {
-    return Object.keys(this._fields).values();
-  }
-
-  values() {
-    return Object.entries(this._fields).reduce((results, [name, values]) => {
-      values.forEach(value => results.push(value));
-      return results;
-    }, []).values();
-  }
-
-  *[Symbol.iterator]() {
-    yield* this.entries();
-  }
-
-}
-
-exports.FormData = NodeFormData;
-exports.isFile = isFile;

package/parseMultipartFormData.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { Readable } from "stream";
-import type { UploadHandler } from "./formData";
-import { FormData as NodeFormData } from "./formData";
-/**
- * Allows you to handle multipart forms (file uploads) for your app.
- *
- * @see https://remix.run/api/remix#parsemultipartformdata-node
- */
-export declare function parseMultipartFormData(request: Request, uploadHandler: UploadHandler): Promise<FormData>;
-export declare function internalParseFormData(contentType: string, body: string | Buffer | Readable, abortController?: AbortController, uploadHandler?: UploadHandler): Promise<NodeFormData>;

package/parseMultipartFormData.js

@@ -1,114 +0,0 @@
-/**
- * @remix-run/node v1.4.3
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var stream = require('stream');
-var Busboy = require('busboy');
-var formData = require('./formData.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var Busboy__default = /*#__PURE__*/_interopDefaultLegacy(Busboy);
-
-/**
- * Allows you to handle multipart forms (file uploads) for your app.
- *
- * @see https://remix.run/api/remix#parsemultipartformdata-node
- */
-
-function parseMultipartFormData(request, uploadHandler) {
-  return request.formData(uploadHandler);
-}
-async function internalParseFormData(contentType, body, abortController, uploadHandler) {
-  let formData$1 = new formData.FormData();
-  let fileWorkQueue = [];
-  let stream$1;
-
-  if (typeof body === "string" || Buffer.isBuffer(body)) {
-    stream$1 = stream.Readable.from(body);
-  } else {
-    stream$1 = body;
-  }
-
-  await new Promise(async (resolve, reject) => {
-    try {
-      let busboy = new Busboy__default["default"]({
-        highWaterMark: 2 * 1024 * 1024,
-        headers: {
-          "content-type": contentType
-        }
-      });
-      let aborted = false;
-
-      function abort(error) {
-        if (aborted) return;
-        aborted = true;
-        stream$1.unpipe();
-        stream$1.removeAllListeners();
-        busboy.removeAllListeners();
-        abortController === null || abortController === void 0 ? void 0 : abortController.abort();
-        reject(error || new Error("failed to parse form data"));
-      }
-
-      busboy.on("field", (name, value) => {
-        formData$1.append(name, value);
-      });
-      busboy.on("file", (name, filestream, filename, encoding, mimetype) => {
-        if (uploadHandler) {
-          fileWorkQueue.push((async () => {
-            try {
-              let value = await uploadHandler({
-                name,
-                stream: filestream,
-                filename,
-                encoding,
-                mimetype
-              });
-
-              if (typeof value !== "undefined") {
-                formData$1.append(name, value);
-              }
-            } catch (error) {
-              // Emit error to busboy to bail early if possible
-              busboy.emit("error", error); // It's possible that the handler is doing stuff and fails
-              // *after* busboy has finished. Rethrow the error for surfacing
-              // in the Promise.all(fileWorkQueue) below.
-
-              throw error;
-            } finally {
-              filestream.resume();
-            }
-          })());
-        } else {
-          filestream.resume();
-        }
-
-        if (!uploadHandler) {
-          console.warn(`Tried to parse multipart file upload for field "${name}" but no uploadHandler was provided.` + " Read more here: https://remix.run/api/remix#parseMultipartFormData-node");
-        }
-      });
-      stream$1.on("error", abort);
-      stream$1.on("aborted", abort);
-      busboy.on("error", abort);
-      busboy.on("finish", resolve);
-      stream$1.pipe(busboy);
-    } catch (err) {
-      reject(err);
-    }
-  });
-  await Promise.all(fileWorkQueue);
-  return formData$1;
-}
-
-exports.internalParseFormData = internalParseFormData;
-exports.parseMultipartFormData = parseMultipartFormData;

package/upload/memoryUploadHandler.d.ts

@@ -1,21 +0,0 @@
-import type { UploadHandler } from "../formData";
-export declare type MemoryUploadHandlerFilterArgs = {
-    filename: string;
-    encoding: string;
-    mimetype: string;
-};
-export declare type MemoryUploadHandlerOptions = {
-    /**
-     * The maximum upload size allowed. If the size is exceeded an error will be thrown.
-     * Defaults to 3000000B (3MB).
-     */
-    maxFileSize?: number;
-    /**
-     *
-     * @param filename
-     * @param mimetype
-     * @param encoding
-     */
-    filter?(args: MemoryUploadHandlerFilterArgs): boolean | Promise<boolean>;
-};
-export declare function createMemoryUploadHandler({ filter, maxFileSize, }: MemoryUploadHandlerOptions): UploadHandler;

package/upload/memoryUploadHandler.js

@@ -1,80 +0,0 @@
-/**
- * @remix-run/node v1.4.3
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var stream = require('stream');
-var file = require('@web-std/file');
-var meter = require('./meter.js');
-
-function createMemoryUploadHandler({
-  filter,
-  maxFileSize = 3000000
-}) {
-  return async ({
-    name,
-    stream,
-    filename,
-    encoding,
-    mimetype
-  }) => {
-    if (filter && !(await filter({
-      filename,
-      encoding,
-      mimetype
-    }))) {
-      stream.resume();
-      return;
-    }
-
-    let bufferStream = new BufferStream();
-    await new Promise((resolve, reject) => {
-      let meter$1 = new meter.Meter(name, maxFileSize);
-      let aborted = false;
-
-      async function abort(error) {
-        if (aborted) return;
-        aborted = true;
-        stream.unpipe();
-        meter$1.unpipe();
-        stream.removeAllListeners();
-        meter$1.removeAllListeners();
-        bufferStream.removeAllListeners();
-        reject(error);
-      }
-
-      stream.on("error", abort);
-      meter$1.on("error", abort);
-      bufferStream.on("error", abort);
-      bufferStream.on("finish", resolve);
-      stream.pipe(meter$1).pipe(bufferStream);
-    });
-    return new file.File(bufferStream.data, filename, {
-      type: mimetype
-    });
-  };
-}
-
-class BufferStream extends stream.Transform {
-  constructor() {
-    super();
-    this.data = [];
-  }
-
-  _transform(chunk, _, callback) {
-    this.data.push(chunk);
-    callback();
-  }
-
-}
-
-exports.createMemoryUploadHandler = createMemoryUploadHandler;

package/upload/meter.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import type { TransformCallback } from "stream";
-import { Transform } from "stream";
-export declare class Meter extends Transform {
-    field: string;
-    maxBytes: number | undefined;
-    bytes: number;
-    constructor(field: string, maxBytes: number | undefined);
-    _transform(chunk: any, _: BufferEncoding, callback: TransformCallback): void;
-}
-export declare class MeterError extends Error {
-    field: string;
-    maxBytes: number;
-    constructor(field: string, maxBytes: number);
-}