@web-ts-toolkit/express-runtime 0.7.0

package/index.mjs

@@ -0,0 +1,220 @@
+// src/index.ts
+import http from "http";
+import express from "express";
+import serverless from "serverless-http";
+var defaultLogger = {
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  debug: (...args) => console.debug(...args)
+};
+function applySettings(app, options) {
+  if (options.disablePoweredBy !== false) {
+    app.disable("x-powered-by");
+  }
+  app.set("etag", options.etag ?? false);
+  app.set("trust proxy", options.trustProxy ?? false);
+}
+function applyMiddlewareList(app, list) {
+  if (list) {
+    for (const mw of list) {
+      app.use(mw);
+    }
+  }
+}
+function applyRouters(app, options) {
+  const mounts = [];
+  if (options.router) mounts.push(options.router);
+  if (options.routers) mounts.push(...options.routers);
+  for (const mount of mounts) {
+    const path = typeof mount.path === "function" ? mount.path() : mount.path;
+    app.use(path, mount.handler);
+  }
+}
+function createExpressApp(options = {}) {
+  const app = express();
+  applySettings(app, options);
+  applyMiddlewareList(app, options.preMiddleware);
+  if (options.json !== false) {
+    app.use(express.json(options.json ?? { limit: "1mb" }));
+  }
+  if (options.urlencoded !== false) {
+    app.use(express.urlencoded(options.urlencoded ?? { extended: false, limit: "1mb" }));
+  }
+  applyMiddlewareList(app, options.middleware);
+  applyRouters(app, options);
+  applyMiddlewareList(app, options.postMiddleware);
+  if (options.finalize) {
+    options.finalize(app);
+  }
+  if (options.errorHandler) {
+    app.use(options.errorHandler);
+  }
+  return app;
+}
+function defaultRequestHook(req, maxBodyBytes = 1024 * 1024, logger = defaultLogger) {
+  if (!req.body || !Buffer.isBuffer(req.body)) {
+    return;
+  }
+  if (req.body.length > maxBodyBytes) {
+    logger.debug?.(" Skipping oversized serverless body for content-type parsing");
+    return;
+  }
+  try {
+    const bodyStr = req.body.toString("utf8");
+    const contentType = (req.headers?.["content-type"] ?? "").toLowerCase();
+    if (contentType.startsWith("application/json")) {
+      req.body = JSON.parse(bodyStr);
+    } else {
+      req.body = bodyStr;
+    }
+  } catch (error) {
+    logger.error("Failed to parse serverless request body:", error);
+  }
+}
+function createServerlessHandler(app, options = {}) {
+  const logger = options.logger ?? defaultLogger;
+  const maxBodyBytes = options.maxBodyBytes ?? 1024 * 1024;
+  const requestHook = options.request ?? ((req) => defaultRequestHook(req, maxBodyBytes, logger));
+  const baseOptions = {
+    ...options.serverlessOptions ?? {},
+    request: requestHook
+  };
+  if (options.response) {
+    baseOptions.response = options.response;
+  }
+  const apiHandler = serverless(app, baseOptions);
+  let initialized = null;
+  const ensureInit = () => {
+    if (!initialized) {
+      logger.debug?.("Serverless cold start: running init");
+      initialized = options.init ? options.init() : Promise.resolve();
+    }
+    return initialized;
+  };
+  const handler = async (event, context) => {
+    await ensureInit();
+    return apiHandler(event, context);
+  };
+  handler.reset = () => {
+    initialized = null;
+  };
+  return handler;
+}
+var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+function normalizePort(val) {
+  if (val === void 0 || val === "") {
+    const envPort = process.env.PORT;
+    if (envPort === void 0 || envPort === "") {
+      return 8080;
+    }
+    val = envPort;
+  }
+  if (typeof val === "string") {
+    const parsed = Number(val);
+    if (Number.isNaN(parsed)) {
+      return val;
+    }
+    val = parsed;
+  }
+  if (!Number.isFinite(val) || val < 0 || val > 65535) {
+    throw new Error(`Invalid port: ${String(val)}`);
+  }
+  return val;
+}
+function defaultOnError(error, port, logger) {
+  if (error.syscall !== "listen") {
+    throw error;
+  }
+  const bind = typeof port === "string" ? `Pipe ${port}` : `Port ${port}`;
+  if (error.code === "EACCES") {
+    logger.error(`${bind} requires elevated privileges`);
+    process.exit(1);
+  } else if (error.code === "EADDRINUSE") {
+    logger.error(`${bind} is already in use`);
+    process.exit(1);
+  } else {
+    throw error;
+  }
+}
+function startLocalServer(app, options = {}) {
+  const logger = options.logger ?? defaultLogger;
+  const port = normalizePort(options.port);
+  const host = options.host ?? process.env.HOST ?? "0.0.0.0";
+  const shutdownTimeout = options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT;
+  const server = http.createServer(app);
+  app.set("port", port);
+  const onError = (error) => {
+    if (options.onError) {
+      options.onError(error);
+    } else {
+      defaultOnError(error, port, logger);
+    }
+  };
+  const onListening = () => {
+    const addr = server.address();
+    const bind = typeof addr === "string" ? `pipe ${addr}` : `port ${addr?.port}`;
+    logger.log(`Server running at http://${host}:${port}/ (${bind})`);
+    options.onListening?.();
+  };
+  server.on("error", onError);
+  server.on("listening", onListening);
+  const shutdown = async () => {
+    logger.log("Shutting down...");
+    try {
+      if (options.onShutdown) {
+        await options.onShutdown();
+      }
+    } catch (err) {
+      logger.error("onShutdown hook failed:", err);
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        server.closeAllConnections?.();
+        resolve();
+      }, shutdownTimeout);
+      server.close((err) => {
+        clearTimeout(timer);
+        if (err) {
+          logger.error("Server close error:", err);
+        }
+        resolve();
+      });
+    });
+    if (options.exitAfterShutdown) {
+      process.exit(0);
+    }
+  };
+  if (options.signals !== false) {
+    const list = options.signals === void 0 || options.signals === true ? DEFAULT_SIGNALS : options.signals;
+    for (const sig of list) {
+      process.once(sig, () => void shutdown());
+    }
+  }
+  const start = async () => {
+    try {
+      if (options.init) {
+        await options.init();
+      }
+      if (typeof port === "number") {
+        server.listen(port, host);
+      } else {
+        server.listen(port);
+      }
+    } catch (err) {
+      server.emit("error", err);
+    }
+  };
+  void start();
+  return {
+    server,
+    shutdown
+  };
+}
+export {
+  createExpressApp,
+  createServerlessHandler,
+  defaultRequestHook,
+  normalizePort,
+  startLocalServer
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@web-ts-toolkit/express-runtime",
+  "description": "Express app factory plus serverless handler and local dev server helpers",
+  "homepage": "https://web-ts-toolkit.pages.dev/docs/packages/express-runtime",
+  "version": "0.7.0",
+  "sideEffects": false,
+  "keywords": [
+    "express",
+    "serverless",
+    "local-server",
+    "dev-server",
+    "runtime",
+    "http"
+  ],
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "bin": {
+    "web-ts-toolkit-express-runtime": "./cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "serverless-http": "^4.0.0"
+  },
+  "peerDependencies": {
+    "express": ">=5.0.0"
+  },
+  "files": [
+    "**/*",
+    "!**/*.map"
+  ],
+  "author": "Junmin Ahn",
+  "bugs": {
+    "url": "https://github.com/egose/web-ts-toolkit/issues"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/egose/web-ts-toolkit.git",
+    "directory": "packages/express-runtime"
+  }
+}