@elysiajs/node/dist/cjs/index.js

Plugin for Elysia for retreiving Bearer token

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  default: () => index_default,
  node: () => node
});
module.exports = __toCommonJS(index_exports);
var import_web_standard = require("elysia/adapter/web-standard");
var import_node_server = require("@hono/node-server");
var import_utils = require("elysia/utils");
var node = () => {
  return {
    ...import_web_standard.WebStandardAdapter,
    name: "node",
    listen(app) {
      return (options, callback) => {
        if (typeof options === "string") {
          if (!(0, import_utils.isNumericString)(options))
            throw new Error("Port must be a numeric value");
          options = parseInt(options);
        }
        const { promise: serverInfo, resolve: setServerInfo } = Promise.withResolvers();
        app.server = serverInfo;
        const serverOptions = typeof options === "number" ? {
          port: options,
          fetch: app.fetch
        } : {
          ...options,
          // @ts-ignore
          host: options?.hostname
        };
        let server = (0, import_node_server.serve)(serverOptions, () => {
          const address = server.address();
          const hostname = typeof address === "string" ? address : address ? address.address : "localhost";
          const port = typeof address === "string" ? 0 : address?.port ?? 0;
          const serverInfo2 = {
            ...server,
            id: (0, import_utils.randomId)(),
            development: process.env.NODE_ENV !== "production",
            fetch: app.fetch,
            hostname,
            // @ts-expect-error
            get pendingRequests() {
              const { promise, resolve, reject } = Promise.withResolvers();
              server.getConnections((error, total) => {
                if (error) reject(error);
                resolve(total);
              });
              return promise;
            },
            get pendingWebSockets() {
              return 0;
            },
            port,
            publish() {
              throw new Error(
                "This adapter doesn't support uWebSocket Publish method"
              );
            },
            ref() {
              server.ref();
            },
            unref() {
              server.unref();
            },
            reload() {
              server.close(() => {
                server = (0, import_node_server.serve)(serverOptions);
              });
            },
            requestIP() {
              throw new Error(
                "This adapter doesn't support Bun requestIP method"
              );
            },
            stop() {
              server.close();
            },
            upgrade() {
              throw new Error(
                "This adapter doesn't support Web Standard Upgrade method"
              );
            },
            url: new URL(
              `http://${hostname === "::" ? "localhost" : hostname}:${port}`
            ),
            [Symbol.dispose]() {
              server.close();
            },
            // @ts-expect-error additional property
            raw: server
          };
          setServerInfo(serverInfo2);
          if (callback) callback(serverInfo2);
          app.modules.then(() => {
            try {
              serverInfo2.reload(
                typeof options === "object" ? options : {
                  port: options
                }
              );
            } catch {
            }
          });
        });
        app.router.http.build?.();
        if (app.event.start)
          for (let i = 0; i < app.event.start.length; i++)
            app.event.start[i].fn(this);
        process.on("beforeExit", () => {
          server.close();
          if (app.event.stop)
            for (let i = 0; i < app.event.stop.length; i++)
              app.event.stop[i].fn(this);
        });
      };
    }
  };
};
var index_default = node;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  node
});