@plyaz/core 1.10.1 → 1.11.1

package/dist/entry-frontend-browser.js

@@ -2774,6 +2774,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
    */
@@ -3684,8 +3702,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 = store.useRootStore;
+      if (!_Core._injectedStoreHook) {
+        throw new errors.CorePackageError(
+          "Root store hook not set. Call Core.setRootStoreHook(useRootStore) before Core.initialize(), or use PlyazProvider with the store prop: <PlyazProvider store={useRootStore} ...>",
+          types.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");
@@ -3794,26 +3818,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.
@@ -6820,7 +6894,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"],
@@ -6845,20 +6919,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
@@ -6926,7 +7000,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) {
@@ -7087,7 +7161,10 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
       const response = await this.apiClient.post(endpoint, data);
       if (!this.isResponseSuccess(response)) {
         const error = this.extractResponseError(response);
-        throw new Error(`Failed to send email: ${JSON.stringify(error)}`);
+        throw new errors.CorePackageError(
+          `Failed to send email: ${JSON.stringify(error)}`,
+          types.ERROR_CODES.CORE_OPERATION_FAILED
+        );
       }
       const result = this.unwrapResponseData(response.data);
       CoreEventManager.emit(`${this.eventPrefix}:email:sent`, { result });
@@ -8629,22 +8706,27 @@ async function initializeCore(config) {
   });
 }
 __name(initializeCore, "initializeCore");
-function createStoreRegistry() {
+function createStoreRegistry(store) {
   return {
     getStore(key) {
-      const state = store.useRootStore.getState();
+      const state = store.getState();
       if (!state) {
         logger4.warn(
           "Store state is undefined - store may not be hydrated yet. This can cause side effects if called during SSR or before initialization."
         );
         return void 0;
       }
-      return state[key];
+      const slice = state[key];
+      logger4.debug(`[StoreRegistry] getStore('${key}')`, {
+        hasSlice: !!slice,
+        sliceKeys: slice ? Object.keys(slice) : []
+      });
+      return slice;
     }
   };
 }
 __name(createStoreRegistry, "createStoreRegistry");
-async function initializeServices(config) {
+async function initializeServices(config, store) {
   if (!config.services || config.services.length === 0) return;
   if (config.verbose) {
     globalThis.console.log("[PlyazProvider] Initializing domain services...");
@@ -8656,7 +8738,7 @@ async function initializeServices(config) {
     observability: config.observability,
     services: config.services,
     // Provide store registry for injecting stores into services
-    stores: createStoreRegistry()
+    stores: createStoreRegistry(store)
   });
   if (config.verbose) {
     globalThis.console.log(
@@ -8693,6 +8775,7 @@ function createServicesObject(config, featureFlagStore) {
 __name(createServicesObject, "createServicesObject");
 function PlyazProvider({
   children,
+  store,
   config,
   loading,
   error: errorComponent,
@@ -8706,8 +8789,9 @@ function PlyazProvider({
   const initialize = react.useCallback(async () => {
     try {
       setError(null);
+      Core.setRootStoreHook(store);
       await initializeCore(config);
-      await initializeServices(config);
+      await initializeServices(config, store);
       await initializeFeatureFlags(featureFlagStore);
       setIsReady(true);
       onReady?.(createServicesObject(config, featureFlagStore));
@@ -8717,7 +8801,7 @@ function PlyazProvider({
       onError?.(initError);
       globalThis.console.error("[PlyazProvider] Initialization failed:", initError);
     }
-  }, [config, featureFlagStore, onReady, onError]);
+  }, [config, store, featureFlagStore, onReady, onError]);
   const reinitialize = react.useCallback(async () => {
     setIsReady(false);
     ServiceRegistry.disposeAll();
@@ -8766,8 +8850,9 @@ __name(PlyazProvider, "PlyazProvider");
 function usePlyaz() {
   const context = react.useContext(PlyazContext);
   if (!context) {
-    throw new Error(
-      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>"
+    throw new errors.CorePackageError(
+      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>",
+      types.ERROR_CODES.CORE_PROVIDER_NOT_FOUND
     );
   }
   return context;
@@ -8776,7 +8861,10 @@ __name(usePlyaz, "usePlyaz");
 function useApi() {
   const { api, isReady } = usePlyaz();
   if (!isReady || !api) {
-    throw new Error("API client is not ready. Make sure PlyazProvider has finished initializing.");
+    throw new errors.CorePackageError(
+      "API client is not ready. Make sure PlyazProvider has finished initializing.",
+      types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return api;
 }
@@ -8819,7 +8907,10 @@ __name(useEnvironment, "useEnvironment");
 function useService(key) {
   const { getService, isReady } = usePlyaz();
   if (!isReady) {
-    throw new Error(`PlyazProvider not ready. Cannot get service '${key}'.`);
+    throw new errors.CorePackageError(
+      `PlyazProvider not ready. Cannot get service '${key}'.`,
+      types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return react.useMemo(() => getService(key), [getService, key]);
 }
@@ -9066,7 +9157,7 @@ var FilesMapper = new FilesMapperClass();
 var logger5 = 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"],
@@ -9129,7 +9220,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);
   }
@@ -9358,10 +9449,6 @@ function createFeatureFlagStoreConfig(options) {
 }
 __name(createFeatureFlagStoreConfig, "createFeatureFlagStoreConfig");
 
-Object.defineProperty(exports, "useRootStore", {
-  enumerable: true,
-  get: function () { return store.useRootStore; }
-});
 exports.ApiClientService = ApiClientService;
 exports.ApiProvider = ApiProvider;
 exports.BaseDomainService = BaseDomainService;