@elliemae/pui-cli 7.0.0-alpha.1 → 7.0.0-alpha.4

package/dist/cjs/monorepo/set-workspace-version.js

@@ -0,0 +1,44 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_workspace_version_exports = {};
+__export(set_workspace_version_exports, {
+  setWorkspaceVersion: () => setWorkspaceVersion
+});
+module.exports = __toCommonJS(set_workspace_version_exports);
+var import_promises = require("node:fs/promises");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_normalize_path = __toESM(require("normalize-path"), 1);
+var import_utils = require("./utils.js");
+const monorepoRoot = (0, import_normalize_path.default)((0, import_utils.findMonoRepoRoot)() || "");
+const setWorkspaceVersion = async () => {
+  const files = await (0, import_fast_glob.default)([
+    `${monorepoRoot}/libs/*/package.json`,
+    `${monorepoRoot}/apps/*/package.json`,
+    `${monorepoRoot}/package.json`
+  ]);
+  Promise.all(files.map(async (file) => {
+    let pkgJSONData = await (0, import_promises.readFile)(file, "utf8");
+    const pkgVersion = JSON.parse(pkgJSONData).version;
+    pkgJSONData = pkgJSONData.replace(new RegExp(pkgVersion, "g"), "workspace:*");
+    pkgJSONData = pkgJSONData.replace(/"version": "workspace:\*"/g, `"version": "${pkgVersion}"`);
+    await (0, import_promises.writeFile)(file, pkgJSONData);
+  }));
+};

package/dist/cjs/monorepo/utils.js

@@ -0,0 +1,34 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  findMonoRepoRoot: () => findMonoRepoRoot
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_find_up = require("find-up");
+const WORKSPACE_DIR_ENV_VAR = "NPM_CONFIG_WORKSPACE_DIR";
+const WORKSPACE_MANIFEST_FILENAME = "pnpm-workspace.yaml";
+const findMonoRepoRoot = (cwd = process.cwd()) => {
+  const workspaceManifestDirEnvVar = process.env[WORKSPACE_DIR_ENV_VAR] ?? process.env[WORKSPACE_DIR_ENV_VAR.toLowerCase()];
+  const workspaceManifestLocation = workspaceManifestDirEnvVar ? import_node_path.default.join(workspaceManifestDirEnvVar, "pnpm-workspace.yaml") : (0, import_find_up.findUpSync)([WORKSPACE_MANIFEST_FILENAME, "pnpm-workspace.yml"], { cwd });
+  return workspaceManifestLocation && import_node_path.default.dirname(workspaceManifestLocation);
+};

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": false
+}

package/dist/cjs/pui-config/index.js

