teraprox-core-sdk 0.3.2 → 0.3.5

package/dist/index.mjs

@@ -2,18 +2,296 @@ import {
   CoreServiceContext,
   DevAutoLogin,
   FederatedBridge,
+  NullObservabilityAdapter,
   StandaloneProvider,
   createReducersBundle
-} from "./chunk-PATJPPYP.mjs";
+} from "./chunk-JK654W4P.mjs";
+
+// src/adapters/null/NullObjectAdapters.ts
+var NullToastService = class {
+  success(message) {
+    console.log(`[Toast Fallback] SUCCESS: ${message}`);
+  }
+  warning(message) {
+    console.warn(`[Toast Fallback] WARNING: ${message}`);
+  }
+  error(message) {
+    console.error(`[Toast Fallback] ERROR: ${message}`);
+  }
+  info(message) {
+    console.info(`[Toast Fallback] INFO: ${message}`);
+  }
+};
+var NullHttpController = class {
+  logAndResolve(method, path) {
+    console.warn(`[Http Fallback] MOCK ${method} requisitado para ${path} (Nenhum adapter injetado)`);
+    return Promise.resolve([]);
+  }
+  get(path) {
+    return this.logAndResolve("GET", path);
+  }
+  post(path) {
+    return this.logAndResolve("POST", path);
+  }
+  put(path) {
+    return this.logAndResolve("PUT", path);
+  }
+  patch(path) {
+    return this.logAndResolve("PATCH", path);
+  }
+  delete(path, id) {
+    return this.logAndResolve("DELETE", `${path}/${id}`);
+  }
+  deleteSimple(path) {
+    return this.logAndResolve("DELETE", path);
+  }
+  save(path) {
+    return this.logAndResolve("SAVE", path);
+  }
+  read(path, id) {
+    return this.logAndResolve("READ", `${path}/${id}`);
+  }
+  readAll(path) {
+    return this.logAndResolve("READ_ALL", path);
+  }
+  readAllwithPage(path) {
+    return this.logAndResolve("READ_ALL_PAGE", path);
+  }
+  bulkDelete(path) {
+    return this.logAndResolve("BULK_DELETE", path);
+  }
+};
+var NullCoreService = {
+  toast: new NullToastService(),
+  createController: (context) => {
+    console.warn(`[CoreService Fallback] createController chamado para "${context}" sem Adapter. Usando NullHttpController.`);
+    return new NullHttpController();
+  },
+  subscribe: (mo) => console.log(`[CoreService Fallback] Inscri\xE7\xE3o simulada RTDB: ${mo.context}`),
+  unsubscribe: (mo) => console.log(`[CoreService Fallback] Desinscri\xE7\xE3o simulada RTDB: ${mo.context}`),
+  subscribeEvent: (evt) => console.log(`[CoreService Fallback] Inscri\xE7\xE3o Evento: ${evt}`),
+  unsubscribeEvent: (evt) => console.log(`[CoreService Fallback] Desinscri\xE7\xE3o Evento: ${evt}`),
+  handleLogout: () => console.log(`[CoreService Fallback] Realizando logout...`),
+  hostedByCore: false,
+  observability: new NullObservabilityAdapter()
+};
+
+// src/utils/tracing.ts
+function toHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return toHex(bytes);
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return toHex(bytes);
+}
+function buildTraceparent(traceId, spanId, sampled = true) {
+  return `00-${traceId}-${spanId}-${sampled ? "01" : "00"}`;
+}
+
+// src/adapters/TracingHttpAdapter.ts
+var TracingHttpAdapter = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    this.traceId = generateTraceId();
+  }
+  mergeHeaders(extraHeaders, withContentType = false) {
+    const spanId = generateSpanId();
+    const headers = {
+      traceparent: buildTraceparent(this.traceId, spanId),
+      ...extraHeaders
+    };
+    if (withContentType && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  async request(method, extraPath, data, extraHeaders) {
+    const url = extraPath ? `${this.endpoint}/${extraPath}` : this.endpoint;
+    const isFormData = data instanceof FormData;
+    const headers = this.mergeHeaders(extraHeaders, data !== void 0 && !isFormData);
+    try {
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: data !== void 0 ? isFormData ? data : JSON.stringify(data) : void 0
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return await res.json();
+    } catch (e) {
+      console.warn(`[TracingHttpAdapter] Falha ao fazer ${method} para ${url}:`, e);
+      return [];
+    }
+  }
+  get(path) {
+    return this.request("GET", path || "");
+  }
+  post(path, data, extraHeaders) {
+    return this.request("POST", path || "", data, extraHeaders);
+  }
+  put(path, data, extraHeaders) {
+    return this.request("PUT", path || "", data, extraHeaders);
+  }
+  patch(path, data, extraHeaders) {
+    return this.request("PATCH", path || "", data, extraHeaders);
+  }
+  delete(path, id, extraHeaders) {
+    return this.request("DELETE", `${path || ""}/${id}`, void 0, extraHeaders);
+  }
+  deleteSimple(path, extraHeaders) {
+    return this.request("DELETE", path || "", void 0, extraHeaders);
+  }
+  save(path, data, extraHeaders) {
+    return this.request("POST", path || "", data, extraHeaders);
+  }
+  read(path, id, extraHeaders) {
+    return this.request("GET", `${path || ""}/${id}`, void 0, extraHeaders);
+  }
+  readAll(path, extraHeaders) {
+    return this.request("GET", path || "", void 0, extraHeaders);
+  }
+  readAllwithPage(path) {
+    return this.request("GET", path || "");
+  }
+  bulkDelete(path, ids, extraHeaders) {
+    return this.request("DELETE", path || "", ids, extraHeaders);
+  }
+};
+
+// src/factories/CoreServiceBuilder.ts
+var FetchHttpAdapter = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  async request(method, extraPath, data) {
+    const url = extraPath ? `${this.endpoint}/${extraPath}` : this.endpoint;
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: data ? { "Content-Type": "application/json" } : void 0,
+        body: data ? JSON.stringify(data) : void 0
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return await res.json();
+    } catch (e) {
+      console.warn(`[FetchHttpAdapter] Falha ao fazer ${method} para ${url}:`, e);
+      return [];
+    }
+  }
+  get(path) {
+    return this.request("GET", path || "");
+  }
+  post(path, data) {
+    return this.request("POST", path || "", data);
+  }
+  put(path, data) {
+    return this.request("PUT", path || "", data);
+  }
+  patch(path, data) {
+    return this.request("PATCH", path || "", data);
+  }
+  delete(path, id) {
+    return this.request("DELETE", `${path || ""}/${id}`);
+  }
+  deleteSimple(path) {
+    return this.request("DELETE", path || "");
+  }
+  save(path, data) {
+    return this.request("POST", path || "", data);
+  }
+  read(path, id) {
+    return this.request("GET", `${path || ""}/${id}`);
+  }
+  readAll(path) {
+    return this.request("GET", path || "");
+  }
+  readAllwithPage(path) {
+    return this.request("GET", path || "");
+  }
+  bulkDelete(path) {
+    return this.request("DELETE", path || "");
+  }
+};
+var CoreServiceBuilder = class {
+  constructor() {
+    this._toast = new NullToastService();
+    this._hostedByCore = false;
+    this._observability = new NullObservabilityAdapter();
+    this._tracing = false;
+  }
+  withToast(toast) {
+    this._toast = toast;
+    return this;
+  }
+  withHttpEndpoint(url) {
+    this._httpEndpoint = url;
+    return this;
+  }
+  withRtdbConfig(config) {
+    this._rtdbConfig = config;
+    return this;
+  }
+  setHostedByCore(hosted) {
+    this._hostedByCore = hosted;
+    return this;
+  }
+  withObservability(observability) {
+    this._observability = observability;
+    return this;
+  }
+  /**
+   * Ativa Distributed Tracing W3C nos controllers HTTP.
+   * Quando habilitado, `createController` retorna `TracingHttpAdapter` em vez de `FetchHttpAdapter`.
+   * O header `traceparent` é injetado em todas as requisições automaticamente.
+   */
+  withTracing(enabled = true) {
+    this._tracing = enabled;
+    return this;
+  }
+  build() {
+    return {
+      toast: this._toast,
+      createController: (context, baseEndPoint) => {
+        const endpoint = baseEndPoint != null ? baseEndPoint : this._httpEndpoint ? `${this._httpEndpoint}/${context}` : null;
+        if (!endpoint) {
+          console.warn(`[CoreServiceBuilder] HttpEndpoint nulo para "${context}". Usando NullHttpController.`);
+          return new NullHttpController();
+        }
+        return this._tracing ? new TracingHttpAdapter(endpoint) : new FetchHttpAdapter(endpoint);
+      },
+      subscribe: (mo) => {
+        console.log(`[CoreServiceBuilder RTDB] Subscribe > ${mo.context}`);
+      },
+      unsubscribe: (mo) => {
+        console.log(`[CoreServiceBuilder RTDB] Unsubscribe > ${mo.context}`);
+      },
+      subscribeEvent: (evt) => {
+      },
+      unsubscribeEvent: (evt) => {
+      },
+      handleLogout: () => console.log("Logout invocado no Standalone mode"),
+      hostedByCore: this._hostedByCore,
+      observability: this._observability
+    };
+  }
+};
 
 // src/hooks/useCoreService.ts
 import { useContext } from "react";
 function useCoreService() {
   const ctx = useContext(CoreServiceContext);
   if (!ctx) {
-    throw new Error(
-      "useCoreService must be used within a CoreServiceProvider. Are you running outside Core (standalone mode)?"
-    );
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        "[useCoreService] rodando sem Provider. O SDK ativou os Fallbacks (Null Object Pattern)."
+      );
+    }
+    return NullCoreService;
   }
   return ctx;
 }
