@plyaz/core 1.10.1 → 1.11.1

package/dist/init/nestjs/index.mjs

@@ -7,7 +7,7 @@ import { generateRequestId, CorePackageError, BaseError, initializeErrorSystem,
 import { ERROR_CODES as ERROR_CODES$1, ERROR_CATEGORY as ERROR_CATEGORY$1, DATABASE_ERROR_CODES } from '@plyaz/types/errors';
 import { OBSERVABILITY_METRICS } from '@plyaz/types/observability';
 import { clearEventEmitter, setEventEmitter, initializeGlobalErrorHandler } from '@plyaz/errors/middleware';
-import { STORE_KEYS, useRootStore, createStandaloneFeatureFlagStore } from '@plyaz/store';
+import { STORE_KEYS, createStandaloneFeatureFlagStore } from '@plyaz/store';
 import { CORE_EVENTS as CORE_EVENTS$1 } from '@plyaz/types/core';
 import { createDatabaseService } from '@plyaz/db';
 
@@ -969,7 +969,7 @@ var LoggerAdapter = class extends BaseAdapter {
     let status = "unset";
     let statusMessage;
     const logSpans = this.logSpans;
-    const logger2 = this.observabilityLogger;
+    const logger3 = this.observabilityLogger;
     return {
       context,
       setAttribute: /* @__PURE__ */ __name((key, value) => {
@@ -981,7 +981,7 @@ var LoggerAdapter = class extends BaseAdapter {
       addEvent: /* @__PURE__ */ __name((event) => {
         events.push(event);
         if (logSpans) {
-          logger2.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
+          logger3.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             eventAttributes: event.attributes
@@ -996,7 +996,7 @@ var LoggerAdapter = class extends BaseAdapter {
         const duration = (endTime ?? Date.now()) - startTime;
         if (logSpans) {
           const logMethod = status === "error" ? "warn" : "debug";
-          logger2[logMethod](`[SPAN END] ${options.name}`, {
+          logger3[logMethod](`[SPAN END] ${options.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             durationMs: duration,
@@ -1009,7 +1009,7 @@ var LoggerAdapter = class extends BaseAdapter {
       }, "end"),
       recordException: /* @__PURE__ */ __name((error) => {
         if (logSpans) {
-          logger2.error(`[SPAN ERROR] ${options.name}`, {
+          logger3.error(`[SPAN ERROR] ${options.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             error: error.message,
@@ -2500,6 +2500,24 @@ var Core = class _Core {
      */
     this._rootStore = null;
   }
+  static {
+    /**
+     * Injected store hook for frontend (set via setRootStoreHook before initialize).
+     * This is used instead of directly importing from @plyaz/store to prevent
+     * duplicate store instances when bundlers create multiple module copies.
+     */
+    this._injectedStoreHook = null;
+  }
+  /**
+   * Set the root store hook for frontend use.
+   * Must be called before Core.initialize() when running in browser.
+   * PlyazProvider calls this automatically with the store prop.
+   *
+   * @param store - The useRootStore hook from @plyaz/store
+   */
+  static setRootStoreHook(store) {
+    _Core._injectedStoreHook = store;
+  }
   /**
    * Setup environment and context
    */
@@ -3410,8 +3428,14 @@ var Core = class _Core {
   static async initializeRootStore(config, verbose) {
     const isFrontend = typeof window !== "undefined";
     if (isFrontend) {
-      _Core.log("Using frontend root store (Zustand)", verbose);
-      _Core._rootStore = useRootStore;
+      if (!_Core._injectedStoreHook) {
+        throw new CorePackageError(
+          "Root store hook not set. Call Core.setRootStoreHook(useRootStore) before Core.initialize(), or use PlyazProvider with the store prop: <PlyazProvider store={useRootStore} ...>",
+          ERROR_CODES.CLIENT_INITIALIZATION_FAILED
+        );
+      }
+      _Core.log("Using frontend root store (Zustand) - injected via setRootStoreHook", verbose);
+      _Core._rootStore = _Core._injectedStoreHook;
     } else {
       _Core.log("Creating backend composite store (in-memory)", verbose);
       const ServerErrorMiddleware = getCoreDependency("ServerErrorMiddleware");
@@ -3520,26 +3544,76 @@ var Core = class _Core {
       errorStore,
       _Core.buildErrorHandlerConfig(_Core._errorConfig)
     );
+    _Core.setupErrorEventSubscription(verbose);
+    _Core.setupErrorStoreSubscription(verbose);
+    _Core.log("Global error handler initialized with CoreEventManager integration", verbose);
+    if (_Core._errorConfig.httpHandler !== false) {
+      await _Core.createHttpErrorHandler(_Core._errorConfig, verbose);
+    }
+  }
+  /**
+   * Log serialized errors with full details.
+   */
+  static logErrors(errors, prefix = "ErrorStore") {
+    for (const err of errors) {
+      _Core.logger.error(`[${prefix}] ${err.code}: ${err.message}`, {
+        id: err.id,
+        code: err.code,
+        message: err.message,
+        category: err.category,
+        source: err.source,
+        status: err.status,
+        isRetryable: err.isRetryable,
+        context: err.context,
+        timestamp: err.timestamp
+      });
+    }
+  }
+  /**
+   * Setup SYSTEM.ERROR event subscription for error store updates.
+   * Backend: Also logs errors with full details.
+   * Frontend: Only updates store (logging handled by store subscription).
+   */
+  static setupErrorEventSubscription(verbose) {
+    const isBackend = BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
     const errorEventCleanup = CoreEventManager.on(
       CORE_EVENTS$1.SYSTEM.ERROR,
       (event) => {
         if (!_Core._rootStore) return;
         try {
           const { errors } = event.data;
-          if (errors && errors.length > 0) {
-            _Core._rootStore.getState().errors.addErrors(errors);
-            _Core.log(`Added ${errors.length} error(s) to store`, verbose);
-          }
+          if (!errors || errors.length === 0) return;
+          _Core._rootStore.getState().errors.addErrors(errors);
+          if (isBackend) _Core.logErrors(errors);
+          _Core.log(`Added ${errors.length} error(s) to store`, verbose);
         } catch (e) {
           _Core.logger.error("Failed to handle error event", { error: e });
         }
       }
     );
     _Core._eventCleanupFns.push(errorEventCleanup);
-    _Core.log("Global error handler initialized with CoreEventManager integration", verbose);
-    if (_Core._errorConfig.httpHandler !== false) {
-      await _Core.createHttpErrorHandler(_Core._errorConfig, verbose);
-    }
+  }
+  /**
+   * Setup error store subscription for frontend logging.
+   * Logs new errors when they're added to the store.
+   * Only active for non-backend runtimes (browser, nextjs, nuxt, edge).
+   */
+  static setupErrorStoreSubscription(verbose) {
+    const isFrontend = !BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
+    if (!isFrontend || !_Core._rootStore) return;
+    let prevErrorCount = 0;
+    const storeUnsubscribe = _Core._rootStore.subscribe((state) => {
+      const currentCount = state.errors.errorCount;
+      if (currentCount <= prevErrorCount) {
+        prevErrorCount = currentCount;
+        return;
+      }
+      const newErrors = state.errors.errors.slice(0, currentCount - prevErrorCount);
+      _Core.logErrors(newErrors, "ErrorStore:FE");
+      prevErrorCount = currentCount;
+    });
+    _Core._eventCleanupFns.push(storeUnsubscribe);
+    _Core.log("Error store subscription initialized for frontend", verbose);
   }
   /**
    * Create HTTP error handler based on detected runtime.
@@ -3727,6 +3801,7 @@ var Core = class _Core {
     _Core.log("Feature flags initialized", verbose);
   }
 };
+var logger2 = new PackageLogger({ packageName: "core", service: "DbService" });
 var DEFAULT_ENCRYPTION_FIELDS = {
   // User PII
   users: ["password_hash", "phone_number", "date_of_birth"],
@@ -3820,6 +3895,41 @@ var DbService = class _DbService {
     };
     CoreEventManager.emit(CORE_EVENTS$1.DATABASE.ERROR, payload);
   }
+  /**
+   * Creates merged event handlers that wrap user-provided handlers.
+   * Adds Core-level logging and forwards to user handlers.
+   *
+   * Note: Unlike StorageService/NotificationService, DB events don't emit
+   * to CoreEventManager by default (too verbose). User handlers can emit
+   * if needed.
+   *
+   * @param userHandlers - User-provided event handlers from config
+   * @returns Merged handlers with Core logging + user handlers
+   */
+  static createMergedEventHandlers(userHandlers) {
+    return {
+      ...userHandlers,
+      onAfterWrite: /* @__PURE__ */ __name(async (event) => {
+        logger2.debug("Database write completed", {
+          operation: event.operation,
+          table: event.table,
+          duration: event.duration
+        });
+        if (userHandlers?.onAfterWrite) {
+          await userHandlers.onAfterWrite(event);
+        }
+      }, "onAfterWrite"),
+      onAfterRead: /* @__PURE__ */ __name(async (event) => {
+        logger2.debug("Database read completed", {
+          table: event.table,
+          duration: event.duration
+        });
+        if (userHandlers?.onAfterRead) {
+          await userHandlers.onAfterRead(event);
+        }
+      }, "onAfterRead")
+    };
+  }
   /**
    * Gets the singleton instance of DbService
    *
@@ -4024,6 +4134,8 @@ var DbService = class _DbService {
     if (cache) dbConfig.cache = cache;
     if (audit) dbConfig.audit = audit;
     if (encryption) dbConfig.encryption = encryption;
+    const events = _DbService.createMergedEventHandlers(config.events);
+    if (events) dbConfig.events = events;
     return dbConfig;
   }
   /**