@backstage/backend-defaults/dist/entrypoints/rootHttpRouter/rootHttpRouterServiceFactory.cjs.js

Backend defaults used by Backstage backend apps

'use strict';

var backendPluginApi = require('@backstage/backend-plugin-api');
var express = require('express');
var config = require('./http/config.cjs.js');
var createHttpServer = require('./http/createHttpServer.cjs.js');
var MiddlewareFactory = require('./http/MiddlewareFactory.cjs.js');
require('minimatch');
require('helmet');
require('lodash/kebabCase');
var DefaultRootHttpRouter = require('./DefaultRootHttpRouter.cjs.js');
var createHealthRouter = require('./createHealthRouter.cjs.js');
var types = require('@backstage/types');
var config$1 = require('@backstage/config');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }

var express__default = /*#__PURE__*/_interopDefaultCompat(express);

function defaultConfigure({ applyDefaults }) {
  applyDefaults();
}
const rootHttpRouterServiceFactoryWithOptions = (options) => backendPluginApi.createServiceFactory({
  service: backendPluginApi.coreServices.rootHttpRouter,
  deps: {
    config: backendPluginApi.coreServices.rootConfig,
    rootLogger: backendPluginApi.coreServices.rootLogger,
    lifecycle: backendPluginApi.coreServices.rootLifecycle,
    health: backendPluginApi.coreServices.rootHealth
  },
  async factory({ config: config$2, rootLogger, lifecycle, health }) {
    const { indexPath, configure = defaultConfigure } = options ?? {};
    const logger = rootLogger.child({ service: "rootHttpRouter" });
    const app = express__default.default();
    const trustProxy = config$2.getOptional("backend.trustProxy");
    const router = DefaultRootHttpRouter.DefaultRootHttpRouter.create({ indexPath });
    const middleware = MiddlewareFactory.MiddlewareFactory.create({ config: config$2, logger });
    const routes = router.handler();
    const healthRouter = createHealthRouter.createHealthRouter({ config: config$2, health });
    const server = await createHttpServer.createHttpServer(
      app,
      config.readHttpServerOptions(config$2.getOptionalConfig("backend")),
      { logger }
    );
    configure({
      app,
      server,
      routes,
      middleware,
      config: config$2,
      logger,
      lifecycle,
      healthRouter,
      applyDefaults() {
        if (process.env.NODE_ENV === "development") {
          app.set("json spaces", 2);
        }
        if (trustProxy !== void 0) {
          app.set("trust proxy", trustProxy);
        }
        const backendConfig = config$2.getOptionalConfig("backend");
        const serverConfig = backendConfig?.getOptionalConfig("server");
        if (serverConfig) {
          const readDurationValue = (key) => {
            if (!serverConfig.has(key)) {
              return void 0;
            }
            const value = serverConfig.getOptional(key);
            if (typeof value === "number") {
              return value;
            }
            try {
              const duration = config$1.readDurationFromConfig(serverConfig, { key });
              return types.durationToMilliseconds(duration);
            } catch (error) {
              logger.warn(
                `Failed to parse backend.server.${key} as duration: ${error}. Expected a number (milliseconds), duration string (e.g., '30s'), ISO duration (e.g., 'PT30S'), or duration object (e.g., {seconds: 30}). Falling back to number parsing.`
              );
              return void 0;
            }
          };
          const headersTimeout = readDurationValue("headersTimeout");
          if (headersTimeout !== void 0) {
            server.headersTimeout = headersTimeout;
          }
          const requestTimeout = readDurationValue("requestTimeout");
          if (requestTimeout !== void 0) {
            server.requestTimeout = requestTimeout;
          }
          const keepAliveTimeout = readDurationValue("keepAliveTimeout");
          if (keepAliveTimeout !== void 0) {
            server.keepAliveTimeout = keepAliveTimeout;
          }
          const timeout = readDurationValue("timeout");
          if (timeout !== void 0) {
            server.timeout = timeout;
          }
          const maxHeadersCount = serverConfig.getOptionalNumber("maxHeadersCount");
          if (maxHeadersCount !== void 0) {
            server.maxHeadersCount = maxHeadersCount;
          }
          const maxRequestsPerSocket = serverConfig.getOptionalNumber(
            "maxRequestsPerSocket"
          );
          if (maxRequestsPerSocket !== void 0) {
            server.maxRequestsPerSocket = maxRequestsPerSocket;
          }
        }
        app.use(middleware.helmet());
        app.use(middleware.cors());
        app.use(middleware.compression());
        app.use(middleware.logging());
        app.use(middleware.rateLimit());
        app.use(healthRouter);
        app.use(routes);
        app.use(middleware.notFound());
        app.use(middleware.error());
      }
    });
    if (config$2.has("backend.lifecycle.serverShutdownDelay")) {
      const serverShutdownDelay = config$1.readDurationFromConfig(config$2, {
        key: "backend.lifecycle.serverShutdownDelay"
      });
      lifecycle.addBeforeShutdownHook(async () => {
        const timeoutMs = types.durationToMilliseconds(serverShutdownDelay);
        return await new Promise((resolve) => {
          setTimeout(resolve, timeoutMs);
        });
      });
    }
    lifecycle.addShutdownHook(() => server.stop());
    await server.start();
    return router;
  }
});
const rootHttpRouterServiceFactory = Object.assign(
  rootHttpRouterServiceFactoryWithOptions,
  rootHttpRouterServiceFactoryWithOptions()
);

exports.rootHttpRouterServiceFactory = rootHttpRouterServiceFactory;
//# sourceMappingURL=rootHttpRouterServiceFactory.cjs.js.map