@remix-run/node 0.0.0-experimental-ab9dac4f

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2021 Remix Software Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# Welcome to Remix!
+
+[Remix](https://remix.run) is a web framework that helps you build better websites with React.
+
+To get started, open a new shell and run:
+
+```sh
+$ npx create-remix@latest
+```
+
+Then follow the prompts you see in your terminal.
+
+For more information about Remix, [visit remix.run](https://remix.run)!

package/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function atob(a: string): string;
+export declare function btoa(b: string): string;

package/base64.js

@@ -0,0 +1,23 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 atob(a) {
+  return Buffer.from(a, "base64").toString("binary");
+}
+function btoa(b) {
+  return Buffer.from(b, "binary").toString("base64");
+}
+
+exports.atob = atob;
+exports.btoa = btoa;

package/cookieSigning.d.ts

@@ -0,0 +1,3 @@
+import type { InternalSignFunctionDoNotUseMe, InternalUnsignFunctionDoNotUseMe } from "@remix-run/server-runtime/cookieSigning";
+export declare const sign: InternalSignFunctionDoNotUseMe;
+export declare const unsign: InternalUnsignFunctionDoNotUseMe;

package/cookieSigning.js

@@ -0,0 +1,29 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 cookieSignature = require('cookie-signature');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var cookieSignature__default = /*#__PURE__*/_interopDefaultLegacy(cookieSignature);
+
+const sign = async (value, secret) => {
+  return cookieSignature__default["default"].sign(value, secret);
+};
+const unsign = async (signed, secret) => {
+  return cookieSignature__default["default"].unsign(signed, secret);
+};
+
+exports.sign = sign;
+exports.unsign = unsign;

package/errors.d.ts

@@ -0,0 +1,9 @@
+import type { NullableMappedPosition } from "source-map";
+import { SourceMapConsumer } from "source-map";
+export declare const UNKNOWN_LOCATION_POSITION = "<unknown location>";
+export declare function formatServerError(error: Error): Promise<Error>;
+export declare function formatStackTrace(error: Error): Promise<string | undefined>;
+export declare function mapToSourceFile(cache: Map<string, SourceMapConsumer>, stackLine: string): Promise<string>;
+export declare function relativeFilename(filename: string): string;
+export declare function getOriginalSourcePosition(smc: SourceMapConsumer, line: number, column: number): NullableMappedPosition;
+export declare function getSourceContentForPosition(smc: SourceMapConsumer, pos: NullableMappedPosition): string;

package/errors.js

@@ -0,0 +1,123 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 fs = require('fs');
+var fsp = require('fs/promises');
+var path = require('path');
+var sourceMap = require('source-map');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var fsp__default = /*#__PURE__*/_interopDefaultLegacy(fsp);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+const ROOT = process.cwd() + path__default["default"].sep;
+const SOURCE_PATTERN = /(?<at>\s+at.+)\((?<filename>.+):(?<line>\d+):(?<column>\d+)\)/;
+const UNKNOWN_LOCATION_POSITION = "<unknown location>";
+async function formatServerError(error) {
+  try {
+    error.stack = await formatStackTrace(error);
+  } catch {}
+
+  return error;
+}
+async function formatStackTrace(error) {
+  var _error$stack;
+
+  const cache = new Map();
+  const lines = ((_error$stack = error.stack) === null || _error$stack === void 0 ? void 0 : _error$stack.split("\n")) || [];
+  const promises = lines.map(line => mapToSourceFile(cache, line));
+  const stack = (await Promise.all(promises)).join("\n") || error.stack;
+  return stack;
+}
+async function mapToSourceFile(cache, stackLine) {
+  let match = SOURCE_PATTERN.exec(stackLine);
+
+  if (!(match !== null && match !== void 0 && match.groups)) {
+    // doesn't match pattern but may still have a filename
+    return relativeFilename(stackLine);
+  }
+
+  let {
+    at,
+    filename
+  } = match.groups;
+  let line = match.groups.line;
+  let column = match.groups.column;
+  let mapFilename = `${filename}.map`;
+  let smc = cache.get(mapFilename);
+  filename = relativeFilename(filename);
+
+  if (!smc) {
+    if (await fileExists(mapFilename)) {
+      // read source map and setup consumer
+      const map = JSON.parse(await fsp__default["default"].readFile(mapFilename, "utf-8"));
+      map.sourceRoot = path__default["default"].dirname(mapFilename);
+      smc = await new sourceMap.SourceMapConsumer(map);
+      cache.set(mapFilename, smc);
+    }
+  }
+
+  if (smc) {
+    const pos = getOriginalSourcePosition(smc, parseInt(line, 10), parseInt(column, 10));
+
+    if (pos.source) {
+      filename = relativeFilename(pos.source);
+      line = pos.line || "?";
+      column = pos.column || "?";
+      at = `    at \`${getSourceContentForPosition(smc, pos)}\` `;
+    }
+  }
+
+  return `${at}(${filename}:${line}:${column})`;
+}
+function relativeFilename(filename) {
+  if (filename.includes("route-module:")) {
+    filename = filename.substring(filename.indexOf("route-module:"));
+  }
+
+  return filename.replace("route-module:", "").replace(ROOT, "./");
+}
+function getOriginalSourcePosition(smc, line, column) {
+  return smc.originalPositionFor({
+    line,
+    column
+  });
+}
+function getSourceContentForPosition(smc, pos) {
+  let src = null;
+
+  if (pos !== null && pos !== void 0 && pos.source && typeof pos.line === "number") {
+    src = smc.sourceContentFor(pos.source);
+  }
+
+  if (!src) {
+    return UNKNOWN_LOCATION_POSITION;
+  }
+
+  return src.split("\n")[pos.line - 1].trim();
+}
+
+function fileExists(filename) {
+  return fsp__default["default"].access(filename, fs__default["default"].constants.F_OK).then(() => true).catch(() => false);
+}
+
+exports.UNKNOWN_LOCATION_POSITION = UNKNOWN_LOCATION_POSITION;
+exports.formatServerError = formatServerError;
+exports.formatStackTrace = formatStackTrace;
+exports.getOriginalSourcePosition = getOriginalSourcePosition;
+exports.getSourceContentForPosition = getSourceContentForPosition;
+exports.mapToSourceFile = mapToSourceFile;
+exports.relativeFilename = relativeFilename;

package/fetch.d.ts

@@ -0,0 +1,16 @@
+import type { RequestInfo, RequestInit, Response } from "node-fetch";
+import { Request as NodeRequest } from "node-fetch";
+import { RemixFormData } from "./form-data";
+export type { HeadersInit, RequestInfo, RequestInit, ResponseInit } from "node-fetch";
+export { Headers, Response } from "node-fetch";
+export declare class Request extends NodeRequest {
+    formData(): Promise<RemixFormData>;
+}
+/**
+ * A `fetch` function for node that matches the web Fetch API. Based on
+ * `node-fetch`.
+ *
+ * @see https://github.com/node-fetch/node-fetch
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+ */
+export declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;

package/fetch.js

@@ -0,0 +1,56 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 nodeFetch = require('node-fetch');
+var formData = require('./form-data.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
+
+class Request extends nodeFetch.Request {
+  async formData() {
+    let body = await this.clone().text();
+    return new formData.RemixFormData(body);
+  }
+
+}
+/**
+ * A `fetch` function for node that matches the web Fetch API. Based on
+ * `node-fetch`.
+ *
+ * @see https://github.com/node-fetch/node-fetch
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+ */
+
+function fetch(input, init) {
+  // Default to { compress: false } so responses can be proxied through more
+  // easily in loaders. Otherwise the response stream encoding will not match
+  // the Content-Encoding response header.
+  return nodeFetch__default["default"](input, {
+    compress: false,
+    ...init
+  });
+}
+
+Object.defineProperty(exports, 'Headers', {
+  enumerable: true,
+  get: function () { return nodeFetch.Headers; }
+});
+Object.defineProperty(exports, 'Response', {
+  enumerable: true,
+  get: function () { return nodeFetch.Response; }
+});
+exports.Request = Request;
+exports.fetch = fetch;

package/form-data.d.ts

@@ -0,0 +1,15 @@
+export declare class RemixFormData implements FormData {
+    private _params;
+    constructor(body?: string);
+    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]>;
+}

package/form-data.js

@@ -0,0 +1,74 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 });
+
+class RemixFormData {
+  constructor(body) {
+    this._params = new URLSearchParams(body);
+  }
+
+  append(name, value, fileName) {
+    if (typeof value !== "string") {
+      throw new Error("formData.append can only accept a string");
+    }
+
+    this._params.append(name, value);
+  }
+
+  delete(name) {
+    this._params.delete(name);
+  }
+
+  get(name) {
+    return this._params.get(name);
+  }
+
+  getAll(name) {
+    return this._params.getAll(name);
+  }
+
+  has(name) {
+    return this._params.has(name);
+  }
+
+  set(name, value, fileName) {
+    if (typeof value !== "string") {
+      throw new Error("formData.set can only accept a string");
+    }
+
+    this._params.set(name, value);
+  }
+
+  forEach(callbackfn, thisArg) {
+    this._params.forEach(callbackfn, thisArg);
+  }
+
+  entries() {
+    return this._params.entries();
+  }
+
+  keys() {
+    return this._params.keys();
+  }
+
+  values() {
+    return this._params.values();
+  }
+
+  *[Symbol.iterator]() {
+    yield* this._params;
+  }
+
+}
+
+exports.RemixFormData = RemixFormData;

