@rpcbase/api 0.86.0 → 0.88.0

package/dist/index.js

@@ -5874,7 +5874,7 @@ function requireBytes() {
   }
   return bytes.exports;
 }
-var lib$1 = { exports: {} };
+var lib$2 = { exports: {} };
 var safer_1;
 var hasRequiredSafer;
 function requireSafer() {
@@ -9595,11 +9595,11 @@ function requireStreams() {
   };
   return streams;
 }
-lib$1.exports;
-var hasRequiredLib$1;
-function requireLib$1() {
-  if (hasRequiredLib$1) return lib$1.exports;
-  hasRequiredLib$1 = 1;
+lib$2.exports;
+var hasRequiredLib$2;
+function requireLib$2() {
+  if (hasRequiredLib$2) return lib$2.exports;
+  hasRequiredLib$2 = 1;
   (function(module) {
     var Buffer2 = requireSafer().Buffer;
     var bomHandling2 = requireBomHandling();
@@ -9723,8 +9723,8 @@ function requireLib$1() {
         throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
       };
     }
-  })(lib$1);
-  return lib$1.exports;
+  })(lib$2);
+  return lib$2.exports;
 }
 var unpipe_1;
 var hasRequiredUnpipe;
@@ -9772,7 +9772,7 @@ function requireRawBody() {
   var asyncHooks = tryRequireAsyncHooks();
   var bytes2 = requireBytes();
   var createError = requireHttpErrors();
-  var iconv = requireLib$1();
+  var iconv = requireLib$2();
   var unpipe = requireUnpipe();
   rawBody = getRawBody;
   var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
@@ -13124,7 +13124,7 @@ function requireRead() {
   hasRequiredRead = 1;
   var createError = requireHttpErrors();
   var getBody = requireRawBody();
-  var iconv = requireLib$1();
+  var iconv = requireLib$2();
   var onFinished2 = requireOnFinished();
   var zlib = require$$4$1;
   var hasBody = requireTypeIs().hasBody;
@@ -15859,20 +15859,20 @@ function requireParse() {
   };
   return parse;
 }
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
+var lib$1;
+var hasRequiredLib$1;
+function requireLib$1() {
+  if (hasRequiredLib$1) return lib$1;
+  hasRequiredLib$1 = 1;
   var stringify = /* @__PURE__ */ requireStringify();
   var parse2 = /* @__PURE__ */ requireParse();
   var formats2 = /* @__PURE__ */ requireFormats();
-  lib = {
+  lib$1 = {
     formats: formats2,
     parse: parse2,
     stringify
   };
-  return lib;
+  return lib$1;
 }
 var urlencoded_1;
 var hasRequiredUrlencoded;
@@ -15882,7 +15882,7 @@ function requireUrlencoded() {
   var createError = requireHttpErrors();
   var debug = requireBrowser$1()("body-parser:urlencoded");
   var read = requireRead();
-  var qs = /* @__PURE__ */ requireLib();
+  var qs = /* @__PURE__ */ requireLib$1();
   var { normalizeOptions } = requireUtils$2();
   urlencoded_1 = urlencoded;
   function urlencoded(options) {
@@ -17265,7 +17265,7 @@ function requireUtils() {
     var etag = requireEtag();
     var mime = requireMimeTypes();
     var proxyaddr = requireProxyAddr();
-    var qs = /* @__PURE__ */ requireLib();
+    var qs = /* @__PURE__ */ requireLib$1();
     var querystring = require$$6$1;
     const { Buffer: Buffer2 } = require$$7$1;
     exports$1.methods = METHODS.map((method) => method.toLowerCase());
@@ -21181,6 +21181,286 @@ function requireExpress() {
   return express;
 }
 var expressExports = requireExpress();
+var lib = { exports: {} };
+var objectAssign;
+var hasRequiredObjectAssign;
+function requireObjectAssign() {
+  if (hasRequiredObjectAssign) return objectAssign;
+  hasRequiredObjectAssign = 1;
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+  function toObject(val) {
+    if (val === null || val === void 0) {
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    }
+    return Object(val);
+  }
+  function shouldUseNative() {
+    try {
+      if (!Object.assign) {
+        return false;
+      }
+      var test1 = new String("abc");
+      test1[5] = "de";
+      if (Object.getOwnPropertyNames(test1)[0] === "5") {
+        return false;
+      }
+      var test2 = {};
+      for (var i = 0; i < 10; i++) {
+        test2["_" + String.fromCharCode(i)] = i;
+      }
+      var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+        return test2[n];
+      });
+      if (order2.join("") !== "0123456789") {
+        return false;
+      }
+      var test3 = {};
+      "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+        test3[letter] = letter;
+      });
+      if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+        return false;
+      }
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  objectAssign = shouldUseNative() ? Object.assign : function(target, source) {
+    var from;
+    var to = toObject(target);
+    var symbols;
+    for (var s = 1; s < arguments.length; s++) {
+      from = Object(arguments[s]);
+      for (var key in from) {
+        if (hasOwnProperty.call(from, key)) {
+          to[key] = from[key];
+        }
+      }
+      if (getOwnPropertySymbols) {
+        symbols = getOwnPropertySymbols(from);
+        for (var i = 0; i < symbols.length; i++) {
+          if (propIsEnumerable.call(from, symbols[i])) {
+            to[symbols[i]] = from[symbols[i]];
+          }
+        }
+      }
+    }
+    return to;
+  };
+  return objectAssign;
+}
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib.exports;
+  hasRequiredLib = 1;
+  (function() {
+    var assign = requireObjectAssign();
+    var vary2 = requireVary();
+    var defaults = {
+      origin: "*",
+      methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+      preflightContinue: false,
+      optionsSuccessStatus: 204
+    };
+    function isString(s) {
+      return typeof s === "string" || s instanceof String;
+    }
+    function isOriginAllowed(origin, allowedOrigin) {
+      if (Array.isArray(allowedOrigin)) {
+        for (var i = 0; i < allowedOrigin.length; ++i) {
+          if (isOriginAllowed(origin, allowedOrigin[i])) {
+            return true;
+          }
+        }
+        return false;
+      } else if (isString(allowedOrigin)) {
+        return origin === allowedOrigin;
+      } else if (allowedOrigin instanceof RegExp) {
+        return allowedOrigin.test(origin);
+      } else {
+        return !!allowedOrigin;
+      }
+    }
+    function configureOrigin(options, req) {
+      var requestOrigin = req.headers.origin, headers = [], isAllowed;
+      if (!options.origin || options.origin === "*") {
+        headers.push([{
+          key: "Access-Control-Allow-Origin",
+          value: "*"
+        }]);
+      } else if (isString(options.origin)) {
+        headers.push([{
+          key: "Access-Control-Allow-Origin",
+          value: options.origin
+        }]);
+        headers.push([{
+          key: "Vary",
+          value: "Origin"
+        }]);
+      } else {
+        isAllowed = isOriginAllowed(requestOrigin, options.origin);
+        headers.push([{
+          key: "Access-Control-Allow-Origin",
+          value: isAllowed ? requestOrigin : false
+        }]);
+        headers.push([{
+          key: "Vary",
+          value: "Origin"
+        }]);
+      }
+      return headers;
+    }
+    function configureMethods(options) {
+      var methods = options.methods;
+      if (methods.join) {
+        methods = options.methods.join(",");
+      }
+      return {
+        key: "Access-Control-Allow-Methods",
+        value: methods
+      };
+    }
+    function configureCredentials(options) {
+      if (options.credentials === true) {
+        return {
+          key: "Access-Control-Allow-Credentials",
+          value: "true"
+        };
+      }
+      return null;
+    }
+    function configureAllowedHeaders(options, req) {
+      var allowedHeaders = options.allowedHeaders || options.headers;
+      var headers = [];
+      if (!allowedHeaders) {
+        allowedHeaders = req.headers["access-control-request-headers"];
+        headers.push([{
+          key: "Vary",
+          value: "Access-Control-Request-Headers"
+        }]);
+      } else if (allowedHeaders.join) {
+        allowedHeaders = allowedHeaders.join(",");
+      }
+      if (allowedHeaders && allowedHeaders.length) {
+        headers.push([{
+          key: "Access-Control-Allow-Headers",
+          value: allowedHeaders
+        }]);
+      }
+      return headers;
+    }
+    function configureExposedHeaders(options) {
+      var headers = options.exposedHeaders;
+      if (!headers) {
+        return null;
+      } else if (headers.join) {
+        headers = headers.join(",");
+      }
+      if (headers && headers.length) {
+        return {
+          key: "Access-Control-Expose-Headers",
+          value: headers
+        };
+      }
+      return null;
+    }
+    function configureMaxAge(options) {
+      var maxAge = (typeof options.maxAge === "number" || options.maxAge) && options.maxAge.toString();
+      if (maxAge && maxAge.length) {
+        return {
+          key: "Access-Control-Max-Age",
+          value: maxAge
+        };
+      }
+      return null;
+    }
+    function applyHeaders(headers, res) {
+      for (var i = 0, n = headers.length; i < n; i++) {
+        var header = headers[i];
+        if (header) {
+          if (Array.isArray(header)) {
+            applyHeaders(header, res);
+          } else if (header.key === "Vary" && header.value) {
+            vary2(res, header.value);
+          } else if (header.value) {
+            res.setHeader(header.key, header.value);
+          }
+        }
+      }
+    }
+    function cors2(options, req, res, next) {
+      var headers = [], method = req.method && req.method.toUpperCase && req.method.toUpperCase();
+      if (method === "OPTIONS") {
+        headers.push(configureOrigin(options, req));
+        headers.push(configureCredentials(options));
+        headers.push(configureMethods(options));
+        headers.push(configureAllowedHeaders(options, req));
+        headers.push(configureMaxAge(options));
+        headers.push(configureExposedHeaders(options));
+        applyHeaders(headers, res);
+        if (options.preflightContinue) {
+          next();
+        } else {
+          res.statusCode = options.optionsSuccessStatus;
+          res.setHeader("Content-Length", "0");
+          res.end();
+        }
+      } else {
+        headers.push(configureOrigin(options, req));
+        headers.push(configureCredentials(options));
+        headers.push(configureExposedHeaders(options));
+        applyHeaders(headers, res);
+        next();
+      }
+    }
+    function middlewareWrapper(o) {
+      var optionsCallback = null;
+      if (typeof o === "function") {
+        optionsCallback = o;
+      } else {
+        optionsCallback = function(req, cb) {
+          cb(null, o);
+        };
+      }
+      return function corsMiddleware(req, res, next) {
+        optionsCallback(req, function(err, options) {
+          if (err) {
+            next(err);
+          } else {
+            var corsOptions = assign({}, defaults, options);
+            var originCallback = null;
+            if (corsOptions.origin && typeof corsOptions.origin === "function") {
+              originCallback = corsOptions.origin;
+            } else if (corsOptions.origin) {
+              originCallback = function(origin, cb) {
+                cb(null, corsOptions.origin);
+              };
+            }
+            if (originCallback) {
+              originCallback(req.headers.origin, function(err2, origin) {
+                if (err2 || !origin) {
+                  next(err2);
+                } else {
+                  corsOptions.origin = origin;
+                  cors2(corsOptions, req, res, next);
+                }
+              });
+            } else {
+              next();
+            }
+          }
+        });
+      };
+    }
+    lib.exports = middlewareWrapper;
+  })();
+  return lib.exports;
+}
+var libExports = requireLib();
+const cors = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
 process.env = {
   ...env,
   ...__rb_env__,
@@ -21188,7 +21468,8 @@ process.env = {
 };
 const initApi = async ({
   app,
-  routes
+  routes,
+  cors: corsOptions
 }) => {
   await initApiClient({ app });
   const registerHandler = (method, path, handler) => {
@@ -21222,24 +21503,36 @@ const initApi = async ({
       registerHandler("delete", path, handler);
     }
   };
+  app.use("/api", cors(corsOptions));
   app.use("/api", expressExports.json({ limit: "8mb" }));
   app.use("/api", function __FIRST_API_MIDDLEWARE__(_req, _res, next) {
     next();
   });
   const routeEntries = Object.entries(routes);
-  const loadRoute = async ([routePath, loadFn]) => {
+  const totalRoutes = routeEntries.length;
+  const loadedModules = /* @__PURE__ */ new Map();
+  let loadedCount = 0;
+  await BBPromise.map(routeEntries, async ([routePath, loadFn]) => {
     const routeModule = await loadFn();
-    if (typeof routeModule.default !== "function") {
+    loadedModules.set(routePath, routeModule);
+    loadedCount += 1;
+    if (loadedCount % 32 === 0 || loadedCount === totalRoutes) {
+      console.log(`loaded ${loadedCount}/${totalRoutes} api routes`);
+    }
+    return routeModule;
+  }, { concurrency: 32 });
+  for (const [routePath] of routeEntries) {
+    const routeModule = loadedModules.get(routePath);
+    if (!routeModule || typeof routeModule.default !== "function") {
       console.warn(`skipping api module without default export: ${routePath}`);
-      return;
+      continue;
     }
     routeModule.default(api);
     const GRAY = "\x1B[90m";
     const RESET = "\x1B[0m";
     const coloredPath = routePath.startsWith("@rpcbase/") ? `${GRAY}${routePath}${RESET}` : routePath;
-    console.log("loaded api route", coloredPath);
-  };
-  await BBPromise.mapSeries(routeEntries, loadRoute);
+    console.log("registered api route", coloredPath);
+  }
   console.log("Done loading routes");
   app.use("/api", (req, res) => {
     res.status(404).json({ error: `Not Found: ${req.method}:${req.originalUrl}` });