@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);
        }
        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