package/globals.d.ts

@@ -0,0 +1,17 @@
+import type { InternalSignFunctionDoNotUseMe, InternalUnsignFunctionDoNotUseMe } from "@remix-run/server-runtime/cookieSigning";
+import { atob, btoa } from "./base64";
+declare global {
+    namespace NodeJS {
+        interface Global {
+            atob: typeof atob;
+            btoa: typeof btoa;
+            Headers: typeof Headers;
+            Request: typeof Request;
+            Response: typeof Response;
+            fetch: typeof fetch;
+            sign: InternalSignFunctionDoNotUseMe;
+            unsign: InternalUnsignFunctionDoNotUseMe;
+        }
+    }
+}
+export declare function installGlobals(): void;

package/globals.js

@@ -0,0 +1,31 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 base64 = require('./base64.js');
+var cookieSigning = require('./cookieSigning.js');
+var fetch = require('./fetch.js');
+var nodeFetch = require('node-fetch');
+
+function installGlobals() {
+  global.atob = base64.atob;
+  global.btoa = base64.btoa;
+  global.Headers = nodeFetch.Headers;
+  global.Request = fetch.Request;
+  global.Response = nodeFetch.Response;
+  global.fetch = fetch.fetch;
+  global.sign = cookieSigning.sign;
+  global.unsign = cookieSigning.unsign;
+}
+
+exports.installGlobals = installGlobals;

