@elliemae/pui-cli 8.42.0-alpha.3 → 8.42.0-alpha.5

package/dist/cjs/server/cert.js

@@ -0,0 +1,45 @@
+"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 cert_exports = {};
+__export(cert_exports, {
+  getCertOptions: () => getCertOptions
+});
+module.exports = __toCommonJS(cert_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+const import_meta = {};
+const getCertOptions = () => {
+  const __filename = (0, import_url.fileURLToPath)(import_meta.url);
+  const __dirname = import_path.default.dirname(__filename);
+  return {
+    pfx: import_fs.default.readFileSync(import_path.default.join(__dirname, "./certs/cert.pfx")),
+    passphrase: "uiplatform"
+  };
+};

package/dist/cjs/server/index.js

@@ -22,9 +22,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var import_node_https = __toESM(require("node:https"), 1);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
 var import_express = __toESM(require("express"), 1);
+var import_cert = require("./cert.js");
 var import_logger = require("./logger.js");
 var import_middlewares = require("./middlewares.js");
 var import_utils = require("./utils.js");
@@ -35,21 +34,15 @@ var import_wsServer = require("./wsServer.js");
   (0, import_middlewares.setupDefaultMiddlewares)(app);
   await (0, import_appRoutes.loadRoutes)(app);
   (0, import_middlewares.setupAdditionalMiddlewars)(app);
-  const options = {
-    pfx: import_node_fs.default.readFileSync(import_node_path.default.join(__dirname, "./certs/uiplatform.p12")),
-    passPhrase: "uiplatform"
-  };
-  const server = import_node_https.default.createServer(options, app);
+  const server = import_node_https.default.createServer((0, import_cert.getCertOptions)(), app);
   server.listen(import_utils.port, import_utils.host, () => {
-    (0, import_wsServer.createWSServer)({ server }).then((wsServer) => {
-      app.locals.wsServer = wsServer;
-    }).catch((err) => {
-      import_logger.logger.error(err);
-      process.exit(1);
-    });
     import_logger.logger.appStarted(import_utils.port.toString(), import_utils.host || "localhost");
   }).on("error", (err) => {
     import_logger.logger.error(err);
     process.exit(1);
   });
+  const { wsServer } = await (0, import_wsServer.createWSServer)({
+    port: import_utils.wsPort
+  });
+  app.locals.wsServer = wsServer;
 })();

package/dist/cjs/server/logger.js

@@ -48,7 +48,7 @@ const logger = {
     const accessUrls = `${import_chalk.default.bold("Access URLs:")}${divider}
 `;
     const localHostUrl = `Localhost: ${import_chalk.default.magenta(
-      `http://${host}:${port}`
+      `https://${host}:${port}`
     )}
 `;
     const lanUrl = `LAN: ${import_chalk.default.magenta(`http://${import_ip.default.address()}:${port}`)}

package/dist/cjs/server/wsServer.js

@@ -31,8 +31,11 @@ __export(wsServer_exports, {
   createWSServer: () => createWSServer
 });
 module.exports = __toCommonJS(wsServer_exports);
+var import_node_https = __toESM(require("node:https"), 1);
 var wsLib = __toESM(require("ws"), 1);
+var import_cert = require("./cert.js");
 const PING_INTERVAL = 3e4;
+const DEFAULT_PORT = 5001;
 const onSocketError = (err) => {
   console.error(err);
 };
