@oondemand/oon-core-front 0.5.6 → 0.6.1

package/dist/chunk-VJ7YNFF7.js

@@ -0,0 +1,694 @@
+// src/api/ApiProvider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+
+// src/api/coreClient.ts
+function createCoreClient(http) {
+  return {
+    async metadata() {
+      const { data } = await http.get("/core/metadata");
+      return data;
+    },
+    async models() {
+      const { data } = await http.get("/core/models");
+      return data.results;
+    },
+    async model(name) {
+      const { data } = await http.get(`/core/models/${name}`);
+      return data;
+    },
+    async permissions() {
+      const { data } = await http.get(
+        "/core/permissions"
+      );
+      return data.results;
+    },
+    async menus() {
+      const { data } = await http.get("/core/menus");
+      return data.results;
+    }
+  };
+}
+
+// src/api/createRestClient.ts
+import axios2 from "axios";
+
+// src/api/errorNormalizer.ts
+import axios from "axios";
+function normalizeError(err) {
+  if (axios.isAxiosError(err)) {
+    const status = err.response?.status;
+    const data = err.response?.data;
+    const responseRequestId = err.response?.headers?.["x-request-id"] ?? err.response?.headers?.["x-correlation-id"];
+    const contentType = String(err.response?.headers?.["content-type"] || "");
+    const isTextPayload = typeof data === "string";
+    const isProbablyHtml = isTextPayload && /<html|<!doctype/i.test(data);
+    if (isTextPayload || contentType && !contentType.includes("json")) {
+      return {
+        code: codeFromStatus(status),
+        message: nonJsonMessage(status, err.config?.url, isProbablyHtml),
+        status,
+        details: isProbablyHtml ? void 0 : data,
+        requestId: responseRequestId
+      };
+    }
+    const rawError = data?.error;
+    const envelope = rawError && typeof rawError === "object" ? rawError : void 0;
+    const legacyDetails = envelope && envelope.details === void 0 && envelope.field ? envelope : void 0;
+    const rawTechnicalDetails = typeof rawError === "string" ? { technicalMessage: rawError } : void 0;
+    return {
+      code: envelope?.code || data?.code || codeFromStatus(status),
+      message: envelope?.message || data?.message || err.message || "Erro inesperado.",
+      status,
+      details: envelope?.details ?? legacyDetails ?? data?.details ?? rawTechnicalDetails,
+      requestId: envelope?.requestId || data?.requestId || responseRequestId
+    };
+  }
+  if (err instanceof Error) {
+    return { code: "UNKNOWN", message: err.message };
+  }
+  return { code: "UNKNOWN", message: "Erro inesperado." };
+}
+function nonJsonMessage(status, url, html) {
+  const path = url ? ` (${url})` : "";
+  if (status === 404) {
+    return `Rota da API n\xE3o encontrada${path}. Verifique VITE_API_URL, porta do backend e modo da Central.`;
+  }
+  if (html) {
+    return `Backend retornou HTML em vez de JSON${path}. Verifique se o frontend est\xE1 apontando para a API correta.`;
+  }
+  return `Backend retornou resposta n\xE3o JSON${path}. Verifique a configura\xE7\xE3o da API.`;
+}
+function codeFromStatus(status) {
+  switch (status) {
+    case 400:
+      return "VALIDATION_ERROR";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 409:
+      return "CONFLICT";
+    default:
+      return status && status >= 500 ? "SERVER_ERROR" : "REQUEST_ERROR";
+  }
+}
+
+// src/api/createRestClient.ts
+function readCookie(name) {
+  try {
+    const prefix = `${name}=`;
+    const value = document.cookie.split(";").map((item) => item.trim()).find((item) => item.startsWith(prefix));
+    return value ? decodeURIComponent(value.slice(prefix.length)) : null;
+  } catch {
+    return null;
+  }
+}
+function createRestClient(deps) {
+  const { api, getToken, getTenantId, onUnauthorized, appId, runtimeMode = "platform" } = deps;
+  const prefix = api.versionPrefix ?? "";
+  const instance = axios2.create({
+    baseURL: `${api.baseUrl.replace(/\/$/, "")}${prefix}`,
+    timeout: api.timeout ?? 3e4,
+    withCredentials: runtimeMode === "local"
+  });
+  instance.interceptors.request.use((config) => {
+    const token = runtimeMode === "local" ? null : getToken();
+    if (token && !config.headers.Authorization) {
+      config.headers.Authorization = `Bearer ${token}`;
+    }
+    const explicitTenantId = config.headers.get("x-oon-tenant-id");
+    const tenantId = explicitTenantId || getTenantId?.();
+    if (tenantId) config.headers.set("x-oon-tenant-id", String(tenantId));
+    else config.headers.delete("x-oon-tenant-id");
+    if (appId) config.headers["x-oon-app"] = appId;
+    if (runtimeMode === "local" && !["get", "head", "options"].includes(String(config.method || "get").toLowerCase())) {
+      const csrf = readCookie("oon_local_csrf");
+      if (csrf) config.headers.set("x-oon-local-csrf", csrf);
+    }
+    return config;
+  });
+  instance.interceptors.response.use(
+    (res) => res,
+    (error) => {
+      const normalized = normalizeError(error);
+      const requestPath = String(error.config?.url || "").split("?")[0].replace(/\/$/, "");
+      const isLogin = requestPath.endsWith("/auth/autenticar");
+      if (normalized.status === 401 && !isLogin) onUnauthorized?.();
+      return Promise.reject(normalized);
+    }
+  );
+  return instance;
+}
+function auditHeaders(audit) {
+  if (!audit) return {};
+  const headers = {};
+  if (audit.origem) headers["x-oon-origin"] = audit.origem;
+  if (audit.module) headers["x-oon-module"] = audit.module;
+  if (audit.entity) headers["x-oon-entity"] = audit.entity;
+  return headers;
+}
+
+// src/api/resourceClient.ts
+var META_KEYS = /* @__PURE__ */ new Set(["pagination", "results", "message", "requestId"]);
+function unwrap(data) {
+  for (const [key, value] of Object.entries(data)) {
+    if (!META_KEYS.has(key) && value && typeof value === "object") {
+      return value;
+    }
+  }
+  return data;
+}
+function createResourceClient(http, basePath) {
+  const base = `/${basePath.replace(/^\/+/, "")}`;
+  return {
+    async list(params) {
+      const { data } = await http.get(base, { params });
+      return data;
+    },
+    async get(id) {
+      const { data } = await http.get(`${base}/${id}`);
+      return unwrap(data);
+    },
+    async create(body, audit) {
+      const { data } = await http.post(base, body, {
+        headers: auditHeaders(audit ?? { origem: "form" })
+      });
+      return unwrap(data);
+    },
+    async update(id, body, audit) {
+      const { data } = await http.put(`${base}/${id}`, body, {
+        headers: auditHeaders(audit ?? { origem: "form" })
+      });
+      return unwrap(data);
+    },
+    async patch(id, body, audit) {
+      const { data } = await http.patch(`${base}/${id}`, body, {
+        headers: auditHeaders(audit ?? { origem: "datagrid" })
+      });
+      return unwrap(data);
+    },
+    async delete(id, audit) {
+      const { data } = await http.delete(`${base}/${id}`, {
+        headers: auditHeaders(audit ?? { origem: "datagrid" })
+      });
+      return unwrap(data);
+    },
+    async importMany(rows, audit) {
+      const { data } = await http.post(
+        `${base}/import`,
+        { rows },
+        { headers: auditHeaders(audit ?? { origem: "import" }) }
+      );
+      return data;
+    },
+    async exportAll(params) {
+      const { data } = await http.get(`${base}/export`, { params });
+      return Array.isArray(data) ? data : data.results;
+    }
+  };
+}
+
+// src/api/ApiProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var ApiContext = createContext(null);
+function ApiProvider({ http, children }) {
+  const value = useMemo(() => {
+    const cache = /* @__PURE__ */ new Map();
+    return {
+      http,
+      core: createCoreClient(http),
+      resource(basePath) {
+        let client = cache.get(basePath);
+        if (!client) {
+          client = createResourceClient(http, basePath);
+          cache.set(basePath, client);
+        }
+        return client;
+      }
+    };
+  }, [http]);
+  return /* @__PURE__ */ jsx(ApiContext.Provider, { value, children });
+}
+function useOonApi() {
+  const ctx = useContext(ApiContext);
+  if (!ctx) throw new Error("useOonApi deve ser usado dentro de <ApiProvider> (oonCoreFront.start).");
+  return ctx;
+}
+function useOonResource(basePath) {
+  const { resource } = useOonApi();
+  return useMemo(() => resource(basePath), [resource, basePath]);
+}
+function useCoreMetadata() {
+  const { core } = useOonApi();
+  return useQuery({
+    queryKey: ["oon", "core", "metadata"],
+    queryFn: () => core.metadata(),
+    staleTime: 5 * 60 * 1e3
+  });
+}
+function useModelSchema(name, enabled = true) {
+  const { core } = useOonApi();
+  return useQuery({
+    queryKey: ["oon", "core", "model", name],
+    queryFn: () => core.model(name),
+    staleTime: 5 * 60 * 1e3,
+    enabled: enabled && !!name
+  });
+}
+
+// src/security/TenantProvider.tsx
+import {
+  createContext as createContext2,
+  useCallback,
+  useContext as useContext2,
+  useMemo as useMemo2,
+  useState
+} from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TenantContext = createContext2(null);
+function applyHeader(http, tenantId) {
+  if (tenantId) {
+    http.defaults.headers.common["x-oon-tenant-id"] = tenantId;
+    return;
+  }
+  delete http.defaults.headers.common["x-oon-tenant-id"];
+}
+function TenantProvider({ http, storage, children }) {
+  const queryClient = useQueryClient();
+  const [activeTenantId, setActiveTenantId] = useState(() => storage.get());
+  const replaceTenant = useCallback(
+    (tenantId) => {
+      const normalized = String(tenantId ?? "").trim() || null;
+      if (normalized) storage.set(normalized);
+      else storage.clear();
+      applyHeader(http, normalized);
+      setActiveTenantId(normalized);
+      queryClient.clear();
+    },
+    [http, queryClient, storage]
+  );
+  const value = useMemo2(
+    () => ({
+      activeTenantId,
+      switchTenant(tenantId) {
+        if (!tenantId?.trim()) throw new Error("tenantId \xE9 obrigat\xF3rio.");
+        replaceTenant(tenantId);
+      },
+      clearTenant() {
+        replaceTenant(null);
+      }
+    }),
+    [activeTenantId, replaceTenant]
+  );
+  return /* @__PURE__ */ jsx2(TenantContext.Provider, { value, children });
+}
+function useOptionalOonTenant() {
+  return useContext2(TenantContext);
+}
+function useOonTenant() {
+  const value = useOptionalOonTenant();
+  if (!value) throw new Error("useOonTenant deve ser usado dentro de TenantProvider.");
+  return value;
+}
+
+// src/security/AuthProvider.tsx
+import {
+  createContext as createContext4,
+  useCallback as useCallback3,
+  useContext as useContext4,
+  useEffect as useEffect2,
+  useState as useState3
+} from "react";
+
+// src/security/tokenStorage.ts
+var STORAGE_KEY = "oon.auth.token";
+function createTokenStorage(namespace) {
+  const key = namespace ? `${STORAGE_KEY}.${namespace}` : STORAGE_KEY;
+  return {
+    get() {
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    set(token) {
+      try {
+        window.localStorage.setItem(key, token);
+      } catch {
+      }
+    },
+    clear() {
+      try {
+        window.localStorage.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function captureTokenFromUrl(tokenParam = "code") {
+  try {
+    const url = new URL(window.location.href);
+    const token = url.searchParams.get(tokenParam);
+    if (!token) return null;
+    url.searchParams.delete(tokenParam);
+    window.history.replaceState({}, document.title, url.pathname + url.search + url.hash);
+    return token;
+  } catch {
+    return null;
+  }
+}
+
+// src/security/ActivationProvider.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback2,
+  useContext as useContext3,
+  useEffect,
+  useState as useState2
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var ActivationContext = createContext3(null);
+function mapStatus(data) {
+  if (["ativa", "ativa_local"].includes(data.status)) return "active";
+  if (data.status === "suspensa") return "suspended";
+  if (data.status === "revogada") return "revoked";
+  if (data.status === "configurando") return "configuring";
+  if (data.status === "erro" && !data.podeAtivar) return "error";
+  return "notActivated";
+}
+function ActivationProvider({
+  http,
+  children
+}) {
+  const [status, setStatus] = useState2("loading");
+  const [details, setDetails] = useState2(null);
+  const refresh = useCallback2(async () => {
+    setStatus("loading");
+    try {
+      const response = await http.get("/ativacao/status");
+      setDetails(response.data);
+      setStatus(mapStatus(response.data));
+    } catch {
+      setStatus("error");
+    }
+  }, [http]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return /* @__PURE__ */ jsx3(ActivationContext.Provider, { value: { status, details, refresh }, children });
+}
+function useOptionalActivation() {
+  return useContext3(ActivationContext);
+}
+function useActivation() {
+  const context = useOptionalActivation();
+  if (!context) {
+    throw new Error(
+      "useActivation deve ser usado dentro de <ActivationProvider>."
+    );
+  }
+  return context;
+}
+
+// src/security/AuthProvider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var AuthContext = createContext4(null);
+function errorStatus(error) {
+  return error?.status;
+}
+function encodeBasicCredentials(email, password) {
+  const bytes = new TextEncoder().encode(`${email}:${password}`);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return window.btoa(binary);
+}
+function normalizeList(value) {
+  if (Array.isArray(value)) return value.map(String).filter(Boolean);
+  if (typeof value === "string") return value.split(/[\s,;]+/).map((item) => item.trim()).filter(Boolean);
+  return [];
+}
+function unique(values) {
+  return values.filter((item, index, all) => Boolean(item) && all.indexOf(item) === index);
+}
+function extractCapabilities(user) {
+  if (!user) return [];
+  return unique([
+    ...normalizeList(user.capabilities),
+    ...normalizeList(user.permissoes?.capabilities),
+    ...normalizeList(user.aplicativo?.capabilities),
+    ...normalizeList(user.aplicativo?.permissoes?.capabilities)
+  ]);
+}
+function explicitPermissions(user) {
+  if (!user) return [];
+  const value = user.permissions;
+  return Array.isArray(value) ? unique(value.map(String)) : null;
+}
+function can(user, permission) {
+  if (!permission) return true;
+  const required = Array.isArray(permission) ? permission : [permission];
+  if (!required.length) return true;
+  const canonical = explicitPermissions(user);
+  if (canonical) {
+    return canonical.includes("*") || required.some((value) => canonical.includes(value));
+  }
+  const roles = unique(normalizeList(user?.roleCode).concat(normalizeList(user?.tipo)));
+  const capabilities = extractCapabilities(user);
+  if (roles.includes("admin") || roles.includes("master")) return true;
+  return required.some((value) => roles.includes(value) || capabilities.includes(value));
+}
+function AuthProvider({ http, storage, auth, loginUrl, runtimeMode = "platform", children }) {
+  const tokenParam = auth?.tokenParam ?? "code";
+  const devToken = auth?.devToken?.trim() || null;
+  const [user, setUser] = useState3(null);
+  const [status, setStatus] = useState3("loading");
+  const activation = useOptionalActivation();
+  const tenantContext = useOptionalOonTenant();
+  const redirectToExternalLogin = useCallback3(() => {
+    if (runtimeMode === "local") return;
+    if (loginUrl) window.location.href = loginUrl;
+  }, [loginUrl, runtimeMode]);
+  const applyUser = useCallback3((next) => {
+    setUser(next);
+    const tenant = next.tenant;
+    const resolvedTenantId = String(next.tenantId || tenant?.id || "").trim();
+    if (resolvedTenantId && tenantContext?.activeTenantId !== resolvedTenantId) {
+      tenantContext?.switchTenant(resolvedTenantId);
+    }
+    const firstAccess = Boolean(
+      next.mustChangePassword || next.firstAccessPending
+    );
+    setStatus(firstAccess ? "first-access" : "authenticated");
+  }, [tenantContext]);
+  const applyValidationError = useCallback3(
+    (error) => {
+      const currentStatus = errorStatus(error);
+      setUser(null);
+      if (currentStatus === 403) {
+        setStatus("forbidden");
+        return;
+      }
+      if (currentStatus === 401) {
+        storage.clear();
+        setStatus("unauthenticated");
+        redirectToExternalLogin();
+        return;
+      }
+      setStatus("error");
+    },
+    [storage, redirectToExternalLogin]
+  );
+  const validateSession = useCallback3(async () => {
+    const response = await http.get("/auth/validar-token");
+    applyUser(response.data.usuario);
+  }, [http, applyUser]);
+  const retry = useCallback3(async () => {
+    setStatus("loading");
+    try {
+      await validateSession();
+    } catch (error) {
+      applyValidationError(error);
+      throw error;
+    }
+  }, [validateSession, applyValidationError]);
+  const login = useCallback3(
+    async (email, password, tenantId) => {
+      if (runtimeMode === "local") {
+        const error = {
+          code: "LOCAL_LOGIN_NOT_SUPPORTED",
+          message: "O runtime local n\xE3o utiliza conta da plataforma.",
+          status: 403
+        };
+        throw error;
+      }
+      setStatus("loading");
+      setUser(null);
+      try {
+        const normalizedTenantId = String(tenantId || "").trim();
+        if (normalizedTenantId) tenantContext?.switchTenant(normalizedTenantId);
+        else tenantContext?.clearTenant();
+        const response = await http.post(
+          "/auth/autenticar",
+          {},
+          {
+            headers: {
+              Authorization: `Basic ${encodeBasicCredentials(email, password)}`,
+              ...normalizedTenantId ? { "x-oon-tenant-id": normalizedTenantId } : {}
+            }
+          }
+        );
+        if (!response.data.token) {
+          const error = { code: "AUTH_TOKEN_MISSING", message: "Token n\xE3o retornado pelo backend.", status: 502 };
+          throw error;
+        }
+        storage.set(response.data.token);
+        await validateSession();
+      } catch (error) {
+        if (error?.code === "TENANT_SELECTION_REQUIRED") {
+          setStatus("unauthenticated");
+        } else {
+          applyValidationError(error);
+        }
+        throw error;
+      }
+    },
+    [http, storage, validateSession, applyValidationError, tenantContext, runtimeMode]
+  );
+  const completeFirstAccess = useCallback3(async (password) => {
+    await http.post("/auth/first-access/password", { password });
+    await validateSession();
+  }, [http, validateSession]);
+  const logout = useCallback3(() => {
+    storage.clear();
+    tenantContext?.clearTenant();
+    setUser(null);
+    setStatus("unauthenticated");
+    if (runtimeMode === "local") {
+      void http.post("/auth/local/logout").catch(() => void 0);
+      return;
+    }
+    redirectToExternalLogin();
+  }, [storage, redirectToExternalLogin, tenantContext, runtimeMode, http]);
+  useEffect2(() => {
+    let active = true;
+    if (activation && !["active", "error"].includes(activation.status)) {
+      setUser(null);
+      setStatus("unauthenticated");
+      return;
+    }
+    if (runtimeMode === "local") {
+      storage.clear();
+      const bootstrapCode = captureTokenFromUrl("oon_local_bootstrap");
+      setStatus("loading");
+      const bootstrap = bootstrapCode ? http.post("/auth/local/bootstrap", { code: bootstrapCode }) : Promise.resolve();
+      bootstrap.then(() => http.get("/auth/validar-token")).then((response) => {
+        if (!active) return;
+        applyUser(response.data.usuario);
+      }).catch((error) => {
+        if (!active) return;
+        applyValidationError(error);
+      });
+      return () => {
+        active = false;
+      };
+    }
+    const launchCode = captureTokenFromUrl("oon_launch");
+    const incoming = captureTokenFromUrl(tokenParam);
+    const stored = storage.get();
+    if (launchCode) {
+      storage.clear();
+      setStatus("loading");
+      http.post("/auth/launch/exchange", { code: launchCode }).then((response) => {
+        if (!response.data.token) {
+          const error = {
+            code: "APP_LAUNCH_TOKEN_MISSING",
+            message: "A troca de abertura n\xE3o retornou uma sess\xE3o.",
+            status: 502
+          };
+          throw error;
+        }
+        storage.set(response.data.token);
+        return http.get("/auth/validar-token");
+      }).then((response) => {
+        if (!active) return;
+        applyUser(response.data.usuario);
+      }).catch((error) => {
+        if (!active) return;
+        storage.clear();
+        applyValidationError(error);
+      });
+      return () => {
+        active = false;
+      };
+    }
+    const token = incoming ?? devToken ?? stored;
+    if (token && token !== stored) storage.set(token);
+    if (!token) {
+      setUser(null);
+      setStatus("unauthenticated");
+      redirectToExternalLogin();
+      return;
+    }
+    setStatus("loading");
+    http.get("/auth/validar-token").then((response) => {
+      if (!active) return;
+      applyUser(response.data.usuario);
+    }).catch((error) => {
+      if (!active) return;
+      applyValidationError(error);
+    });
+    return () => {
+      active = false;
+    };
+  }, [http, storage, tokenParam, devToken, redirectToExternalLogin, applyValidationError, applyUser, activation?.status, runtimeMode]);
+  const roleCode = String(user?.roleCode || user?.tipo || "");
+  const roles = roleCode ? [roleCode] : [];
+  const capabilities = extractCapabilities(user);
+  const permissions = explicitPermissions(user) ?? capabilities;
+  const hasPermission = useCallback3(
+    (permission) => can(user, permission),
+    [user]
+  );
+  const value = {
+    user,
+    roles,
+    capabilities,
+    permissions,
+    status,
+    isAuthenticated: status === "authenticated" || status === "first-access",
+    hasPermission,
+    login,
+    completeFirstAccess,
+    retry,
+    logout
+  };
+  return /* @__PURE__ */ jsx4(AuthContext.Provider, { value, children });
+}
+function useOonAuth() {
+  const context = useContext4(AuthContext);
+  if (!context) throw new Error("useOonAuth deve ser usado dentro de <AuthProvider> (oonCoreFront.start).");
+  return context;
+}
+
+export {
+  createRestClient,
+  createTokenStorage,
+  ApiProvider,
+  useOonApi,
+  useOonResource,
+  useCoreMetadata,
+  useModelSchema,
+  ActivationProvider,
+  useActivation,
+  TenantProvider,
+  useOonTenant,
+  can,
+  AuthProvider,
+  useOonAuth
+};
+//# sourceMappingURL=chunk-VJ7YNFF7.js.map