@plyaz/core 1.10.0 → 1.11.0

package/dist/entry-frontend.js

@@ -2980,6 +2980,11 @@ var Core = class _Core {
           environment: globalEnvironment,
           runtime,
           apiClient: apiConfig ? { baseURL: apiConfig.baseURL, ...apiConfig } : void 0,
+          db: options.db,
+          cache: options.cache,
+          storage: options.storage,
+          notifications: options.notifications,
+          observability: options.observability,
           services: mergedServices,
           stores: {
             // Returns specific slice from namespaced root store (type-safe)
@@ -3789,26 +3794,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 = types.BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
     const errorEventCleanup = CoreEventManager.on(
       core.CORE_EVENTS.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 = !types.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.
@@ -6772,7 +6827,7 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
   // Constructor
   // ─────────────────────────────────────────────────────────────────────────
   constructor(config = {}, options) {
-    const apiBasePath = config.apiBasePath || "/api/examples";
+    const apiBasePath = config.apiBasePath || "";
     super({
       serviceName: "ExampleFrontendService",
       supportedRuntimes: ["frontend"],
@@ -6797,20 +6852,20 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
         // Note: Use relative paths since apiClient.baseURL is already set to apiBasePath
         fetchers: {
           fetchAll: /* @__PURE__ */ __name(async (query) => {
-            return this.apiClient.get("", { params: query });
+            return this.apiClient.get("/examples", { params: query });
           }, "fetchAll"),
           fetchById: /* @__PURE__ */ __name(async (id) => {
-            return this.apiClient.get(`/${id}`);
+            return this.apiClient.get(`/examples/${id}`);
           }, "fetchById"),
           create: /* @__PURE__ */ __name(async (data) => {
-            return this.apiClient.post("", data);
+            return this.apiClient.post("/examples", data);
           }, "create"),
           update: /* @__PURE__ */ __name(async (payload) => {
             const { id, data } = payload;
-            return this.apiClient.patch(`/${id}`, data);
+            return this.apiClient.patch(`/examples/${id}`, data);
           }, "update"),
           delete: /* @__PURE__ */ __name(async (id) => {
-            return this.apiClient.delete(`/${id}`);
+            return this.apiClient.delete(`/examples/${id}`);
           }, "delete")
         }
         // Store handlers - customize how data syncs to store
@@ -6878,7 +6933,7 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
       // The ?? operator only falls through on null/undefined, not empty strings.
       // An empty string is not a valid API path, so we treat it as "not provided" and fall through to default.
       // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || "/api/examples"
+      apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || ""
     };
     const service = new _FrontendExampleDomainService(mergedConfig, options);
     if (mergedConfig.autoFetch) {
@@ -7250,7 +7305,7 @@ var FilesMapper = new FilesMapperClass();
 var logger4 = new logger$1.PackageLogger({ packageName: "core", service: "FrontendFilesDomainService" });
 var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseFrontendDomainService {
   constructor(config = {}, options) {
-    const apiBasePath = config.apiBasePath || "/api";
+    const apiBasePath = config.apiBasePath || "";
     super({
       serviceName: "FrontendFilesDomainService",
       supportedRuntimes: ["frontend"],
@@ -7313,7 +7368,7 @@ var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseF
       // The ?? operator only falls through on null/undefined, not empty strings.
       // An empty string is not a valid API path, so we treat it as "not provided" and fall through to default.
       // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || "/api"
+      apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || ""
     };
     return new _FrontendFilesDomainService(mergedConfig, options);
   }
@@ -9074,7 +9129,10 @@ async function initializeServices(config) {
     globalThis.console.log("[PlyazProvider] Initializing domain services...");
   }
   await ServiceRegistry.initialize({
+    environment: config.environment,
+    runtime: config.runtime ?? detectRuntime(),
     apiClient: { baseURL: config.api.baseURL },
+    observability: config.observability,
     services: config.services,
     // Provide store registry for injecting stores into services
     stores: createStoreRegistry()