@@ -114,6 +392,11 @@ function useNavigator(config) {
   );
 }
 
+// src/hooks/useObservability.ts
+function useObservability() {
+  return useCoreService().observability;
+}
+
 // src/hooks/useFetchData.ts
 import { useState, useCallback as useCallback2, useRef } from "react";
 function useFetchData() {
@@ -1169,6 +1452,39 @@ var {
 } = pickerSlice.actions;
 var pickerReducer_default = pickerSlice.reducer;
 
+// src/utils/webVitals.ts
+function initWebVitals(observability) {
+  if (typeof PerformanceObserver === "undefined") return;
+  try {
+    const lcpObserver = new PerformanceObserver((list) => {
+      const entries = list.getEntries();
+      if (!entries.length) return;
+      const last = entries[entries.length - 1];
+      observability.captureVitals({ name: "LCP", value: Math.round(last.startTime), unit: "ms" });
+    });
+    lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+  } catch (_) {
+  }
+  try {
+    let clsValue = 0;
+    const clsObserver = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const ls = entry;
+        if (!ls.hadRecentInput && typeof ls.value === "number") {
+          clsValue += ls.value;
+        }
+      }
+      observability.captureVitals({
+        name: "CLS",
+        value: parseFloat(clsValue.toFixed(4)),
+        unit: "score"
+      });
+    });
+    clsObserver.observe({ type: "layout-shift", buffered: true });
+  } catch (_) {
+  }
+}
+
 // src/utils/dateUtils.ts
 import dayjs from "dayjs";
 function formatDate(date, format = "DD/MM/YYYY") {
@@ -1213,13 +1529,21 @@ function isBlank(str) {
   return !str || str.trim().length === 0;
 }
 export {
+  CoreServiceBuilder,
   CoreServiceContext,
   DevAutoLogin,
   FederatedBridge,
+  FetchHttpAdapter,
+  NullCoreService,
+  NullHttpController,
+  NullObservabilityAdapter,
+  NullToastService,
   RecursoDisplayer_default as RecursoDisplayer,
   StandaloneProvider,
+  TracingHttpAdapter,
   addDays,
   branchLevelReducer_default as branchLevelReducer,
+  buildTraceparent,
   capitalize,
   clearBranchLevelForm,
   clearPicker,
@@ -1227,6 +1551,9 @@ export {
   daysBetween,
   formatDate,
   formatDateTime,
+  generateSpanId,
+  generateTraceId,
+  initWebVitals,
   isBlank,
   isDateAfter,
   isDateBefore,
@@ -1255,6 +1582,7 @@ export {
   useMatchingObject,
   useNavigator,
   useNotifications,
+  useObservability,
   usePostData,
   useSmartSearch,
   useToast,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teraprox-core-sdk",
-  "version": "0.3.2",
+  "version": "0.3.5",
   "description": "Contrato tipado Core ↔ Federados — interfaces, context, hooks e componentes compartilhados",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -46,7 +46,9 @@
     "react-router-dom": ">=6.0.0"
   },
   "peerDependenciesMeta": {
-    "firebase": { "optional": true }
+    "firebase": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@reduxjs/toolkit": "^2.0.0",
@@ -60,5 +62,5 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0"
   },
-  "license": "UNLICENSED"
+  "license": "MIT"
 }