Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

6.9 KB
Raw Blame
/* eslint-disable import/extensions */
import path from "node:path";

import type { ClickHouseClient } from "@clickhouse/client";
import type { FastifyCorsOptions } from "@fastify/cors";
import cors from "@fastify/cors";
import fastifyEtag from "@fastify/etag";
import fastifyFormBody from "@fastify/formbody";
import helmet from "@fastify/helmet";
import type { FastifyRateLimitOptions } from "@fastify/rate-limit";
import ratelimiter from "@fastify/rate-limit";
import { fastifyRequestContext } from "@fastify/request-context";
import websocket from "@fastify/websocket";
import fastify from "fastify";
import { Cluster, Redis } from "ioredis";
import { Knex } from "knex";

import { THsmServiceFactory } from "@app/ee/services/hsm/hsm-service";
import { TKeyStoreFactory } from "@app/keystore/keystore";
import { getConfig, IS_PACKAGED, TEnvConfig } from "@app/lib/config/env";
import { CustomLogger } from "@app/lib/logger/logger";
import { alphaNumericNanoId } from "@app/lib/nanoid";
import { RequestContextKey } from "@app/lib/request-context/request-context-keys";
import { RequestMemoizer } from "@app/lib/request-context/request-memoizer";
import { TQueueServiceFactory } from "@app/queue";
import { TKmsRootConfigDALFactory } from "@app/services/kms/kms-root-config-dal";
import { TSmtpService } from "@app/services/smtp/smtp-service";
import { TSuperAdminDALFactory } from "@app/services/super-admin/super-admin-dal";

import { globalRateLimiterCfg } from "./config/rateLimiter";
import { apiMetrics } from "./plugins/api-metrics";
import { fastifyErrHandler } from "./plugins/error-handler";
import { serializerCompiler, validatorCompiler, ZodTypeProvider } from "./plugins/fastify-zod";
import { fastifyIp } from "./plugins/ip";
import { maintenanceMode } from "./plugins/maintenanceMode";
import { registerResponseSchemaHooks } from "./plugins/response-schema-hooks";
import { registerServeUI } from "./plugins/serve-ui";
import { fastifySwagger } from "./plugins/swagger";
import { registerRoutes } from "./routes";

type TMain = {
  auditLogDb?: Knex;
  db: Knex;
  smtp: TSmtpService;
  logger?: CustomLogger;
  queue: TQueueServiceFactory;
  keyStore: TKeyStoreFactory;
  redis: Redis | Cluster;
  clickhouse: ClickHouseClient | null;
  envConfig: TEnvConfig;
  superAdminDAL: TSuperAdminDALFactory;
  hsmService: THsmServiceFactory;
  kmsRootConfigDAL: TKmsRootConfigDALFactory;
};

