@emmett-community/emmett-google-services-bootstrap 0.3.0 → 0.4.0

package/dist/chunk-XUV26TX4.js

@@ -0,0 +1,919 @@
+// src/firebase/FirebaseInitializer.ts
+import admin from "firebase-admin";
+var normalizeContext = (data) => {
+  if (data === void 0 || data === null) return {};
+  if (typeof data === "object" && !Array.isArray(data)) {
+    return { ...data };
+  }
+  return { data };
+};
+var normalizeErrorContext = (error) => {
+  if (error === void 0 || error === null) return {};
+  if (error instanceof Error) return { err: error };
+  if (typeof error === "object" && !Array.isArray(error)) {
+    return { ...error };
+  }
+  return { err: error };
+};
+var safeLog = {
+  debug: (logger, msg, data) => {
+    if (!logger) return;
+    logger.debug(normalizeContext(data), msg);
+  },
+  info: (logger, msg, data) => {
+    if (!logger) return;
+    logger.info(normalizeContext(data), msg);
+  },
+  warn: (logger, msg, data) => {
+    if (!logger) return;
+    logger.warn(normalizeContext(data), msg);
+  },
+  error: (logger, msg, error) => {
+    if (!logger) return;
+    logger.error(normalizeErrorContext(error), msg);
+  }
+};
+var FirebaseInitializer = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Returns true if emulator hosts are configured.
+   */
+  isEmulatorMode() {
+    return Boolean(
+      this.options.firestoreEmulatorHost || this.options.databaseEmulatorHost || process.env.FIRESTORE_EMULATOR_HOST || process.env.FIREBASE_DATABASE_EMULATOR_HOST
+    );
+  }
+  /**
+   * Initialize Firebase Admin and return service handles.
+   */
+  async initialize() {
+    const {
+      projectId,
+      databaseURL,
+      firestoreEmulatorHost,
+      databaseEmulatorHost,
+      logger
+    } = this.options;
+    if (firestoreEmulatorHost && !process.env.FIRESTORE_EMULATOR_HOST) {
+      process.env.FIRESTORE_EMULATOR_HOST = firestoreEmulatorHost;
+    }
+    if (databaseEmulatorHost && !process.env.FIREBASE_DATABASE_EMULATOR_HOST) {
+      process.env.FIREBASE_DATABASE_EMULATOR_HOST = databaseEmulatorHost;
+    }
+    const resolvedDatabaseURL = databaseURL ?? this.getDatabaseURL(projectId, databaseEmulatorHost);
+    const firebaseAdmin = this.options._firebaseAdmin ?? admin;
+    const app = this.getOrCreateApp(firebaseAdmin, projectId, resolvedDatabaseURL);
+    safeLog.info(logger, "Firebase initialized", {
+      projectId,
+      databaseURL: resolvedDatabaseURL,
+      emulatorMode: this.isEmulatorMode()
+    });
+    const firestore = app.firestore();
+    const database = app.database();
+    const auth = app.auth();
+    if (firestoreEmulatorHost) {
+      firestore.settings({
+        host: firestoreEmulatorHost,
+        ssl: false
+      });
+      safeLog.info(logger, "Firestore emulator configured", {
+        host: firestoreEmulatorHost
+      });
+    }
+    return { app, firestore, database, auth };
+  }
+  getOrCreateApp(firebaseAdmin, projectId, databaseURL) {
+    const apps = (firebaseAdmin.apps ?? []).filter(
+      (app) => app !== null
+    );
+    if (apps.length > 0 && firebaseAdmin.app) {
+      safeLog.debug(this.options.logger, "Reusing existing Firebase app");
+      return firebaseAdmin.app();
+    }
+    safeLog.debug(this.options.logger, "Creating Firebase app");
+    return firebaseAdmin.initializeApp(
+      {
+        projectId,
+        databaseURL
+      }
+    );
+  }
+  getDatabaseURL(projectId, emulatorHost) {
+    if (emulatorHost) {
+      return `http://${emulatorHost}?ns=${projectId}`;
+    }
+    return `https://${projectId}-default-rtdb.firebaseio.com`;
+  }
+};
+
+// src/pubsub/PubSubInitializer.ts
+import { PubSub } from "@google-cloud/pubsub";
+var normalizeContext2 = (data) => {
+  if (data === void 0 || data === null) return {};
+  if (typeof data === "object" && !Array.isArray(data)) {
+    return { ...data };
+  }
+  return { data };
+};
+var normalizeErrorContext2 = (error) => {
+  if (error === void 0 || error === null) return {};
+  if (error instanceof Error) return { err: error };
+  if (typeof error === "object" && !Array.isArray(error)) {
+    return { ...error };
+  }
+  return { err: error };
+};
+var safeLog2 = {
+  debug: (logger, msg, data) => {
+    if (!logger) return;
+    logger.debug(normalizeContext2(data), msg);
+  },
+  info: (logger, msg, data) => {
+    if (!logger) return;
+    logger.info(normalizeContext2(data), msg);
+  },
+  warn: (logger, msg, data) => {
+    if (!logger) return;
+    logger.warn(normalizeContext2(data), msg);
+  },
+  error: (logger, msg, error) => {
+    if (!logger) return;
+    logger.error(normalizeErrorContext2(error), msg);
+  }
+};
+var PubSubInitializer = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Returns true if emulator host is configured.
+   */
+  isEmulatorMode() {
+    return Boolean(
+      this.options.emulatorHost || process.env.PUBSUB_EMULATOR_HOST
+    );
+  }
+  /**
+   * Initialize PubSub client or return injected instance.
+   */
+  async initialize() {
+    const { projectId, emulatorHost, logger } = this.options;
+    if (emulatorHost && !process.env.PUBSUB_EMULATOR_HOST) {
+      process.env.PUBSUB_EMULATOR_HOST = emulatorHost;
+    }
+    if (this.options._pubsub) {
+      safeLog2.info(logger, "Using provided PubSub client", {
+        projectId,
+        emulatorHost: emulatorHost ?? process.env.PUBSUB_EMULATOR_HOST
+      });
+      return this.options._pubsub;
+    }
+    const pubsub = new PubSub({ projectId });
+    safeLog2.info(logger, "PubSub initialized", {
+      projectId,
+      emulatorHost: emulatorHost ?? process.env.PUBSUB_EMULATOR_HOST,
+      emulatorMode: this.isEmulatorMode()
+    });
+    return pubsub;
+  }
+};
+
+// src/eventstore/EventStoreFactory.ts
+import {
+  asEventStore,
+  getFirestoreEventStore
+} from "@emmett-community/emmett-google-firestore";
+import {
+  wireRealtimeDBProjections
+} from "@emmett-community/emmett-google-realtime-db";
+var createEventStore = (options) => {
+  const { firestore, database, projections, logger, collections } = options;
+  const observability = logger ? { logger } : void 0;
+  const baseEventStore = asEventStore(
+    getFirestoreEventStore(firestore, {
+      observability,
+      collections
+    })
+  );
+  if (projections && projections.length > 0) {
+    return wireRealtimeDBProjections({
+      eventStore: baseEventStore,
+      database,
+      projections,
+      observability
+    });
+  }
+  return baseEventStore;
+};
+
+// src/lifecycle/DependencyChecker.ts
+var DependencyTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Dependency check timed out after ${timeoutMs}ms`);
+    this.name = "DependencyTimeoutError";
+  }
+};
+var normalizeErrorContext3 = (error) => {
+  if (error === void 0 || error === null) return {};
+  if (error instanceof Error) return { err: error };
+  if (typeof error === "object" && !Array.isArray(error)) {
+    return { ...error };
+  }
+  return { err: error };
+};
+var withTimeout = async (promise, timeoutMs) => {
+  if (!timeoutMs || timeoutMs <= 0) return promise;
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new DependencyTimeoutError(timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var startDependency = async (dependency, startFn, options) => {
+  const { logger, successMessage, timeoutMs } = options ?? {};
+  const startTime = Date.now();
+  try {
+    await withTimeout(startFn(), timeoutMs);
+    logger?.info({ dependency, durationMs: Date.now() - startTime }, successMessage);
+    return true;
+  } catch (error) {
+    logger?.warn(
+      { dependency, durationMs: Date.now() - startTime, ...normalizeErrorContext3(error) },
+      "Unable to reach dependency"
+    );
+    return false;
+  }
+};
+var DependencyChecker = class {
+  logger;
+  defaultTimeoutMs;
+  constructor(options) {
+    this.logger = options?.logger;
+    this.defaultTimeoutMs = options?.defaultTimeoutMs;
+  }
+  async check(dependency) {
+    const start = Date.now();
+    const timeoutMs = dependency.timeoutMs ?? this.defaultTimeoutMs;
+    try {
+      await withTimeout(dependency.check(), timeoutMs);
+      if (dependency.successMessage) {
+        this.logger?.info(
+          { dependency: dependency.name, durationMs: Date.now() - start },
+          dependency.successMessage
+        );
+      }
+      return {
+        name: dependency.name,
+        ok: true,
+        required: dependency.required ?? true,
+        durationMs: Date.now() - start,
+        timedOut: false
+      };
+    } catch (error) {
+      const timedOut = error instanceof DependencyTimeoutError;
+      this.logger?.warn(
+        {
+          dependency: dependency.name,
+          durationMs: Date.now() - start,
+          timedOut,
+          ...normalizeErrorContext3(error)
+        },
+        "Dependency check failed"
+      );
+      return {
+        name: dependency.name,
+        ok: false,
+        required: dependency.required ?? true,
+        durationMs: Date.now() - start,
+        timedOut,
+        error
+      };
+    }
+  }
+  async checkAll(dependencies) {
+    const results = [];
+    for (const dependency of dependencies) {
+      results.push(await this.check(dependency));
+    }
+    const ok = results.every((result) => result.ok || !result.required);
+    return { ok, results };
+  }
+};
+
+// src/lifecycle/GracefulShutdown.ts
+var ShutdownTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Shutdown task timed out after ${timeoutMs}ms`);
+    this.name = "ShutdownTimeoutError";
+  }
+};
+var normalizeContext3 = (data) => {
+  if (data === void 0 || data === null) return {};
+  if (typeof data === "object" && !Array.isArray(data)) {
+    return { ...data };
+  }
+  return { data };
+};
+var normalizeErrorContext4 = (error) => {
+  if (error === void 0 || error === null) return {};
+  if (error instanceof Error) return { err: error };
+  if (typeof error === "object" && !Array.isArray(error)) {
+    return { ...error };
+  }
+  return { err: error };
+};
+var withTimeout2 = async (promise, timeoutMs) => {
+  if (!timeoutMs || timeoutMs <= 0) return promise;
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new ShutdownTimeoutError(timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+var GracefulShutdown = class {
+  logger;
+  timeoutMs;
+  exitOnComplete;
+  exitFn;
+  tasks = [];
+  shuttingDown = false;
+  lastResult;
+  constructor(options) {
+    this.logger = options?.logger;
+    this.timeoutMs = options?.timeoutMs;
+    this.exitOnComplete = options?.exitOnComplete ?? false;
+    this.exitFn = options?.exitFn ?? process.exit;
+  }
+  /**
+   * Register a shutdown task.
+   */
+  register(task) {
+    this.tasks.push(task);
+  }
+  /**
+   * Register a shutdown task that runs before the ones already registered.
+   */
+  registerFirst(task) {
+    this.tasks.unshift(task);
+  }
+  /**
+   * Execute all shutdown tasks and return the aggregated result.
+   */
+  async shutdown(reason, exitCode = 1) {
+    if (this.shuttingDown && this.lastResult) {
+      return this.lastResult;
+    }
+    this.shuttingDown = true;
+    this.logger?.info({ reason }, "Shutting down gracefully");
+    const results = [];
+    for (const task of this.tasks) {
+      const start = Date.now();
+      const timeoutMs = task.timeoutMs ?? this.timeoutMs;
+      try {
+        await withTimeout2(task.close(), timeoutMs);
+        results.push({
+          name: task.name,
+          ok: true,
+          timedOut: false,
+          durationMs: Date.now() - start
+        });
+        this.logger?.info(
+          { task: task.name, durationMs: Date.now() - start },
+          "Shutdown task completed"
+        );
+      } catch (error) {
+        const timedOut = error instanceof ShutdownTimeoutError;
+        results.push({
+          name: task.name,
+          ok: false,
+          timedOut,
+          durationMs: Date.now() - start,
+          error
+        });
+        this.logger?.warn(
+          {
+            task: task.name,
+            timedOut,
+            durationMs: Date.now() - start,
+            ...normalizeErrorContext4(error)
+          },
+          "Shutdown task failed"
+        );
+      }
+    }
+    const failed = results.some((result2) => !result2.ok || result2.timedOut);
+    const finalExitCode = failed ? exitCode : 0;
+    if (failed) {
+      const failedTasks = results.filter((result2) => !result2.ok || result2.timedOut).map((result2) => result2.name);
+      this.logger?.error(
+        normalizeContext3({ failedTasks }),
+        "Shutdown completed with failures"
+      );
+    } else {
+      this.logger?.info({}, "Shutdown completed");
+    }
+    const result = { reason, exitCode: finalExitCode, tasks: results };
+    this.lastResult = result;
+    if (this.exitOnComplete) {
+      this.exitFn(finalExitCode);
+    }
+    return result;
+  }
+};
+
+// src/lifecycle/SignalHandlers.ts
+var registerSignalHandlers = (options) => {
+  const signals = options.signals ?? ["SIGINT", "SIGTERM"];
+  const handlers = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const handler = () => {
+      options.logger?.info({ signal }, "Shutdown signal received");
+      void options.shutdown(`Signal ${signal} received`, options.exitCode ?? 0);
+    };
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  return () => {
+    for (const [signal, handler] of handlers.entries()) {
+      process.off(signal, handler);
+    }
+  };
+};
+
+// src/bootstrap/ServiceBootstrap.ts
+import path from "path";
+import { createLogger } from "@emmett-community/emmett-observability";
+import {
+  createOpenApiValidatorOptions,
+  getApplication,
+  startAPI
+} from "@emmett-community/emmett-expressjs-with-openapi";
+import { getPubSubMessageBus } from "@emmett-community/emmett-google-pubsub";
+var DependencyUnavailableError = class extends Error {
+  summary;
+  constructor(summary) {
+    const failed = summary.results.filter((result) => result.required && !result.ok).map((result) => result.name).join(", ");
+    super(`Dependency check failed: ${failed}`);
+    this.name = "DependencyUnavailableError";
+    this.summary = summary;
+  }
+};
+var READINESS_CHECK_TIMEOUT_MS = 3e3;
+var resolvePath = (inputPath) => {
+  return path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+};
+var ServiceBootstrap = class {
+  config;
+  resolvedConfig;
+  logger;
+  context;
+  dependencyChecker;
+  shutdownManager;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Resolve configuration with defaults and environment variables.
+   */
+  getConfig() {
+    return this.resolveConfig();
+  }
+  /**
+   * Return the initialized context if available.
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Register process signal handlers that trigger shutdown.
+   */
+  registerSignalHandlers(options) {
+    return registerSignalHandlers({
+      shutdown: async (reason, exitCode) => {
+        await this.shutdown(reason, exitCode);
+      },
+      signals: options?.signals,
+      logger: this.getLogger(),
+      exitCode: options?.exitCode
+    });
+  }
+  /**
+   * Create an Express app using emmett-expressjs-with-openapi defaults.
+   */
+  async createApp(options) {
+    const logger = this.getLogger();
+    const openApiValidator = createOpenApiValidatorOptions(
+      resolvePath(options.openApiPath),
+      {
+        ...options.openApiOptions,
+        operationHandlers: resolvePath(options.handlersPath),
+        initializeHandlers: options.initializeHandlers
+      }
+    );
+    return getApplication({
+      ...options.appOptions ?? {},
+      openApiValidator,
+      observability: logger ? { logger } : void 0
+    });
+  }
+  /**
+   * Initialize, run dependency checks, create the app, and start the HTTP server.
+   */
+  async startApi(options) {
+    const {
+      port,
+      registerSignalHandlers: registerSignalHandlers2,
+      beforeStart,
+      initializeHandlers,
+      ...createAppOptions
+    } = options;
+    const logger = this.getLogger();
+    try {
+      const ctx = await this.initialize();
+      if (beforeStart) {
+        await beforeStart(ctx);
+      }
+      if (registerSignalHandlers2 !== false) {
+        this.registerSignalHandlers();
+      }
+      await this.start();
+      const app = await this.createApp({
+        ...createAppOptions,
+        initializeHandlers: (handlers) => initializeHandlers(handlers, ctx)
+      });
+      const server = startAPI(app, { port, logger });
+      this.getShutdownManager().registerFirst({
+        name: "httpServer",
+        close: () => new Promise((resolve, reject) => {
+          server.close((error) => {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve();
+          });
+        })
+      });
+      logger?.info({ port: port ?? 3e3 }, "API server started");
+      return { app, server, context: ctx };
+    } catch (error) {
+      logger?.error({ err: error }, "Startup failed");
+      await this.shutdown("Startup failed");
+      throw error;
+    }
+  }
+  /**
+   * Initialize Firebase, PubSub, and event store wiring.
+   * Does not execute dependency checks.
+   */
+  async initialize() {
+    if (this.context) {
+      return this.context;
+    }
+    const resolvedConfig = this.resolveConfig();
+    const logger = this.getLogger();
+    const firebaseInitializer = new FirebaseInitializer({
+      projectId: resolvedConfig.firebase.projectId,
+      databaseURL: resolvedConfig.firebase.databaseURL,
+      firestoreEmulatorHost: resolvedConfig.firebase.firestoreEmulatorHost,
+      databaseEmulatorHost: resolvedConfig.firebase.databaseEmulatorHost,
+      logger,
+      _firebaseAdmin: resolvedConfig._testOverrides?.firebaseAdmin
+    });
+    const firebase = await firebaseInitializer.initialize();
+    const firestore = resolvedConfig._testOverrides?.firestore ?? firebase.firestore;
+    const database = resolvedConfig._testOverrides?.database ?? firebase.database;
+    const auth = resolvedConfig._testOverrides?.auth ?? firebase.auth;
+    const pubsubInitializer = new PubSubInitializer({
+      projectId: resolvedConfig.pubsub.projectId,
+      emulatorHost: resolvedConfig.pubsub.emulatorHost,
+      logger,
+      _pubsub: resolvedConfig._testOverrides?.pubsub
+    });
+    const pubsub = await pubsubInitializer.initialize();
+    const eventStore = resolvedConfig._testOverrides?.eventStore ?? createEventStore({
+      firestore,
+      database,
+      projections: resolvedConfig.projections,
+      collections: resolvedConfig.eventStore.collections,
+      logger
+    });
+    const messageBus = resolvedConfig._testOverrides?.messageBus ?? getPubSubMessageBus({
+      pubsub,
+      useEmulator: pubsubInitializer.isEmulatorMode(),
+      topicPrefix: resolvedConfig.pubsub.topicPrefix,
+      // Event subscriptions are shared by the replicas of the service and survive restarts
+      subscriptionId: resolvedConfig.pubsub.subscriptionId,
+      // Command subscriptions are shared too, so a command has one handler
+      instanceId: resolvedConfig.pubsub.subscriptionId,
+      subscriptionOptions: resolvedConfig.pubsub.subscriptionOptions,
+      autoCreateResources: resolvedConfig.pubsub.autoCreateResources,
+      cleanupOnClose: resolvedConfig.pubsub.cleanupOnClose,
+      closePubSubClient: resolvedConfig.pubsub.closePubSubClient,
+      observability: { logger }
+    });
+    this.shutdownManager = new GracefulShutdown({
+      ...resolvedConfig.shutdown,
+      logger
+    });
+    this.registerDefaultShutdownTasks({
+      messageBus,
+      firestore,
+      firebaseApp: firebase.app
+    });
+    this.dependencyChecker = new DependencyChecker({ logger });
+    this.context = {
+      serviceName: resolvedConfig.serviceName,
+      firebase: {
+        app: firebase.app,
+        firestore,
+        database,
+        auth
+      },
+      firestore,
+      database,
+      auth,
+      pubsub,
+      eventStore,
+      messageBus,
+      logger,
+      getCurrentTime: resolvedConfig.getCurrentTime,
+      config: resolvedConfig,
+      checkReadiness: () => this.checkReadiness()
+    };
+    return this.context;
+  }
+  /**
+   * Initialize and run dependency checks before returning context.
+   */
+  async start() {
+    const ctx = await this.initialize();
+    const resolvedConfig = this.resolveConfig();
+    const checks = [];
+    if (resolvedConfig.includeDefaultDependencyChecks) {
+      checks.push(...this.buildDefaultDependencyChecks(ctx));
+    }
+    if (resolvedConfig.dependencies.length > 0) {
+      checks.push(...resolvedConfig.dependencies);
+    }
+    if (checks.length > 0) {
+      const summary = await this.getDependencyChecker().checkAll(checks);
+      if (!summary.ok) {
+        const error = new DependencyUnavailableError(summary);
+        this.logger?.error(
+          {
+            err: error,
+            results: summary.results
+          },
+          "Dependency checks failed"
+        );
+        if (resolvedConfig.shutdownOnDependencyFailure) {
+          await this.shutdown("Dependency check failed");
+        }
+        throw error;
+      }
+    }
+    this.logger?.info(
+      { serviceName: resolvedConfig.serviceName },
+      "Service is running"
+    );
+    return ctx;
+  }
+  /**
+   * Run the readiness checks: the stores and the message bus must answer, plus the configured
+   * dependencies. A hung dependency fails the check instead of hanging the probe.
+   */
+  async checkReadiness() {
+    const ctx = await this.initialize();
+    const resolvedConfig = this.resolveConfig();
+    const checks = [];
+    if (resolvedConfig.includeDefaultDependencyChecks) {
+      checks.push(...this.buildStoreDependencyChecks(ctx));
+      if (resolvedConfig.autoStartMessageBus) {
+        checks.push({
+          name: "PubSub",
+          check: async () => {
+            if (!ctx.messageBus.isStarted?.()) {
+              throw new Error("Message bus is not started");
+            }
+          }
+        });
+      }
+    }
+    checks.push(...resolvedConfig.dependencies);
+    return this.getDependencyChecker().checkAll(
+      checks.map((check) => ({
+        ...check,
+        timeoutMs: check.timeoutMs ?? READINESS_CHECK_TIMEOUT_MS
+      }))
+    );
+  }
+  /**
+   * Execute graceful shutdown tasks and return the shutdown result.
+   */
+  async shutdown(reason, exitCode = 1) {
+    return this.getShutdownManager().shutdown(reason, exitCode);
+  }
+  getLogger() {
+    if (this.logger !== void 0) {
+      return this.logger;
+    }
+    const resolvedConfig = this.resolveConfig();
+    const observability = resolvedConfig.observability;
+    if (observability.logger) {
+      this.logger = observability.logger;
+      return this.logger;
+    }
+    if (observability.createLogger === false) {
+      this.logger = void 0;
+      return this.logger;
+    }
+    this.logger = createLogger({
+      serviceName: resolvedConfig.serviceName,
+      environment: observability.environment,
+      logLevel: observability.logLevel
+    });
+    return this.logger;
+  }
+  resolveConfig() {
+    if (this.resolvedConfig) {
+      return this.resolvedConfig;
+    }
+    const missing = [];
+    const serviceName = this.config.serviceName?.trim();
+    if (!serviceName) {
+      missing.push("serviceName");
+    }
+    const firestoreEmulatorHost = this.config.firebase?.firestoreEmulatorHost ?? process.env.FIRESTORE_EMULATOR_HOST;
+    const databaseEmulatorHost = this.config.firebase?.databaseEmulatorHost ?? process.env.FIREBASE_DATABASE_EMULATOR_HOST;
+    const pubsubEmulatorHost = this.config.pubsub?.emulatorHost ?? process.env.PUBSUB_EMULATOR_HOST;
+    const hasEmulator = Boolean(firestoreEmulatorHost) || Boolean(databaseEmulatorHost) || Boolean(pubsubEmulatorHost);
+    const firebaseProjectId = this.config.firebase?.projectId ?? process.env.FIRESTORE_PROJECT_ID ?? process.env.GCLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT ?? (hasEmulator ? "demo-project" : void 0);
+    if (!firebaseProjectId) {
+      missing.push("firebase.projectId (or FIRESTORE_PROJECT_ID)");
+    }
+    const pubsubProjectId = this.config.pubsub?.projectId ?? process.env.PUBSUB_PROJECT_ID ?? firebaseProjectId ?? (hasEmulator ? "demo-project" : void 0);
+    if (!pubsubProjectId) {
+      missing.push("pubsub.projectId (or PUBSUB_PROJECT_ID)");
+    }
+    if (missing.length > 0) {
+      throw new Error(`Missing required configuration: ${missing.join(", ")}`);
+    }
+    const resolvedServiceName = serviceName;
+    const resolvedFirebaseProjectId = firebaseProjectId;
+    const resolvedPubsubProjectId = pubsubProjectId;
+    const databaseURL = this.config.firebase?.databaseURL ?? this.getDatabaseURL(resolvedFirebaseProjectId, databaseEmulatorHost);
+    const observability = {
+      ...this.config.observability,
+      environment: this.config.observability?.environment ?? process.env.NODE_ENV,
+      logLevel: this.config.observability?.logLevel ?? process.env.LOG_LEVEL,
+      createLogger: this.config.observability?.createLogger ?? true
+    };
+    const getCurrentTime = this.config.getCurrentTime ?? (() => /* @__PURE__ */ new Date());
+    this.resolvedConfig = {
+      serviceName: resolvedServiceName,
+      firebase: {
+        projectId: resolvedFirebaseProjectId,
+        databaseURL,
+        firestoreEmulatorHost,
+        databaseEmulatorHost
+      },
+      pubsub: {
+        projectId: resolvedPubsubProjectId,
+        emulatorHost: pubsubEmulatorHost,
+        topicPrefix: this.config.pubsub?.topicPrefix ?? process.env.PUBSUB_TOPIC_PREFIX ?? resolvedServiceName,
+        subscriptionId: this.config.pubsub?.subscriptionId ?? resolvedServiceName,
+        subscriptionOptions: this.config.pubsub?.subscriptionOptions,
+        autoCreateResources: this.config.pubsub?.autoCreateResources ?? true,
+        cleanupOnClose: this.config.pubsub?.cleanupOnClose ?? false,
+        closePubSubClient: this.config.pubsub?.closePubSubClient ?? true
+      },
+      observability,
+      projections: this.config.projections ?? [],
+      getCurrentTime,
+      dependencies: this.config.dependencies ?? [],
+      includeDefaultDependencyChecks: this.config.includeDefaultDependencyChecks ?? true,
+      includeRealtimeDatabaseCheck: this.config.includeRealtimeDatabaseCheck ?? true,
+      autoStartMessageBus: this.config.autoStartMessageBus ?? true,
+      shutdownOnDependencyFailure: this.config.shutdownOnDependencyFailure ?? true,
+      shutdown: {
+        timeoutMs: this.config.shutdown?.timeoutMs ?? 3e4,
+        exitOnComplete: this.config.shutdown?.exitOnComplete ?? false,
+        exitFn: this.config.shutdown?.exitFn
+      },
+      eventStore: {
+        collections: this.config.eventStore?.collections
+      },
+      _testOverrides: this.config._testOverrides
+    };
+    return this.resolvedConfig;
+  }
+  getDatabaseURL(projectId, emulatorHost) {
+    if (emulatorHost) {
+      return `http://${emulatorHost}?ns=${projectId}`;
+    }
+    return `https://${projectId}-default-rtdb.firebaseio.com`;
+  }
+  getDependencyChecker() {
+    if (!this.dependencyChecker) {
+      this.dependencyChecker = new DependencyChecker({ logger: this.getLogger() });
+    }
+    return this.dependencyChecker;
+  }
+  getShutdownManager() {
+    if (!this.shutdownManager) {
+      this.shutdownManager = new GracefulShutdown({
+        ...this.resolveConfig().shutdown,
+        logger: this.getLogger()
+      });
+    }
+    return this.shutdownManager;
+  }
+  registerDefaultShutdownTasks(options) {
+    const shutdownManager = this.getShutdownManager();
+    if (options.messageBus?.close) {
+      shutdownManager.register({
+        name: "messageBus",
+        close: () => options.messageBus.close()
+      });
+    }
+    if (typeof options.firestore.terminate === "function") {
+      shutdownManager.register({
+        name: "firestore",
+        close: () => options.firestore.terminate()
+      });
+    }
+    if (typeof options.firebaseApp.delete === "function") {
+      shutdownManager.register({
+        name: "firebaseApp",
+        close: () => options.firebaseApp.delete()
+      });
+    }
+  }
+  buildDefaultDependencyChecks(ctx) {
+    const checks = [];
+    if (this.resolveConfig().autoStartMessageBus) {
+      checks.push({
+        name: "PubSub",
+        check: () => ctx.messageBus.start(),
+        successMessage: "Message bus started"
+      });
+    }
+    checks.push(...this.buildStoreDependencyChecks(ctx));
+    return checks;
+  }
+  buildStoreDependencyChecks(ctx) {
+    const checks = [
+      {
+        name: "Firestore",
+        check: async () => {
+          await ctx.firestore.collection("_healthcheck").limit(1).get();
+        }
+      }
+    ];
+    if (this.resolveConfig().includeRealtimeDatabaseCheck) {
+      checks.push({
+        name: "Realtime Database",
+        check: async () => {
+          await ctx.database.ref("_healthcheck/connection").once("value");
+        }
+      });
+    }
+    return checks;
+  }
+};
+
+export {
+  FirebaseInitializer,
+  PubSubInitializer,
+  createEventStore,
+  DependencyTimeoutError,
+  startDependency,
+  DependencyChecker,
+  ShutdownTimeoutError,
+  GracefulShutdown,
+  registerSignalHandlers,
+  DependencyUnavailableError,
+  ServiceBootstrap
+};
+//# sourceMappingURL=chunk-XUV26TX4.js.map