package/index.d.ts

@@ -0,0 +1,5 @@
+export { formatServerError } from "./errors";
+export type { HeadersInit, RequestInfo, RequestInit, ResponseInit } from "./fetch";
+export { Headers, Request, Response, fetch } from "./fetch";
+export { installGlobals } from "./globals";
+export { createFileSessionStorage } from "./sessions/fileStorage";

package/index.js

@@ -0,0 +1,35 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 errors = require('./errors.js');
+var fetch = require('./fetch.js');
+var globals = require('./globals.js');
+var fileStorage = require('./sessions/fileStorage.js');
+var nodeFetch = require('node-fetch');
+
+
+
+exports.formatServerError = errors.formatServerError;
+exports.Request = fetch.Request;
+exports.fetch = fetch.fetch;
+exports.installGlobals = globals.installGlobals;
+exports.createFileSessionStorage = fileStorage.createFileSessionStorage;
+Object.defineProperty(exports, 'Headers', {
+  enumerable: true,
+  get: function () { return nodeFetch.Headers; }
+});
+Object.defineProperty(exports, 'Response', {
+  enumerable: true,
+  get: function () { return nodeFetch.Response; }
+});

package/magicExports/browser/platform.js

@@ -0,0 +1,11 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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
+ */
+export { createFileSessionStorage } from '@remix-run/node';

package/magicExports/platform.d.ts

@@ -0,0 +1 @@
+export { createFileSessionStorage } from "@remix-run/node";

package/magicExports/platform.js