// Run the server!
export const main = async ({
  db,
  auditLogDb,
  smtp,
  logger,
  queue,
  keyStore,
  redis,
  clickhouse,
  envConfig,
  superAdminDAL,
  hsmService,
  kmsRootConfigDAL
}: TMain) => {
  const appCfg = getConfig();

  // Infisical Cloud request IDs carry a region segment (req-us-, req-eu-) so an ID's
  // origin is identifiable at a glance; self-hosted and dedicated stay bare req-.
  let requestIdOrigin = "";
  if (appCfg.INFISICAL_CLOUD) {
    requestIdOrigin = appCfg.INTERNAL_REGION === "eu" ? "eu-" : "us-";
  }

  const server = fastify({
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    ...(appCfg.NODE_ENV === "test" ? { logger: false } : { loggerInstance: logger }),
    genReqId: () => `req-${requestIdOrigin}${alphaNumericNanoId(14)}`,
    // When TRUSTED_PROXY_CIDRS is configured, only requests from those sources have their
    // forwarded-IP headers honored. Unset preserves legacy behavior (trust all) for backcompat.
    trustProxy: appCfg.TRUSTED_PROXY_CIDRS ?? true,

    connectionTimeout: 100_000,
    ignoreTrailingSlash: true,
    pluginTimeout: 40_000
  }).withTypeProvider<ZodTypeProvider>();

  server.setValidatorCompiler(validatorCompiler);
  server.setSerializerCompiler(serializerCompiler);

  // @ts-expect-error akhilmhdh: even on setting it fastify as Redis | Cluster it's throwing error
  server.decorate("redis", redis);

  // ensures that we return proper zod errors instead of a 500 "something went wrong" error when someone sends a request with empty json body
  const defaultJsonParser = server.getDefaultJsonParser("error", "error");
  server.removeContentTypeParser("application/json");
  server.addContentTypeParser("application/json", { parseAs: "string" }, (req, body: string | Buffer, done) => {
    const strBody = typeof body === "string" ? body : body.toString();
    if (strBody?.length === 0) {
      done(null, {});
      return;
    }
    void defaultJsonParser(req, strBody, done);
  });

  server.addContentTypeParser("application/scim+json", { parseAs: "string" }, (_, body: string | Buffer, done) => {
    try {
      const strBody = typeof body === "string" ? body : body.toString();
      if (!strBody) {
        done(null, undefined);
        return;
      }
      const json: unknown = JSON.parse(strBody);
      done(null, json);
    } catch (err) {
      const error = err as Error;
      done(error, undefined);
    }
  });

  try {
    await server.register(fastifyEtag);

    await server.register<FastifyCorsOptions>(cors, {
      credentials: true,
      ...(appCfg.CORS_ALLOWED_ORIGINS?.length
        ? {
            origin: [...appCfg.CORS_ALLOWED_ORIGINS, ...(appCfg.SITE_URL ? [appCfg.SITE_URL] : [])]
          }
        : {
            origin: appCfg.SITE_URL || true
          }),
      ...(appCfg.CORS_ALLOWED_HEADERS?.length && {
        allowedHeaders: appCfg.CORS_ALLOWED_HEADERS
      })
    });

    await server.register(registerResponseSchemaHooks);
    // pull ip based on various proxy headers
    await server.register(fastifyIp);

    if (appCfg.OTEL_TELEMETRY_COLLECTION_ENABLED) {
      await server.register(apiMetrics);
    }

    await server.register(fastifyErrHandler);
    await server.register(fastifySwagger, { fullSpec: appCfg.isOpenApiFullSpec });
    await server.register(fastifyFormBody);
    await server.register(websocket, {
      options: { maxPayload: 64 * 1024 } // 64 KB
    });

    // Rate limiters and security headers
    if (appCfg.isProductionMode && appCfg.isCloud) {
      await server.register<FastifyRateLimitOptions>(ratelimiter, globalRateLimiterCfg());
    }

    await server.register(helmet, { contentSecurityPolicy: false });

    await server.register(maintenanceMode);

    await server.register(fastifyRequestContext, {
      defaultStoreValues: (req) => ({
        reqId: req.id,
        log: req.log.child({ reqId: req.id }),
        ip: req.realIp,
        userAgent: req.headers["user-agent"],
        [RequestContextKey.Memoizer]: new RequestMemoizer()
      })
    });

    await server.register(registerRoutes, {
      smtp,
      queue,
      db,
      auditLogDb,
      keyStore,
      redis,
      clickhouse,
      hsmService,
      envConfig,
      superAdminDAL,
      kmsRootConfigDAL
    });

    if (appCfg.isApiRunModeEnabled) {
      await server.register(registerServeUI, {
        standaloneMode: appCfg.STANDALONE_MODE || IS_PACKAGED,
        dir: path.join(__dirname, IS_PACKAGED ? "../../../" : "../../")
      });
    }

    await server.ready();
    server.swagger();
    return server;
  } catch (err) {
    server.log.error(err);
    await queue.shutdown();
    process.exit(1);
  }
};