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

package/dist/chunk-G3V6OOZL.cjs

@@ -0,0 +1,919 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/firebase/FirebaseInitializer.ts
+var _firebaseadmin = require('firebase-admin'); var _firebaseadmin2 = _interopRequireDefault(_firebaseadmin);
+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 {
+  
+  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 = _nullishCoalesce(databaseURL, () => ( this.getDatabaseURL(projectId, databaseEmulatorHost)));
+    const firebaseAdmin = _nullishCoalesce(this.options._firebaseAdmin, () => ( _firebaseadmin2.default));
+    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 = (_nullishCoalesce(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
+var _pubsub2 = require('@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 {
+  
+  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: _nullishCoalesce(emulatorHost, () => ( process.env.PUBSUB_EMULATOR_HOST))
+      });
+      return this.options._pubsub;
+    }
+    const pubsub = new (0, _pubsub2.PubSub)({ projectId });
+    safeLog2.info(logger, "PubSub initialized", {
+      projectId,
+      emulatorHost: _nullishCoalesce(emulatorHost, () => ( process.env.PUBSUB_EMULATOR_HOST)),
+      emulatorMode: this.isEmulatorMode()
+    });
+    return pubsub;
+  }
+};
+
+// src/eventstore/EventStoreFactory.ts
+
+
+
+var _emmettgooglefirestore = require('@emmett-community/emmett-google-firestore');
+
+
+var _emmettgooglerealtimedb = require('@emmett-community/emmett-google-realtime-db');
+var createEventStore = (options) => {
+  const { firestore, database, projections, logger, collections } = options;
+  const observability = logger ? { logger } : void 0;
+  const baseEventStore = _emmettgooglefirestore.asEventStore.call(void 0, 
+    _emmettgooglefirestore.getFirestoreEventStore.call(void 0, firestore, {
+      observability,
+      collections
+    })
+  );
+  if (projections && projections.length > 0) {
+    return _emmettgooglerealtimedb.wireRealtimeDBProjections.call(void 0, {
+      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 } = _nullishCoalesce(options, () => ( {}));
+  const startTime = Date.now();
+  try {
+    await withTimeout(startFn(), timeoutMs);
+    _optionalChain([logger, 'optionalAccess', _2 => _2.info, 'call', _3 => _3({ dependency, durationMs: Date.now() - startTime }, successMessage)]);
+    return true;
+  } catch (error) {
+    _optionalChain([logger, 'optionalAccess', _4 => _4.warn, 'call', _5 => _5(
+      { dependency, durationMs: Date.now() - startTime, ...normalizeErrorContext3(error) },
+      "Unable to reach dependency"
+    )]);
+    return false;
+  }
+};
+var DependencyChecker = class {
+  
+  
+  constructor(options) {
+    this.logger = _optionalChain([options, 'optionalAccess', _6 => _6.logger]);
+    this.defaultTimeoutMs = _optionalChain([options, 'optionalAccess', _7 => _7.defaultTimeoutMs]);
+  }
+  async check(dependency) {
+    const start = Date.now();
+    const timeoutMs = _nullishCoalesce(dependency.timeoutMs, () => ( this.defaultTimeoutMs));
+    try {
+      await withTimeout(dependency.check(), timeoutMs);
+      if (dependency.successMessage) {
+        _optionalChain([this, 'access', _8 => _8.logger, 'optionalAccess', _9 => _9.info, 'call', _10 => _10(
+          { dependency: dependency.name, durationMs: Date.now() - start },
+          dependency.successMessage
+        )]);
+      }
+      return {
+        name: dependency.name,
+        ok: true,
+        required: _nullishCoalesce(dependency.required, () => ( true)),
+        durationMs: Date.now() - start,
+        timedOut: false
+      };
+    } catch (error) {
+      const timedOut = error instanceof DependencyTimeoutError;
+      _optionalChain([this, 'access', _11 => _11.logger, 'optionalAccess', _12 => _12.warn, 'call', _13 => _13(
+        {
+          dependency: dependency.name,
+          durationMs: Date.now() - start,
+          timedOut,
+          ...normalizeErrorContext3(error)
+        },
+        "Dependency check failed"
+      )]);
+      return {
+        name: dependency.name,
+        ok: false,
+        required: _nullishCoalesce(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 = class {
+  
+  
+  
+  
+  __init() {this.tasks = []}
+  __init2() {this.shuttingDown = false}
+  
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.logger = _optionalChain([options, 'optionalAccess', _14 => _14.logger]);
+    this.timeoutMs = _optionalChain([options, 'optionalAccess', _15 => _15.timeoutMs]);
+    this.exitOnComplete = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.exitOnComplete]), () => ( false));
+    this.exitFn = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.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;
+    _optionalChain([this, 'access', _18 => _18.logger, 'optionalAccess', _19 => _19.info, 'call', _20 => _20({ reason }, "Shutting down gracefully")]);
+    const results = [];
+    for (const task of this.tasks) {
+      const start = Date.now();
+      const timeoutMs = _nullishCoalesce(task.timeoutMs, () => ( this.timeoutMs));
+      try {
+        await withTimeout2(task.close(), timeoutMs);
+        results.push({
+          name: task.name,
+          ok: true,
+          timedOut: false,
+          durationMs: Date.now() - start
+        });
+        _optionalChain([this, 'access', _21 => _21.logger, 'optionalAccess', _22 => _22.info, 'call', _23 => _23(
+          { 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
+        });
+        _optionalChain([this, 'access', _24 => _24.logger, 'optionalAccess', _25 => _25.warn, 'call', _26 => _26(
+          {
+            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);
+      _optionalChain([this, 'access', _27 => _27.logger, 'optionalAccess', _28 => _28.error, 'call', _29 => _29(
+        normalizeContext3({ failedTasks }),
+        "Shutdown completed with failures"
+      )]);
+    } else {
+      _optionalChain([this, 'access', _30 => _30.logger, 'optionalAccess', _31 => _31.info, 'call', _32 => _32({}, "Shutdown completed")]);
+    }
+    const result = { reason, exitCode: finalExitCode, tasks: results };
+    this.lastResult = result;
+    if (this.exitOnComplete) {
+      this.exitFn(finalExitCode);
+    }
+    return result;
+  }
+}, _class);
+
+// src/lifecycle/SignalHandlers.ts
+var registerSignalHandlers = (options) => {
+  const signals = _nullishCoalesce(options.signals, () => ( ["SIGINT", "SIGTERM"]));
+  const handlers = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const handler = () => {
+      _optionalChain([options, 'access', _33 => _33.logger, 'optionalAccess', _34 => _34.info, 'call', _35 => _35({ signal }, "Shutdown signal received")]);
+      void options.shutdown(`Signal ${signal} received`, _nullishCoalesce(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
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _emmettobservability = require('@emmett-community/emmett-observability');
+
+
+
+
+var _emmettexpressjswithopenapi = require('@emmett-community/emmett-expressjs-with-openapi');
+var _emmettgooglepubsub = require('@emmett-community/emmett-google-pubsub');
+var DependencyUnavailableError = class extends Error {
+  
+  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 _path2.default.isAbsolute(inputPath) ? inputPath : _path2.default.resolve(process.cwd(), inputPath);
+};
+var ServiceBootstrap = class {
+  
+  
+  
+  
+  
+  
+  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: _optionalChain([options, 'optionalAccess', _36 => _36.signals]),
+      logger: this.getLogger(),
+      exitCode: _optionalChain([options, 'optionalAccess', _37 => _37.exitCode])
+    });
+  }
+  /**
+   * Create an Express app using emmett-expressjs-with-openapi defaults.
+   */
+  async createApp(options) {
+    const logger = this.getLogger();
+    const openApiValidator = _emmettexpressjswithopenapi.createOpenApiValidatorOptions.call(void 0, 
+      resolvePath(options.openApiPath),
+      {
+        ...options.openApiOptions,
+        operationHandlers: resolvePath(options.handlersPath),
+        initializeHandlers: options.initializeHandlers
+      }
+    );
+    return _emmettexpressjswithopenapi.getApplication.call(void 0, {
+      ..._nullishCoalesce(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 = _emmettexpressjswithopenapi.startAPI.call(void 0, app, { port, logger });
+      this.getShutdownManager().registerFirst({
+        name: "httpServer",
+        close: () => new Promise((resolve, reject) => {
+          server.close((error) => {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve();
+          });
+        })
+      });
+      _optionalChain([logger, 'optionalAccess', _38 => _38.info, 'call', _39 => _39({ port: _nullishCoalesce(port, () => ( 3e3)) }, "API server started")]);
+      return { app, server, context: ctx };
+    } catch (error) {
+      _optionalChain([logger, 'optionalAccess', _40 => _40.error, 'call', _41 => _41({ 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: _optionalChain([resolvedConfig, 'access', _42 => _42._testOverrides, 'optionalAccess', _43 => _43.firebaseAdmin])
+    });
+    const firebase = await firebaseInitializer.initialize();
+    const firestore = _nullishCoalesce(_optionalChain([resolvedConfig, 'access', _44 => _44._testOverrides, 'optionalAccess', _45 => _45.firestore]), () => ( firebase.firestore));
+    const database = _nullishCoalesce(_optionalChain([resolvedConfig, 'access', _46 => _46._testOverrides, 'optionalAccess', _47 => _47.database]), () => ( firebase.database));
+    const auth = _nullishCoalesce(_optionalChain([resolvedConfig, 'access', _48 => _48._testOverrides, 'optionalAccess', _49 => _49.auth]), () => ( firebase.auth));
+    const pubsubInitializer = new PubSubInitializer({
+      projectId: resolvedConfig.pubsub.projectId,
+      emulatorHost: resolvedConfig.pubsub.emulatorHost,
+      logger,
+      _pubsub: _optionalChain([resolvedConfig, 'access', _50 => _50._testOverrides, 'optionalAccess', _51 => _51.pubsub])
+    });
+    const pubsub = await pubsubInitializer.initialize();
+    const eventStore = _nullishCoalesce(_optionalChain([resolvedConfig, 'access', _52 => _52._testOverrides, 'optionalAccess', _53 => _53.eventStore]), () => ( createEventStore({
+      firestore,
+      database,
+      projections: resolvedConfig.projections,
+      collections: resolvedConfig.eventStore.collections,
+      logger
+    })));
+    const messageBus = _nullishCoalesce(_optionalChain([resolvedConfig, 'access', _54 => _54._testOverrides, 'optionalAccess', _55 => _55.messageBus]), () => ( _emmettgooglepubsub.getPubSubMessageBus.call(void 0, {
+      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);
+        _optionalChain([this, 'access', _56 => _56.logger, 'optionalAccess', _57 => _57.error, 'call', _58 => _58(
+          {
+            err: error,
+            results: summary.results
+          },
+          "Dependency checks failed"
+        )]);
+        if (resolvedConfig.shutdownOnDependencyFailure) {
+          await this.shutdown("Dependency check failed");
+        }
+        throw error;
+      }
+    }
+    _optionalChain([this, 'access', _59 => _59.logger, 'optionalAccess', _60 => _60.info, 'call', _61 => _61(
+      { 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 (!_optionalChain([ctx, 'access', _62 => _62.messageBus, 'access', _63 => _63.isStarted, 'optionalCall', _64 => _64()])) {
+              throw new Error("Message bus is not started");
+            }
+          }
+        });
+      }
+    }
+    checks.push(...resolvedConfig.dependencies);
+    return this.getDependencyChecker().checkAll(
+      checks.map((check) => ({
+        ...check,
+        timeoutMs: _nullishCoalesce(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 = _emmettobservability.createLogger.call(void 0, {
+      serviceName: resolvedConfig.serviceName,
+      environment: observability.environment,
+      logLevel: observability.logLevel
+    });
+    return this.logger;
+  }
+  resolveConfig() {
+    if (this.resolvedConfig) {
+      return this.resolvedConfig;
+    }
+    const missing = [];
+    const serviceName = _optionalChain([this, 'access', _65 => _65.config, 'access', _66 => _66.serviceName, 'optionalAccess', _67 => _67.trim, 'call', _68 => _68()]);
+    if (!serviceName) {
+      missing.push("serviceName");
+    }
+    const firestoreEmulatorHost = _nullishCoalesce(_optionalChain([this, 'access', _69 => _69.config, 'access', _70 => _70.firebase, 'optionalAccess', _71 => _71.firestoreEmulatorHost]), () => ( process.env.FIRESTORE_EMULATOR_HOST));
+    const databaseEmulatorHost = _nullishCoalesce(_optionalChain([this, 'access', _72 => _72.config, 'access', _73 => _73.firebase, 'optionalAccess', _74 => _74.databaseEmulatorHost]), () => ( process.env.FIREBASE_DATABASE_EMULATOR_HOST));
+    const pubsubEmulatorHost = _nullishCoalesce(_optionalChain([this, 'access', _75 => _75.config, 'access', _76 => _76.pubsub, 'optionalAccess', _77 => _77.emulatorHost]), () => ( process.env.PUBSUB_EMULATOR_HOST));
+    const hasEmulator = Boolean(firestoreEmulatorHost) || Boolean(databaseEmulatorHost) || Boolean(pubsubEmulatorHost);
+    const firebaseProjectId = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _78 => _78.config, 'access', _79 => _79.firebase, 'optionalAccess', _80 => _80.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 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _81 => _81.config, 'access', _82 => _82.pubsub, 'optionalAccess', _83 => _83.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 = _nullishCoalesce(_optionalChain([this, 'access', _84 => _84.config, 'access', _85 => _85.firebase, 'optionalAccess', _86 => _86.databaseURL]), () => ( this.getDatabaseURL(resolvedFirebaseProjectId, databaseEmulatorHost)));
+    const observability = {
+      ...this.config.observability,
+      environment: _nullishCoalesce(_optionalChain([this, 'access', _87 => _87.config, 'access', _88 => _88.observability, 'optionalAccess', _89 => _89.environment]), () => ( process.env.NODE_ENV)),
+      logLevel: _nullishCoalesce(_optionalChain([this, 'access', _90 => _90.config, 'access', _91 => _91.observability, 'optionalAccess', _92 => _92.logLevel]), () => ( process.env.LOG_LEVEL)),
+      createLogger: _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.config, 'access', _94 => _94.observability, 'optionalAccess', _95 => _95.createLogger]), () => ( true))
+    };
+    const getCurrentTime = _nullishCoalesce(this.config.getCurrentTime, () => ( (() => /* @__PURE__ */ new Date())));
+    this.resolvedConfig = {
+      serviceName: resolvedServiceName,
+      firebase: {
+        projectId: resolvedFirebaseProjectId,
+        databaseURL,
+        firestoreEmulatorHost,
+        databaseEmulatorHost
+      },
+      pubsub: {
+        projectId: resolvedPubsubProjectId,
+        emulatorHost: pubsubEmulatorHost,
+        topicPrefix: _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _96 => _96.config, 'access', _97 => _97.pubsub, 'optionalAccess', _98 => _98.topicPrefix]), () => ( process.env.PUBSUB_TOPIC_PREFIX)), () => ( resolvedServiceName)),
+        subscriptionId: _nullishCoalesce(_optionalChain([this, 'access', _99 => _99.config, 'access', _100 => _100.pubsub, 'optionalAccess', _101 => _101.subscriptionId]), () => ( resolvedServiceName)),
+        subscriptionOptions: _optionalChain([this, 'access', _102 => _102.config, 'access', _103 => _103.pubsub, 'optionalAccess', _104 => _104.subscriptionOptions]),
+        autoCreateResources: _nullishCoalesce(_optionalChain([this, 'access', _105 => _105.config, 'access', _106 => _106.pubsub, 'optionalAccess', _107 => _107.autoCreateResources]), () => ( true)),
+        cleanupOnClose: _nullishCoalesce(_optionalChain([this, 'access', _108 => _108.config, 'access', _109 => _109.pubsub, 'optionalAccess', _110 => _110.cleanupOnClose]), () => ( false)),
+        closePubSubClient: _nullishCoalesce(_optionalChain([this, 'access', _111 => _111.config, 'access', _112 => _112.pubsub, 'optionalAccess', _113 => _113.closePubSubClient]), () => ( true))
+      },
+      observability,
+      projections: _nullishCoalesce(this.config.projections, () => ( [])),
+      getCurrentTime,
+      dependencies: _nullishCoalesce(this.config.dependencies, () => ( [])),
+      includeDefaultDependencyChecks: _nullishCoalesce(this.config.includeDefaultDependencyChecks, () => ( true)),
+      includeRealtimeDatabaseCheck: _nullishCoalesce(this.config.includeRealtimeDatabaseCheck, () => ( true)),
+      autoStartMessageBus: _nullishCoalesce(this.config.autoStartMessageBus, () => ( true)),
+      shutdownOnDependencyFailure: _nullishCoalesce(this.config.shutdownOnDependencyFailure, () => ( true)),
+      shutdown: {
+        timeoutMs: _nullishCoalesce(_optionalChain([this, 'access', _114 => _114.config, 'access', _115 => _115.shutdown, 'optionalAccess', _116 => _116.timeoutMs]), () => ( 3e4)),
+        exitOnComplete: _nullishCoalesce(_optionalChain([this, 'access', _117 => _117.config, 'access', _118 => _118.shutdown, 'optionalAccess', _119 => _119.exitOnComplete]), () => ( false)),
+        exitFn: _optionalChain([this, 'access', _120 => _120.config, 'access', _121 => _121.shutdown, 'optionalAccess', _122 => _122.exitFn])
+      },
+      eventStore: {
+        collections: _optionalChain([this, 'access', _123 => _123.config, 'access', _124 => _124.eventStore, 'optionalAccess', _125 => _125.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 (_optionalChain([options, 'access', _126 => _126.messageBus, 'optionalAccess', _127 => _127.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;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FirebaseInitializer = FirebaseInitializer; exports.PubSubInitializer = PubSubInitializer; exports.createEventStore = createEventStore; exports.DependencyTimeoutError = DependencyTimeoutError; exports.startDependency = startDependency; exports.DependencyChecker = DependencyChecker; exports.ShutdownTimeoutError = ShutdownTimeoutError; exports.GracefulShutdown = GracefulShutdown; exports.registerSignalHandlers = registerSignalHandlers; exports.DependencyUnavailableError = DependencyUnavailableError; exports.ServiceBootstrap = ServiceBootstrap;
+//# sourceMappingURL=chunk-G3V6OOZL.cjs.map