@@ -48,7 +51,7 @@ const getAuthToken = (protocols) => {
   return authProtocol.split("--")[1]?.trim?.();
 };
 const createWSServer = ({
-  server,
+  port = DEFAULT_PORT,
   pingInterval = PING_INTERVAL,
   onOpen
 }) => {
@@ -56,8 +59,9 @@ const createWSServer = ({
   const heartbeat = () => {
     isAlive = true;
   };
-  const wsServer = new wsLib.WebSocketServer({ server });
-  server.on("upgrade", (req, socket, head) => {
+  const httpServer = import_node_https.default.createServer((0, import_cert.getCertOptions)());
+  const wsServer = new wsLib.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
     socket.on("error", onSocketError);
     wsServer.handleUpgrade(req, socket, head, (ws) => {
       const protocols = req.headers["sec-websocket-protocol"]?.split(",");
@@ -113,5 +117,10 @@ const createWSServer = ({
   wsServer.on("close", function close() {
     clearInterval(interval);
   });
-  return Promise.resolve(wsServer);
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      console.log(`Websocket server listening on port ${port}`);
+      return resolve({ httpServer, wsServer });
+    });
+  });
 };

package/dist/cjs/webpack/webpack.dev.babel.js

@@ -44,7 +44,9 @@ var import_middlewares = require("../server/middlewares.js");
 var import_appRoutes = require("../server/appRoutes.js");
 var import_helpers = require("./helpers.js");
 var import_webpack_base_babel = require("./webpack.base.babel.js");
+var import_utils = require("../server/utils.js");
 var import_wsServer = require("../server/wsServer.js");
+var import_cert = require("../server/cert.js");
 const import_meta = {};
 const __filename = (0, import_node_url.fileURLToPath)(import_meta.url);
 const {
@@ -152,10 +154,7 @@ const devConfig = {
     port: process.env.PORT || "auto",
     server: {
       type: "https",
-      options: {
-        pfx: import_node_path.default.join(__dirname, "../server/certs/uiplatform.p12"),
-        passphrase: "uiplatform"
-      }
+      options: (0, import_cert.getCertOptions)()
     },
     setupMiddlewares: (middlewares, devServer) => {
       (0, import_interceptor_middleware.addCSPNonceMiddleware)(middlewares);
@@ -175,8 +174,8 @@ const devConfig = {
           next();
         });
         (0, import_wsServer.createWSServer)({
-          server: devServer.server
-        }).then((wsServer) => {
+          port: import_utils.wsPort
+        }).then(({ wsServer }) => {
           if (devServer.app) devServer.app.locals.wsServer = wsServer;
         }).catch((err) => {
           console.error(err);

package/dist/esm/server/cert.js

@@ -0,0 +1,14 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const getCertOptions = () => {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  return {
+    pfx: fs.readFileSync(path.join(__dirname, "./certs/cert.pfx")),
+    passphrase: "uiplatform"
+  };
+};
+export {
+  getCertOptions
+};

package/dist/esm/server/index.js

@@ -1,13 +1,12 @@
 import https from "node:https";
-import fs from "node:fs";
-import path from "node:path";
 import express from "express";
+import { getCertOptions } from "./cert.js";
 import { logger } from "./logger.js";
 import {
   setupDefaultMiddlewares,
   setupAdditionalMiddlewars
 } from "./middlewares.js";
-import { port, host } from "./utils.js";
+import { port, wsPort, host } from "./utils.js";
 import { loadRoutes } from "./appRoutes.js";
 import { createWSServer } from "./wsServer.js";
 (async function startServer() {
@@ -15,21 +14,15 @@ import { createWSServer } from "./wsServer.js";
   setupDefaultMiddlewares(app);
   await loadRoutes(app);
   setupAdditionalMiddlewars(app);
-  const options = {
-    pfx: fs.readFileSync(path.join(__dirname, "./certs/uiplatform.p12")),
-    passPhrase: "uiplatform"
-  };
-  const server = https.createServer(options, app);
+  const server = https.createServer(getCertOptions(), app);
   server.listen(port, host, () => {
-    createWSServer({ server }).then((wsServer) => {
-      app.locals.wsServer = wsServer;
-    }).catch((err) => {
-      logger.error(err);
-      process.exit(1);
-    });
     logger.appStarted(port.toString(), host || "localhost");
   }).on("error", (err) => {
     logger.error(err);
     process.exit(1);
   });
+  const { wsServer } = await createWSServer({
+    port: wsPort
+  });
+  app.locals.wsServer = wsServer;
 })();

package/dist/esm/server/logger.js

@@ -15,7 +15,7 @@ const logger = {
     const accessUrls = `${chalk.bold("Access URLs:")}${divider}
 `;
     const localHostUrl = `Localhost: ${chalk.magenta(
-      `http://${host}:${port}`
+      `https://${host}:${port}`
     )}
 `;
     const lanUrl = `LAN: ${chalk.magenta(`http://${ip.address()}:${port}`)}

package/dist/esm/server/wsServer.js

@@ -1,5 +1,8 @@
+import https from "node:https";
 import * as wsLib from "ws";
+import { getCertOptions } from "./cert.js";
 const PING_INTERVAL = 3e4;
+const DEFAULT_PORT = 5001;
 const onSocketError = (err) => {
   console.error(err);
 };
@@ -15,7 +18,7 @@ const getAuthToken = (protocols) => {
   return authProtocol.split("--")[1]?.trim?.();
 };
 const createWSServer = ({
-  server,
+  port = DEFAULT_PORT,
   pingInterval = PING_INTERVAL,
   onOpen
 }) => {
@@ -23,8 +26,9 @@ const createWSServer = ({
   const heartbeat = () => {
     isAlive = true;
   };
-  const wsServer = new wsLib.WebSocketServer({ server });
-  server.on("upgrade", (req, socket, head) => {
+  const httpServer = https.createServer(getCertOptions());
+  const wsServer = new wsLib.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
     socket.on("error", onSocketError);
     wsServer.handleUpgrade(req, socket, head, (ws) => {
       const protocols = req.headers["sec-websocket-protocol"]?.split(",");
@@ -80,7 +84,12 @@ const createWSServer = ({
   wsServer.on("close", function close() {
     clearInterval(interval);
   });
-  return Promise.resolve(wsServer);
+  return new Promise((resolve) => {
+    httpServer.listen(port, () => {
+      console.log(`Websocket server listening on port ${port}`);
+      return resolve({ httpServer, wsServer });
+    });
+  });
 };
 export {
   createWSServer

package/dist/esm/webpack/webpack.dev.babel.js

@@ -15,7 +15,9 @@ import {
   isGoogleTagManagerEnabled
 } from "./helpers.js";
 import { baseConfig } from "./webpack.base.babel.js";
+import { wsPort } from "../server/utils.js";
 import { createWSServer } from "../server/wsServer.js";
+import { getCertOptions } from "../server/cert.js";
 const __filename = fileURLToPath(import.meta.url);
 const {
   appVersion,
@@ -122,10 +124,7 @@ const devConfig = {
     port: process.env.PORT || "auto",
     server: {
       type: "https",
-      options: {
-        pfx: path.join(__dirname, "../server/certs/uiplatform.p12"),
-        passphrase: "uiplatform"
-      }
+      options: getCertOptions()
     },
     setupMiddlewares: (middlewares, devServer) => {
       addCSPNonceMiddleware(middlewares);
@@ -145,8 +144,8 @@ const devConfig = {
           next();
         });
         createWSServer({
-          server: devServer.server
-        }).then((wsServer) => {
+          port: wsPort
+        }).then(({ wsServer }) => {
           if (devServer.app) devServer.app.locals.wsServer = wsServer;
         }).catch((err) => {
           console.error(err);

package/dist/types/lib/server/cert.d.ts

@@ -0,0 +1,4 @@
+export declare const getCertOptions: () => {
+    pfx: Buffer;
+    passphrase: string;
+};

package/dist/types/lib/server/wsServer.d.ts

@@ -1,8 +1,12 @@
 import https from 'node:https';
 import * as wsLib from 'ws';
+export interface Servers {
+    httpServer: https.Server;
+    wsServer: wsLib.WebSocketServer;
+}
 export interface WSServerOptions {
-    server: https.Server;
+    port?: number;
     pingInterval?: number;
     onOpen?: (webSocket: wsLib.WebSocket) => void;
 }
-export declare const createWSServer: ({ server, pingInterval, onOpen, }: WSServerOptions) => Promise<wsLib.WebSocketServer>;
+export declare const createWSServer: ({ port, pingInterval, onOpen, }: WSServerOptions) => Promise<Servers>;