@jtandrelevicius/utils-js-library 1.0.3 → 1.0.5

package/index.js

@@ -1,61 +1,102 @@
-/**
- * DataQueryService (Antigo JSK)
- * Responsável pela execução e processamento de consultas assíncronas.
- */
-class DataQueryService {
+'use strict';
+
+class ServicoDados {
+    
     /**
-     * Define o executor de query padrão para a classe.
-     * Isso remove a dependência de uma função global.
-     * @param {Function} executorFunction Função que aceita (query, params, onSuccess, onError).
+     * Define o executor de query padrão para a classe (Legado).
+     * @param {Function} funcaoExecutor Função que aceita (query, params, onSuccess, onError).
      */
-    static setExecutor(executorFunction) {
-        this.executor = executorFunction;
+    static definirExecutor(funcaoExecutor) {
+        this.executor = funcaoExecutor;
+    }
+
+    /**
+     * Realiza requisições do tipo POST (Base para salvar/excluir).
+     * @param {string} url URL da requisição.
+     * @param {Object} corpo Corpo da requisição.
+     * @param {Object} opcoes Opções adicionais (headers, raw).
+     * @returns {Promise<Object>} Resposta da requisição.
+     */
+    static async post(url, corpo, { headers, raw } = { headers: {}, raw: false }) {
+        let isJSON = true;
+
+        if (headers) {
+            const cabecalhoTipoOriginal = headers['Content-Type'] ? String(headers['Content-Type']) : 'application/json; charset=UTF-8';
+            isJSON = headers['Content-Type'] ? RegExp(/json/i).exec(headers['Content-Type']) : isJSON;
+
+            if (headers['Content-Type']) delete headers['Content-Type'];
+            headers['Content-Type'] = cabecalhoTipoOriginal;
+        }
+
+        try {
+            let corpoRequisicaoFormatado = corpo;
+
+            if (corpo && typeof corpo === 'object') {
+                corpoRequisicaoFormatado = JSON.stringify(corpo);
+            }
+
+            if (typeof window === 'undefined' || !window.fetch) {
+                throw new Error("O método 'post' requer um ambiente de navegador com 'fetch' disponível.");
+            }
+
+            const resposta = await window.fetch.bind(window)(url, {
+                headers,
+                method: 'POST',
+                redirect: 'follow',
+                credentials: 'include',
+                body: corpoRequisicaoFormatado
+            });
+
+            if (raw) {
+                return resposta;
+            }
+
+            return isJSON ? resposta.json() : resposta.text();
+
+        } catch (erro) {
+            console.error("[ServicoDados] Erro no POST:", erro);
+            throw erro;
+        }
     }
 
     /**
+     * Normaliza a resposta da API (Método auxiliar).
      * @private
-     * Normaliza a resposta da API, lidando com estruturas aninhadas legadas/específicas.
-     * @param {unknown} rawValue O valor bruto retornado pela query.
-     * @returns {Array<Object>} O array de dados normalizado.
      */
-    static normalizeResponse(rawValue) {
+    static normalizarResposta(valorBruto) {
         try {
-            // Tenta parsear se for string, senão usa o valor original
-            const parsedValue = typeof rawValue === 'string' ? JSON.parse(rawValue) : rawValue;
-
-            if (!parsedValue) return [];
-            if (Array.isArray(parsedValue)) return parsedValue;
-
-            // Lógica de fallback para estruturas aninhadas complexas (ex: respostas SAP/Legacy)
-            let finalData = null;
-
-            if (typeof parsedValue === 'object') {
-                if (typeof parsedValue.b === 'string') {
-                    finalData = JSON.parse(parsedValue.b);
-                } else if (parsedValue.c?.b && typeof parsedValue.c.b === 'string') {
-                    finalData = JSON.parse(parsedValue.c.b);
-                } else if (parsedValue.data?.responseBody || parsedValue.responseBody) {
-                    const body = parsedValue.data?.responseBody || parsedValue.responseBody;
-                    finalData = typeof body === 'string' ? JSON.parse(body) : body;
+            const valorParseado = typeof valorBruto === 'string' ? JSON.parse(valorBruto) : valorBruto;
+
+            if (!valorParseado) return [];
+            if (Array.isArray(valorParseado)) return valorParseado;
+
+            let dadosFinais = null;
+
+            if (typeof valorParseado === 'object') {
+                if (typeof valorParseado.b === 'string') {
+                    dadosFinais = JSON.parse(valorParseado.b);
+                } else if (valorParseado.c?.b && typeof valorParseado.c.b === 'string') {
+                    dadosFinais = JSON.parse(valorParseado.c.b);
+                } else if (valorParseado.data?.responseBody || valorParseado.responseBody) {
+                    const corpo = valorParseado.data?.responseBody || valorParseado.responseBody;
+                    dadosFinais = typeof corpo === 'string' ? JSON.parse(corpo) : corpo;
                 }
             }
 
-            if (Array.isArray(finalData)) return finalData;
-
+            if (Array.isArray(dadosFinais)) return dadosFinais;
             throw new Error("Formato de resposta desconhecido ou inválido.");
-        } catch (error) {
-            throw new Error(`Falha ao normalizar resposta da query: ${error.message}`);
+        } catch (erro) {
+            throw new Error(`Falha ao normalizar resposta da query: ${erro.message}`);
         }
     }
 
     /**
-     * Executa uma consulta de dados.
-     * @param {string} query A string da consulta (SQL/HQL/etc).
-     * @param {Object} [params=null] Parâmetros opcionais para a query.
+     * Executa uma consulta de dados (Via executor configurado ou executeQuery global).
+     * @param {string} query A string da consulta.
+     * @param {Object} [params=null] Parâmetros opcionais.
      * @returns {Promise<Array<Object>>} Promise resolvendo com os dados.
      */
-    static async fetch(query, params = null) {
-        // Tenta usar o executor configurado ou busca o global executeQuery como fallback
+    static async consultar(query, params = null) {
         const executor = this.executor || (typeof window !== 'undefined' ? window.executeQuery : null);
 
         if (typeof executor !== 'function') {
@@ -64,10 +105,10 @@ class DataQueryService {
 
         return new Promise((resolve, reject) => {
             executor(query, params, 
-                (rawValue) => {
+                (valorBruto) => {
                     try {
-                        const data = DataQueryService.normalizeResponse(rawValue);
-                        resolve(data || []);
+                        const dados = ServicoDados.normalizarResposta(valorBruto);
+                        resolve(dados || []);
                     } catch (err) {
                         reject(err);
                     }
@@ -79,154 +120,189 @@ class DataQueryService {
 
     /**
      * Executa uma consulta paginada.
-     * @param {string} query A query base.
-     * @param {Object} params Parâmetros da query.
-     * @param {number} limit Registros por página.
-     * @param {number} offset Ponto de início (pular x registros).
-     * @returns {Promise<Object>} Objeto contendo dados e metadados de paginação.
      */
-    static async fetchPaginated(query, params = null, limit, offset) {
-        const safeLimit = Number(limit);
-        const safeOffset = Number(offset);
+    static async consultarPaginado(query, params = null, limite, offset) {
+        const limiteSeguro = Number(limite);
+        const offsetSeguro = Number(offset);
 
-        if (isNaN(safeLimit) || isNaN(safeOffset) || safeLimit < 0 || safeOffset < 0) {
-            throw new Error("Parâmetros 'limit' e 'offset' devem ser números positivos válidos.");
+        if (isNaN(limiteSeguro) || isNaN(offsetSeguro) || limiteSeguro < 0 || offsetSeguro < 0) {
+            throw new Error("Parâmetros 'limite' e 'offset' devem ser números positivos válidos.");
         }
 
-        const paginatedQuery = `${query} LIMIT ${safeLimit} OFFSET ${safeOffset}`;
-
-        const data = await DataQueryService.fetch(paginatedQuery, params);
-        
-        const currentPage = Math.floor(safeOffset / safeLimit) + 1;
+        const queryPaginada = `${query} LIMIT ${limiteSeguro} OFFSET ${offsetSeguro}`;
+        const dados = await ServicoDados.consultar(queryPaginada, params);
+        const paginaAtual = Math.floor(offsetSeguro / limiteSeguro) + 1;
 
         return {
-            data,
-            meta: {
-                currentPage,
-                itemsPerPage: safeLimit,
-                totalItems: null, 
-                totalPages: null 
-            }
+            dados,
+            meta: { paginaAtual, itensPorPagina: limiteSeguro, totalItens: null, totalPaginas: null }
         };
     }
-}
 
-/**
- * FormatUtils (Antigo JFSK)
- * Utilitários para formatação de moeda, números e datas (Locale pt-BR).
- */
-class FormatUtils {
     /**
-     * Formata valor para moeda BRL (R$).
+     * Salva (Insert) ou Atualiza (Update) um registro usando DatasetSP.
+     * * Lógica Automática:
+     * 1. Se 'chavesPrimarias' for informado -> Realiza UPDATE no registro específico.
+     * 2. Se 'chavesPrimarias' for NULO/UNDEFINED -> Realiza INSERT de um novo registro.
+     * * @param {Object} dados Objeto com os dados a serem gravados { CAMPO: valor }.
+     * @param {string} entidade Nome da entidade/tabela (ex: 'Parceiro', 'TGFCAB').
+     * @param {Object} [chavesPrimarias=null] Chaves primárias { PK: valor } para edição.
+     * @returns {Promise<Object>} Resposta da requisição.
      */
-    static currency(value) {
-        const numberVal = parseFloat(value);
-        if (isNaN(numberVal)) return "R$ 0,00";
-
-        return new Intl.NumberFormat('pt-BR', {
-            style: 'currency',
-            currency: 'BRL'
-        }).format(numberVal);
+    static async salvar(dados, entidade, chavesPrimarias = null) {
+        const url = `${window.location.origin}/mge/service.sbr?serviceName=DatasetSP.save&outputType=json`;
+
+        const chavesDados = Object.keys(dados);
+        const fields = chavesDados.map(campo => campo.toUpperCase());
+        
+        const values = {};
+        chavesDados.forEach((chave, indice) => {
+            values[indice.toString()] = String(dados[chave]);
+        });
+
+        const record = { values: values };
+
+        if (chavesPrimarias) {
+            const pk = {};
+            Object.keys(chavesPrimarias).forEach(chave => {
+                pk[chave.toUpperCase()] = String(chavesPrimarias[chave]);
+            });
+            record.pk = pk;
+        }
+
+        const dadosEnvio = {
+            serviceName: 'DatasetSP.save',
+            requestBody: {
+                entityName: entidade,
+                fields: fields,
+                records: [record]
+            }
+        };
+
+        return await ServicoDados.post(url, dadosEnvio);
     }
 
     /**
-     * Formata número inteiro com separadores de milhar.
+     * Exclui registros da base de dados.
+     * @param {string} entidade Nome da Entidade.
+     * @param {Object|Array} chavesPrimarias Objeto PK { COD: 1 } ou Array de PKs.
+     * @returns {Promise<Object>} Resposta da exclusão.
      */
-    static number(value) {
-        const numberVal = parseFloat(value);
-        if (isNaN(numberVal)) return "0";
+    static async excluir(entidade, chavesPrimarias) {
+        const url = `${window.location.origin}/mge/service.sbr?serviceName=DatasetSP.removeRecord&outputType=json`;
+        
+        const dadosEnvio = {
+            serviceName: 'DatasetSP.removeRecord',
+            requestBody: {
+                entityName: entidade,
+                pks: Array.isArray(chavesPrimarias) ? chavesPrimarias : [chavesPrimarias]
+            }
+        };
 
-        return new Intl.NumberFormat('pt-BR', {
-            maximumFractionDigits: 0
-        }).format(numberVal);
+        return ServicoDados.post(url, dadosEnvio);
+    }
+}
+
+/**
+ * UtilitariosFormatacao
+ */
+class UtilitariosFormatacao {
+    static moeda(valor) {
+        const valorNumerico = parseFloat(valor);
+        if (isNaN(valorNumerico)) return "R$ 0,00";
+        return new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' }).format(valorNumerico);
+    }
+
+    static numerico(valor) {
+        const valorNumerico = parseFloat(valor);
+        if (isNaN(valorNumerico)) return "0";
+        return new Intl.NumberFormat('pt-BR', { maximumFractionDigits: 0 }).format(valorNumerico);
     }
     
-    /**
-     * Formata número decimal com 2 casas fixas.
-     */
-    static decimal(value) {
-        const numberVal = parseFloat(value);
-        if (isNaN(numberVal)) return "0,00";
-
-        return new Intl.NumberFormat('pt-BR', {
-            minimumFractionDigits: 2,
-            maximumFractionDigits: 2
-        }).format(numberVal);
+    static decimal(valor) {
+        const valorNumerico = parseFloat(valor);
+        if (isNaN(valorNumerico)) return "0,00";
+        return new Intl.NumberFormat('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 }).format(valorNumerico);
     }
 
-    /**
-     * Retorna data atual no formato DD/MM/YYYY.
-     */
-    static currentDate() {
+    static data() {
         return new Intl.DateTimeFormat('pt-BR').format(new Date());
     }
 
-    /**
-     * Converte string ISO (YYYY-MM-DD) para PT-BR (DD/MM/YYYY).
-     */
-    static formatDateToBR(isoDateString) {
-        if (!isoDateString) return '';
-        const parts = isoDateString.split('-');
-        if (parts.length !== 3) return isoDateString;
-        return `${parts[2]}/${parts[1]}/${parts[0]}`;
+    static formatarDataParaDMY(stringDataIso) {
+        if (!stringDataIso) return '';
+        const partes = stringDataIso.split('-');
+        if (partes.length !== 3) return stringDataIso;
+        return `${partes[2]}/${partes[1]}/${partes[0]}`;
     }
 
-    /**
-     * Retorna data atual em ISO (YYYY-MM-DD).
-     */
-    static currentIsoDate() {
+    static normalizarStringData(entradaData) {
+        if (!entradaData) return '01/01/2025';
+        let str = String(entradaData).trim();
+    
+        if (str.includes('/')) {
+            const partes = str.split('/');
+            if (partes.length >= 3) {
+                const dia = String(parseInt(partes[0], 10)).padStart(2, '0');
+                const mes = String(parseInt(partes[1], 10)).padStart(2, '0');
+                const ano = partes[2].substring(0, 4); 
+                return `${dia}/${mes}/${ano}`;
+            }
+        }
+    
+        if (str.includes('-')) {
+            const partes = str.split('-');
+            if (partes.length === 3) {
+                return `${partes[2].substring(0, 2)}/${partes[1]}/${partes[0]}`;
+            }
+        }
+    
+        return str; 
+    }
+
+    static obterDataAtualISO() {
         return new Date().toISOString().split('T')[0];
     }
 
-    /**
-     * Data e Hora atuais (DD/MM/YYYY HH:mm).
-     */
-    static currentDateTime() {
-        const now = new Date();
-        const datePart = new Intl.DateTimeFormat('pt-BR').format(now);
-        const timePart = now.toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' });
-        return `${datePart} ${timePart}`;
+    static dataHora() {
+        const agora = new Date();
+        const parteData = new Intl.DateTimeFormat('pt-BR').format(agora);
+        const parteHora = agora.toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' });
+        return `${parteData} ${parteHora}`;
     }
 }
 
 /**
- * SortUtils (Antigo JOSK)
- * Utilitários para ordenação de listas.
+ * UtilitariosOrdenacao
  */
-class SortUtils {
-    static sortBy(data, key, direction = 'asc') {
-        if (!Array.isArray(data) || !key) return data;
-
-        const multiplier = direction === 'asc' ? 1 : -1;
-
-        return [...data].sort((a, b) => {
-            const valA = a[key];
-            const valB = b[key];
-
+class UtilitariosOrdenacao {
+    static ordenar(dados, chave, direcao = 'asc') {
+        if (!Array.isArray(dados) || !chave) return dados;
+        const multiplicador = direcao === 'asc' ? 1 : -1;
+
+        return [...dados].sort((a, b) => {
+            const valA = a[chave];
+            const valB = b[chave];
             if (valA == null) return 1; 
             if (valB == null) return -1;
-
             if (typeof valA === 'string' && typeof valB === 'string') {
-                return valA.localeCompare(valB) * multiplier;
+                return valA.localeCompare(valB) * multiplicador;
             }
-
-            if (valA < valB) return -1 * multiplier;
-            if (valA > valB) return 1 * multiplier;
+            if (valA < valB) return -1 * multiplicador;
+            if (valA > valB) return 1 * multiplicador;
             return 0;
         });
     }
 }
 
 /**
- * ExportService (Antigo JEXSK)
- * Exportação para Excel (.xlsx) e CSV.
+ * ServicoExportacao
  */
-class ExportService {
+class ServicoExportacao {
     static CDN_URL = "https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js";
 
-    static async loadDependency() {
+    static async carregarDependencia() {
         if (typeof window !== 'undefined' && window.XLSX) return;
-
         return new Promise((resolve, reject) => {
             const script = document.createElement('script');
             script.src = this.CDN_URL;
@@ -237,38 +313,36 @@ class ExportService {
         });
     }
 
-    static async toExcel(data, columns, filename, sheetName = 'Dados') {
-        await this.loadDependency();
-        const formattedData = data.map(item => {
-            const row = {};
-            columns.forEach(col => {
-                row[col.display] = item[col.key];
-            });
-            return row;
+    static async paraExcel(dados, colunas, nomeArquivo, nomePlanilha = 'Dados') {
+        await this.carregarDependencia();
+        const dadosFormatados = dados.map(item => {
+            const linha = {};
+            colunas.forEach(col => { linha[col.display] = item[col.key]; });
+            return linha;
         });
-        // @ts-ignore
-        const worksheet = XLSX.utils.json_to_sheet(formattedData);
-        const workbook = XLSX.utils.book_new();
-        XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
-        XLSX.writeFile(workbook, `${filename}.xlsx`);
+
+        const planilha = XLSX.utils.json_to_sheet(dadosFormatados);
+        const pastaTrabalho = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(pastaTrabalho, planilha, nomePlanilha);
+        XLSX.writeFile(pastaTrabalho, `${nomeArquivo}.xlsx`);
     }
 
-    static toCSV(data, columns, filename) {
-        const headerRow = columns.map(c => `"${c.display}"`).join(';');
-        const bodyRows = data.map(item => {
-            return columns.map(col => {
+    static paraCSV(dados, colunas, nomeArquivo) {
+        const linhaCabecalho = colunas.map(c => `"${c.display}"`).join(';');
+        const linhasCorpo = dados.map(item => {
+            return colunas.map(col => {
                 const val = item[col.key] ?? '';
-                const stringVal = String(val).replace(/"/g, '""').replace(/\r?\n|\r/g, ' ');
-                return `"${stringVal}"`;
+                const valString = String(val).replace(/"/g, '""').replace(/\r?\n|\r/g, ' ');
+                return `"${valString}"`;
             }).join(';');
         });
-        const csvContent = [headerRow, ...bodyRows].join('\r\n');
-        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+        const conteudoCsv = [linhaCabecalho, ...linhasCorpo].join('\r\n');
+        const blob = new Blob([conteudoCsv], { type: 'text/csv;charset=utf-8;' });
         const link = document.createElement('a');
         if (link.download !== undefined) { 
             const url = URL.createObjectURL(blob);
             link.setAttribute('href', url);
-            link.setAttribute('download', `${filename}.csv`);
+            link.setAttribute('download', `${nomeArquivo}.csv`);
             link.style.visibility = 'hidden';
             document.body.appendChild(link);
             link.click();
@@ -276,44 +350,36 @@ class ExportService {
         }
     }
 
-    static async export(data, columns, filename = 'export', format = 'xlsx') {
-        if (!data?.length) throw new Error("Sem dados para exportar.");
-        if (!columns?.length) throw new Error("Colunas não definidas.");
+    static async exportar(dados, colunas, nomeArquivo = 'exportacao', formato = 'xlsx') {
+        if (!dados?.length) throw new Error("Sem dados para exportar.");
+        if (!colunas?.length) throw new Error("Colunas não definidas.");
 
-        const fmt = format.toLowerCase();
-        if (fmt === 'xlsx') await this.toExcel(data, columns, filename);
-        else if (fmt === 'csv') this.toCSV(data, columns, filename);
-        else throw new Error(`Formato '${format}' não suportado.`);
+        const fmt = formato.toLowerCase();
+        if (fmt === 'xlsx') await this.paraExcel(dados, colunas, nomeArquivo);
+        else if (fmt === 'csv') this.paraCSV(dados, colunas, nomeArquivo);
+        else throw new Error(`Formato '${formato}' não suportado.`);
     }
 }
 
-// ==========================================
-// DETECÇÃO DE AMBIENTE (Browser vs Node.js)
-// ==========================================
-
 const lib = {
-    DataQueryService,
-    FormatUtils,
-    SortUtils,
-    ExportService,
-    // Aliases para retrocompatibilidade
-    JSK: DataQueryService,
-    JFSK: FormatUtils,
-    JOSK: SortUtils,
-    JEXSK: ExportService
+    ServicoDados,
+    UtilitariosFormatacao,
+    UtilitariosOrdenacao,
+    ServicoExportacao,
+
+    // Aliases
+    JSK: ServicoDados,
+    JFSK: UtilitariosFormatacao,
+    JOSK: UtilitariosOrdenacao,
+    JEXSK: ServicoExportacao
 };
 
-// Se estiver em ambiente Node.js/CommonJS
 if (typeof module !== 'undefined' && module.exports) {
     module.exports = lib;
-} 
-// Se estiver no Browser (janela global)
-else if (typeof window !== 'undefined') {
+} else if (typeof window !== 'undefined') {
     Object.assign(window, lib);
-    
-    // Configuração automática se existir a função legado
     if (typeof window.executeQuery === 'function') {
-        DataQueryService.setExecutor(window.executeQuery);
-        console.log("[DataQueryService] Executor 'executeQuery' detectado e configurado automaticamente.");
+        ServicoDados.definirExecutor(window.executeQuery);
+        console.log("[JSK] Executor 'executeQuery' detectado e configurado automaticamente.");
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtandrelevicius/utils-js-library",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "main": "index.js",
   "scripts": {