@@ -0,0 +1,22 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 node = require('@remix-run/node');
+
+
+
+Object.defineProperty(exports, 'createFileSessionStorage', {
+	enumerable: true,
+	get: function () { return node.createFileSessionStorage; }
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@remix-run/node",
+  "description": "Node.js platform abstractions for Remix",
+  "version": "0.0.0-experimental-ab9dac4f",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remix-run/remix",
+    "directory": "packages/remix-node"
+  },
+  "bugs": {
+    "url": "https://github.com/remix-run/remix/issues"
+  },
+  "dependencies": {
+    "@remix-run/server-runtime": "0.0.0-experimental-ab9dac4f",
+    "@types/node-fetch": "^2.5.12",
+    "cookie-signature": "^1.1.0",
+    "node-fetch": "^2.6.1",
+    "source-map": "^0.7.3"
+  },
+  "devDependencies": {
+    "@types/cookie-signature": "^1.0.3"
+  },
+  "sideEffects": false
+}

package/sessions/fileStorage.d.ts

@@ -0,0 +1,20 @@
+import type { SessionStorage, SessionIdStorageStrategy } from "@remix-run/server-runtime";
+interface FileSessionStorageOptions {
+    /**
+     * The Cookie used to store the session id on the client, or options used
+     * to automatically create one.
+     */
+    cookie?: SessionIdStorageStrategy["cookie"];
+    /**
+     * The directory to use to store session files.
+     */
+    dir: string;
+}
+/**
+ * Creates a SessionStorage that stores session data on a filesystem.
+ *
+ * The advantage of using this instead of cookie session storage is that
+ * files may contain much more data than cookies.
+ */
+export declare function createFileSessionStorage({ cookie, dir }: FileSessionStorageOptions): SessionStorage;
+export {};

package/sessions/fileStorage.js

@@ -0,0 +1,137 @@
+/**
+ * @remix-run/node v0.0.0-experimental-ab9dac4f
+ *
+ * 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 crypto = require('crypto');
+var fs = require('fs');
+var path = require('path');
+var serverRuntime = require('@remix-run/server-runtime');
+
+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 crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/**
+ * Creates a SessionStorage that stores session data on a filesystem.
+ *
+ * The advantage of using this instead of cookie session storage is that
+ * files may contain much more data than cookies.
+ */
+function createFileSessionStorage({
+  cookie,
+  dir
+}) {
+  return serverRuntime.createSessionStorage({
+    cookie,
+
+    async createData(data, expires) {
+      let content = JSON.stringify({
+        data,
+        expires
+      });
+
+      while (true) {
+        // TODO: Once node v16 is available on AWS we should use the webcrypto
+        // API's crypto.getRandomValues() function here instead.
+        let randomBytes = crypto__namespace.randomBytes(8); // This storage manages an id space of 2^64 ids, which is far greater
+        // than the maximum number of files allowed on an NTFS or ext4 volume
+        // (2^32). However, the larger id space should help to avoid collisions
+        // with existing ids when creating new sessions, which speeds things up.
+
+        let id = Buffer.from(randomBytes).toString("hex");
+
+        try {
+          let file = getFile(dir, id);
+          await fs.promises.mkdir(path__namespace.dirname(file), {
+            recursive: true
+          });
+          await fs.promises.writeFile(file, content, {
+            encoding: "utf-8",
+            flag: "wx"
+          });
+          return id;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
+      }
+    },
+
+    async readData(id) {
+      try {
+        let file = getFile(dir, id);
+        let content = JSON.parse(await fs.promises.readFile(file, "utf-8"));
+        let data = content.data;
+        let expires = typeof content.expires === "string" ? new Date(content.expires) : null;
+
+        if (!expires || expires > new Date()) {
+          return data;
+        } // Remove expired session data.
+
+
+        if (expires) await fs.promises.unlink(file);
+        return null;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        return null;
+      }
+    },
+
+    async updateData(id, data, expires) {
+      let content = JSON.stringify({
+        data,
+        expires
+      });
+      let file = getFile(dir, id);
+      await fs.promises.mkdir(path__namespace.dirname(file), {
+        recursive: true
+      });
+      await fs.promises.writeFile(file, content, "utf-8");
+    },
+
+    async deleteData(id) {
+      try {
+        await fs.promises.unlink(getFile(dir, id));
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+
+  });
+}
+
+function getFile(dir, id) {
+  // Divide the session id up into a directory (first 2 bytes) and filename
+  // (remaining 6 bytes) to reduce the chance of having very large directories,
+  // which should speed up file access. This is a maximum of 2^16 directories,
+  // each with 2^48 files.
+  return path__namespace.join(dir, id.slice(0, 4), id.slice(4));
+}
+
+exports.createFileSessionStorage = createFileSessionStorage;