@@ -0,0 +1,40 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pui_config_exports = {};
+__export(pui_config_exports, {
+  getPUIConfig: () => getPUIConfig
+});
+module.exports = __toCommonJS(pui_config_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_lodash = require("lodash");
+const baseConfig = {
+  esBuild: {
+    target: "es2020"
+  }
+};
+const getPUIConfig = () => {
+  const configPath = import_node_path.default.resolve(process.cwd(), "./pui.config.js");
+  if (!import_node_fs.default.existsSync(configPath))
+    return baseConfig;
+  const config = JSON.parse(import_node_fs.default.readFileSync(configPath, "utf8"));
+  return (0, import_lodash.merge)(baseConfig, config);
+};

package/dist/cjs/scripts/helpers/checkmark.js

@@ -0,0 +1,32 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkmark_exports = {};
+__export(checkmark_exports, {
+  default: () => checkmark_default
+});
+module.exports = __toCommonJS(checkmark_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+function checkmark_default(callback, message = "") {
+  process.stdout.write("\n\n");
+  process.stdout.write(import_chalk.default.green(" \u2713"));
+  if (callback)
+    callback(message);
+}

package/dist/cjs/scripts/helpers/get-npm-config.js

@@ -0,0 +1,27 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_npm_config_exports = {};
+__export(get_npm_config_exports, {
+  default: () => get_npm_config_default
+});
+module.exports = __toCommonJS(get_npm_config_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var get_npm_config_default = JSON.parse(import_node_fs.default.readFileSync("package.json", "utf8"));

package/dist/cjs/scripts/helpers/progress.js

@@ -0,0 +1,35 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var progress_exports = {};
+__export(progress_exports, {
+  default: () => progress_default
+});
+module.exports = __toCommonJS(progress_exports);
+var import_readline = __toESM(require("readline"), 1);
+function progress_default(message, amountOfDots = 3) {
+  let i = 0;
+  return setInterval(() => {
+    import_readline.default.cursorTo(process.stdout, 0);
+    i = (i + 1) % (amountOfDots + 1);
+    const dots = new Array(i + 1).join(".");
+    process.stdout.write(message + dots);
+  }, 500);
+}

package/dist/cjs/scripts/helpers/xmark.js

@@ -0,0 +1,31 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var xmark_exports = {};
+__export(xmark_exports, {
+  default: () => xmark_default
+});
+module.exports = __toCommonJS(xmark_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+function xmark_default(callback) {
+  process.stdout.write(import_chalk.default.red(" \u2718"));
+  if (callback)
+    callback();
+}

package/dist/cjs/scripts/npmcheckversion.js

@@ -0,0 +1,8 @@
+var import_child_process = require("child_process");
+(0, import_child_process.exec)("npm -v", (err, stdout) => {
+  if (err)
+    throw err;
+  if (parseFloat(stdout) < 5) {
+    throw new Error(`[ERROR] You need npm version @>=5 but you have ${stdout}`);
+  }
+});

package/dist/cjs/scripts/update-notifier.js

@@ -0,0 +1,33 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_notifier_exports = {};
+__export(update_notifier_exports, {
+  default: () => update_notifier_default
+});
+module.exports = __toCommonJS(update_notifier_exports);
+var import_update_notifier = __toESM(require("update-notifier"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var update_notifier_default = async () => {
+  const pkgFile = await import_promises.default.readFile(import_node_path.default.join(process.cwd(), "./package.json"));
+  const pkg = JSON.parse(pkgFile);
+  (0, import_update_notifier.default)({ pkg }).notify();
+};

package/dist/cjs/server/csp.js

@@ -0,0 +1,88 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csp_exports = {};
+__export(csp_exports, {
+  csp: () => csp,
+  sendFileWithCSPNonce: () => sendFileWithCSPNonce
+});
+module.exports = __toCommonJS(csp_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_helmet_csp = __toESM(require("helmet-csp"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+const sources = [
+  "'self'",
+  "http://localhost:*",
+  "*.elliemae.io",
+  "*.elliemae.com",
+  "*.elliservices.com",
+  "*.ellielabs.com",
+  "http://pdx-col.eum-appdynamics.com",
+  "https://pdx-col.eum-appdynamics.com/",
+  "https://www.google-analytics.com",
+  "https://www.googletagmanager.com"
+];
+const sendFileWithCSPNonce = ({
+  buildPath,
+  page = "index.html",
+  nonceRegex = /__CSP_NONCE__/g,
+  res,
+  fileSystem = import_node_fs.default
+}) => {
+  fileSystem.readFile(import_node_path.default.resolve(buildPath, page), "utf8", (err, html) => {
+    if (err) {
+      res.sendStatus(404);
+    } else {
+      res.set("Content-Type", "text/html");
+      res.send(html.replace(nonceRegex, (res.locals || {}).cspNonce));
+    }
+  });
+};
+const getScriptSrc = () => {
+  const scriptSrc = sources.concat([
+    (req, res) => `'nonce-${res.locals.cspNonce}'`
+  ]);
+  return true ? scriptSrc.concat(["'unsafe-eval'"]) : scriptSrc;
+};
+const csp = (app) => {
+  app.use((req, res, next) => {
+    res.locals.cspNonce = import_crypto.default.randomBytes(16).toString("hex");
+    next();
+  });
+  app.use((0, import_helmet_csp.default)({
+    directives: {
+      defaultSrc: ["'self'"],
+      baseUri: ["'self'"],
+      blockAllMixedContent: [],
+      connectSrc: sources,
+      fontSrc: sources.concat(["data:"]),
+      frameAncestors: sources,
+      imgSrc: sources.concat(["data:"]),
+      objectSrc: ["'none'"],
+      scriptSrc: getScriptSrc(),
+      scriptSrcAttr: ["'none'"],
+      styleSrc: sources.concat(["'unsafe-inline'"]),
+      upgradeInsecureRequests: [],
+      reportUri: "/v1/csp"
+    },
+    reportOnly: true
+  }));
+};

package/dist/cjs/server/index.js

@@ -0,0 +1,29 @@
+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 __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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var import_express = __toESM(require("express"), 1);
+var import_logger = require("./logger.js");
+var import_middlewares = require("./middlewares/index.js");
+var import_util = require("./util/index.js");
+const app = (0, import_express.default)();
+(0, import_middlewares.setupDefaultMiddlewares)(app);
+(0, import_util.loadRoutes)(app);
+(0, import_middlewares.setupAdditionalMiddlewars)(app);
+app.listen(import_util.port, import_util.host, async (err) => {
+  if (err) {
+    return import_logger.logger.error(err.message);
+  }
+  import_logger.logger.appStarted(import_util.port, import_util.host || "localhost");
+});

package/dist/cjs/server/logger.js

@@ -0,0 +1,50 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  logger: () => logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ip = __toESM(require("ip"), 1);
+const divider = import_chalk.default.gray("\n-----------------------------------");
+const logger = {
+  error: (err) => {
+    console.error(import_chalk.default.red(err));
+  },
+  appStarted: (port, host, tunnelStarted) => {
+    console.log(`Server started ! ${import_chalk.default.green("\u2713")}`);
+    if (tunnelStarted) {
+      console.log(`Tunnel initialised ${import_chalk.default.green("\u2713")}`);
+    }
+    const accessUrls = `${import_chalk.default.bold("Access URLs:")}${divider}
+`;
+    const localHostUrl = `Localhost: ${import_chalk.default.magenta(`http://${host}:${port}`)}
+`;
+    const lanUrl = `LAN: ${import_chalk.default.magenta(`http://${import_ip.default.address()}:${port}`)}
+`;
+    const proxy = tunnelStarted ? `
+    Proxy: ${import_chalk.default.magenta(tunnelStarted)}` : "";
+    console.log(`${accessUrls}${localHostUrl}${lanUrl}${proxy}${divider}${import_chalk.default.blue(`
+Press ${import_chalk.default.italic("CTRL-C")} to stop`)}
+    `);
+  }
+};

package/dist/cjs/server/middlewares/addProdMiddlewares.js

@@ -0,0 +1,44 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addProdMiddlewares_exports = {};
+__export(addProdMiddlewares_exports, {
+  addProdMiddlewares: () => addProdMiddlewares
+});
+module.exports = __toCommonJS(addProdMiddlewares_exports);
+var import_compression = __toESM(require("compression"), 1);
+var import_express_static_gzip = __toESM(require("express-static-gzip"), 1);
+var import_csp = require("../csp.js");
+var import_helpers = require("../../webpack/helpers.js");
+const paths = (0, import_helpers.getPaths)();
+const addProdMiddlewares = (app, options = {}) => {
+  const { buildPath = paths.buildPath, basePath = paths.basePath } = options;
+  app.use((0, import_compression.default)());
+  app.get(basePath, (req, res) => {
+    (0, import_csp.sendFileWithCSPNonce)({ buildPath, res });
+  });
+  app.use(basePath, (0, import_express_static_gzip.default)(buildPath, {
+    index: false,
+    enableBrotli: true,
+    orderPreference: ["br"]
+  }));
+  app.use((0, import_express_static_gzip.default)("cdn"));
+  app.get("*", (req, res) => (0, import_csp.sendFileWithCSPNonce)({ buildPath, res }));
+};

package/dist/cjs/server/middlewares/index.js

@@ -0,0 +1,57 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+__export(middlewares_exports, {
+  setupAdditionalMiddlewars: () => setupAdditionalMiddlewars,
+  setupDefaultMiddlewares: () => setupDefaultMiddlewares
+});
+module.exports = __toCommonJS(middlewares_exports);
+var import_express = __toESM(require("express"), 1);
+var import_cors = __toESM(require("cors"), 1);
+var import_express_pino_logger = __toESM(require("express-pino-logger"), 1);
+var import_csp = require("../csp.js");
+var import_addProdMiddlewares = require("./addProdMiddlewares.js");
+const setupDefaultMiddlewares = (app) => {
+  const pino = (0, import_express_pino_logger.default)({
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true
+      }
+    }
+  });
+  pino.logger.level = "warn";
+  app.use(pino);
+  app.use((0, import_cors.default)());
+  app.options("*", (0, import_cors.default)());
+  (0, import_csp.csp)(app);
+  app.use(import_express.default.urlencoded({ extended: false }));
+  app.use(import_express.default.text({ type: "text/plain" }));
+  app.use(import_express.default.json({ type: "application/json" }));
+  app.use(import_express.default.json({ type: "application/csp-report" }));
+};
+const setupAdditionalMiddlewars = (app, options) => {
+  const isProd = false;
+  if (isProd) {
+    (0, import_addProdMiddlewares.addProdMiddlewares)(app, options);
+  }
+  return app;
+};

package/dist/cjs/server/util/index.js

@@ -0,0 +1,68 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  getCWD: () => getCWD,
+  host: () => host,
+  loadRoutes: () => loadRoutes,
+  port: () => port
+});
+module.exports = __toCommonJS(util_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_minimist = __toESM(require("minimist"), 1);
+const argv = (0, import_minimist.default)(process.argv.slice(2));
+const getCWD = () => process.cwd();
+const allJS = /\.js$/;
+const serviceEndpoints = /\.endpoint\.js$/;
+const getFilesMatching = (filePattern) => {
+  const getFiles = (dir) => {
+    let routeFiles = [];
+    if (!import_fs.default.existsSync(dir))
+      return routeFiles;
+    import_fs.default.readdirSync(dir).forEach((file) => {
+      const fullPath = import_path.default.join(dir, file);
+      if (import_fs.default.lstatSync(fullPath).isDirectory()) {
+        routeFiles = routeFiles.concat(getFiles(fullPath));
+      } else if (filePattern.test(fullPath))
+        routeFiles.push(fullPath);
+    });
+    return routeFiles;
+  };
+  return getFiles;
+};
+const getServerRouteFiles = getFilesMatching(allJS);
+const getServiceEndpoints = getFilesMatching(serviceEndpoints);
+const loadRoutes = (app) => {
+  const routeFiles = getServerRouteFiles(import_path.default.join(getCWD(), "server/routes"));
+  routeFiles.push(...getServiceEndpoints(import_path.default.join(getCWD(), "app")));
+  routeFiles.push(...getServiceEndpoints(import_path.default.join(getCWD(), "lib")));
+  routeFiles.forEach(async (routeFile) => {
+    const init = await import(routeFile);
+    try {
+      init(app);
+    } catch (err) {
+      console.error(`unable to load routes from ${routeFile}. ${err.message}`);
+    }
+  });
+};
+const port = parseInt(argv.port || process.env.port || process.env.PORT || "3000", 10);
+const host = argv.host || process.env.HOST;