forlogic-core 1.15.2 → 1.15.4

package/dist/qualiex/hooks/useQualiexUsers.d.ts

@@ -0,0 +1,51 @@
+import { QualiexUser } from '../../types';
+interface UseQualiexUsersOptions {
+    /**
+     * Controla se a query executa.
+     *
+     * **Padrão: `true`** - A query executa automaticamente!
+     *
+     * - `true`: Busca imediata e automática (padrão)
+     * - `false`: Não busca (use com `refetch()` para lazy loading)
+     * - Condicional: `enabled: isModalOpen` (busca só quando aberto)
+     *
+     * @example
+     * // ✅ Uso padrão (busca automática)
+     * useQualiexUsers()
+     *
+     * @example
+     * // ✅ Modal condicional
+     * useQualiexUsers({ enabled: isModalOpen })
+     *
+     * @example
+     * // ✅ Lazy loading
+     * const { refetch } = useQualiexUsers({ enabled: false });
+     * await refetch(); // Chama quando necessário
+     */
+    enabled?: boolean;
+}
+/**
+ * Hook para buscar usuários da API Qualiex.
+ *
+ * Por padrão, a query executa automaticamente quando o hook é montado.
+ *
+ * @param options - Opções de configuração
+ * @param options.enabled - Controla se a query executa (padrão: `true`)
+ *
+ * @returns Objeto com dados, loading, error e refetch
+ *
+ * @example
+ * // ✅ Uso padrão - Busca automática
+ * const { data: users, isLoading } = useQualiexUsers();
+ *
+ * @example
+ * // ✅ Busca condicional (modal)
+ * const { data: users } = useQualiexUsers({ enabled: isModalOpen });
+ *
+ * @example
+ * // ✅ Lazy loading com controle manual
+ * const { data: users, refetch } = useQualiexUsers({ enabled: false });
+ * await refetch(); // Chamar quando necessário
+ */
+export declare const useQualiexUsers: (options?: UseQualiexUsersOptions) => import("@tanstack/react-query").UseQueryResult<QualiexUser[], Error>;
+export {};

package/dist/qualiex/services/qualiexApi.d.ts

@@ -0,0 +1,21 @@
+import { QualiexUser } from '../../types';
+declare class QualiexApiService {
+    private baseUrl;
+    /**
+     * Faz uma chamada para a API do Qualiex
+     * IMPORTANTE: O header 'un-alias' é OBRIGATÓRIO para todas as requisições da API common-v4
+     * Sem este header, a API retorna erro 401 "ID not found"
+     */
+    private makeApiCall;
+    private mapToQualiexUser;
+    fetchUsers(alias: string, companyId: string): Promise<QualiexUser[]>;
+    fetchUserById(userId: string, alias: string, companyId: string): Promise<QualiexUser | null>;
+    fetchActiveUsersMap(alias: string, companyId: string): Promise<Map<string, QualiexUser>>;
+    getUsers(alias: string): Promise<QualiexUser[]>;
+    /**
+     * @deprecated Use getUsers() instead. Este método agora retorna apenas usuários ativos.
+     */
+    getAllUsers(alias: string): Promise<QualiexUser[]>;
+}
+export declare const qualiexApi: QualiexApiService;
+export {};

package/dist/qualiex/utils/QualiexErrorInterceptor.d.ts

@@ -0,0 +1,15 @@
+export declare class QualiexErrorInterceptor {
+    private static isRetrying;
+    /**
+     * Intercepta erros da API Qualiex e tenta resolver automaticamente
+     * @returns true se o erro foi resolvido e a operação pode ser retentada
+     */
+    static handleApiError(error: any): Promise<boolean>;
+    /**
+     * Valida se o token OAuth está válido antes de fazer chamadas
+     */
+    static validateToken(): {
+        valid: boolean;
+        message?: string;
+    };
+}

package/dist/qualiex/utils/userPlaceUtils.d.ts

@@ -0,0 +1,16 @@
+import { QualiexUser } from '../../types';
+/**
+ * Extrai placeId de um QualiexUser
+ */
+export declare const getUserPlaceId: (user: QualiexUser | null | undefined) => string | null;
+/**
+ * Extrai placeName de um QualiexUser
+ */
+export declare const getUserPlaceName: (user: QualiexUser | null | undefined) => string | null;
+/**
+ * Extrai placeId e placeName de um QualiexUser
+ */
+export declare const getUserPlaceData: (user: QualiexUser | null | undefined) => {
+    placeId: string | null;
+    placeName: string | null;
+};

package/dist/services/BaseService.d.ts

@@ -0,0 +1,51 @@
+import type { PaginatedResponse, QueryParams } from '../types';
+import { QualiexUserFieldMapping } from '../types';
+export interface ServiceOptions {
+    tableName: string;
+    searchFields?: string[];
+    selectFields?: string;
+    schemaName?: string;
+    entityName?: string;
+    enableQualiexEnrichment?: boolean;
+    userIdFields?: string[];
+    userFieldsMapping?: QualiexUserFieldMapping[];
+}
+/**
+ * Factory para criar serviço CRUD com Supabase
+ *
+ * Implementa soft delete automático e integração com RLS.
+ *
+ * @example
+ * ```typescript
+ * const service = createService<Employee>({
+ *   tableName: 'employees',
+ *   searchFields: ['name', 'email'],
+ *   enableQualiexEnrichment: true
+ * });
+ * ```
+ *
+ * Ver README para documentação completa
+ *
+ * @see createSimpleService - Método recomendado (mais simples)
+ */
+export declare function createService<T extends {
+    id_user?: string | null;
+} = any, TInsert = any, TUpdate = any>(options: ServiceOptions | string, // Mantém compatibilidade com API antiga
+searchFields?: string[], schemaName?: string): {
+    getAll(params?: QueryParams): Promise<PaginatedResponse<T & {
+        responsible_name?: string;
+    }>>;
+    getById(id: string): Promise<T | null>;
+    create(payload: TInsert): Promise<T>;
+    update(id: string, payload: TUpdate): Promise<T>;
+    /**
+     * Delete a record by ID using SOFT DELETE
+     *
+     * IMPORTANT: This performs a SOFT DELETE by setting is_removed = true
+     * - No physical DELETE is performed
+     * - Record remains in database but filtered from queries
+     * - RLS policies should NOT include DELETE policies
+     * - Compatible with audit trails and data recovery
+     */
+    delete(id: string): Promise<void>;
+};

package/dist/services/EmailService.d.ts

@@ -0,0 +1,110 @@
+export interface SendEmailParams {
+    /**
+     * Código do template cadastrado no banco de dados (common.email_templates)
+     * Exemplo: 'WELCOME', 'PASSWORD_RESET', 'NOTIFICATION'
+     */
+    templateCode: string;
+    /**
+     * Email(s) do(s) destinatário(s)
+     */
+    to: string | string[];
+    /**
+     * Variáveis para substituição no template
+     * As chaves devem corresponder aos placeholders no template: {{variableName}}
+     * Exemplo: { userName: 'João', activationLink: 'https://...' }
+     */
+    variables: Record<string, any>;
+    /**
+     * Emails em cópia (opcional)
+     */
+    cc?: string[];
+    /**
+     * Emails em cópia oculta (opcional)
+     */
+    bcc?: string[];
+    /**
+     * Email para resposta (opcional)
+     */
+    replyTo?: string;
+}
+/**
+ * Serviço para envio de emails usando templates do banco de dados
+ *
+ * O serviço busca automaticamente o template cadastrado na tabela common.email_templates
+ * pelo alias da empresa e pelo template_code fornecido, e substitui as variáveis
+ * pelos valores fornecidos.
+ *
+ * @example
+ * ```typescript
+ * import { emailService } from 'forlogic-core';
+ *
+ * // Enviar email de boas-vindas
+ * await emailService.sendEmail({
+ *   templateCode: 'WELCOME',
+ *   to: 'usuario@exemplo.com',
+ *   variables: {
+ *     userName: 'João Silva',
+ *     activationLink: 'https://app.com/activate',
+ *     companyName: 'Minha Empresa'
+ *   }
+ * });
+ *
+ * // Enviar notificação genérica
+ * await emailService.sendEmail({
+ *   templateCode: 'NOTIFICATION',
+ *   to: ['usuario1@exemplo.com', 'usuario2@exemplo.com'],
+ *   variables: {
+ *     title: 'Novo documento disponível',
+ *     message: 'Um novo documento foi compartilhado com você',
+ *     actionUrl: 'https://app.com/documents/123',
+ *     actionLabel: 'Ver Documento'
+ *   },
+ *   cc: ['gestor@exemplo.com']
+ * });
+ *
+ * // Template personalizado
+ * await emailService.sendEmail({
+ *   templateCode: 'CUSTOM_REPORT',
+ *   to: 'gerente@exemplo.com',
+ *   variables: {
+ *     reportTitle: 'Relatório Mensal',
+ *     period: 'Janeiro/2024',
+ *     totalSales: 'R$ 50.000,00',
+ *     downloadLink: 'https://app.com/reports/jan-2024.pdf'
+ *   }
+ * });
+ * ```
+ */
+export declare class EmailService {
+    /**
+     * Envia email usando template do banco de dados
+     *
+     * A edge function irá:
+     * 1. Buscar o template na tabela common.email_templates usando o alias da empresa
+     * 2. Substituir as variáveis {{variableName}} pelos valores fornecidos
+     * 3. Enviar o email via SMTP
+     * 4. Registrar o log em common.email_logs
+     *
+     * @param params - Parâmetros do email
+     * @throws Error se o template não for encontrado ou se houver erro no envio
+     * @returns Dados da resposta da edge function (message_id, etc)
+     */
+    static sendEmail(params: SendEmailParams): Promise<any>;
+}
+/**
+ * Instância singleton do serviço de email
+ *
+ * Use este export para enviar emails através de templates cadastrados no banco.
+ *
+ * @example
+ * ```typescript
+ * import { emailService } from 'forlogic-core';
+ *
+ * await emailService.sendEmail({
+ *   templateCode: 'WELCOME',
+ *   to: 'usuario@exemplo.com',
+ *   variables: { userName: 'João' }
+ * });
+ * ```
+ */
+export declare const emailService: typeof EmailService;

package/dist/services/ErrorService.d.ts

@@ -0,0 +1,19 @@
+interface ErrorEntry {
+    id: string;
+    message: string;
+    timestamp: number;
+    count: number;
+}
+declare class ErrorService {
+    private errors;
+    private toastCount;
+    private lastToastTime;
+    handleError(error: Error | string, showToast?: boolean): void;
+    private getErrorTitle;
+    success(title: string, description?: string): void;
+    private shouldShowToast;
+    getErrors(): ErrorEntry[];
+    clearErrors(): void;
+}
+export declare const errorService: ErrorService;
+export {};

package/dist/services/QualiexEnrichmentService.d.ts

@@ -0,0 +1,65 @@
+import { QualiexUserFieldMapping } from '../types';
+export interface QualiexEnrichmentOptions {
+    entityName: string;
+    userIdFields?: string[];
+    userFieldsMapping?: QualiexUserFieldMapping[];
+}
+export declare class QualiexEnrichmentService {
+    /**
+     * Busca usuários Qualiex com cache inteligente
+     */
+    private static fetchQualiexUsers;
+    /**
+     * Extrai todos os IDs únicos das entidades baseado nos mapeamentos
+     */
+    private static extractUserIds;
+    /**
+     * Cria índice duplo de usuários (por id e userId)
+     */
+    private static indexUsers;
+    /**
+     * Aplica enrichment em uma única entidade
+     */
+    private static enrichEntity;
+    /**
+     * Enriquece entidades com múltiplos campos de usuário do Qualiex
+     *
+     * Suporta:
+     * - Múltiplos campos de ID arbitrários (userIdFields ou userFieldsMapping)
+     * - Campos de saída customizados (name, email, username)
+     * - Cache inteligente (5min TTL)
+     * - Resiliência: não quebra em caso de falha
+     *
+     * @example
+     * ```typescript
+     * // Uso simples (lista de campos)
+     * enrichWithUserData(evaluations, {
+     *   entityName: 'Avaliações',
+     *   userIdFields: ['target_user_id', 'evaluator_user_id']
+     * });
+     * // Resultado: target_user_name, evaluator_user_name preenchidos
+     *
+     * // Uso avançado (mapeamento customizado)
+     * enrichWithUserData(evaluations, {
+     *   entityName: 'Avaliações',
+     *   userFieldsMapping: [
+     *     { idField: 'target_user_id', nameField: 'avaliado_nome' },
+     *     { idField: 'evaluator_user_id', nameField: 'avaliador_nome', emailField: 'avaliador_email' }
+     *   ]
+     * });
+     * ```
+     */
+    static enrichWithUserData<T>(entities: T[], options: QualiexEnrichmentOptions): Promise<T[]>;
+    /**
+     * Método legado (retrocompatibilidade)
+     *
+     * @deprecated Use enrichWithUserData() para maior flexibilidade
+     */
+    static enrichWithResponsibleNames<T extends {
+        id_user?: string | null;
+    }>(entities: T[], options: {
+        entityName: string;
+    }): Promise<(T & {
+        responsible_name?: string;
+    })[]>;
+}

package/dist/services/QualiexFieldHelpers.d.ts

@@ -0,0 +1,17 @@
+import { QualiexUserFieldMapping } from '../types';
+/**
+ * Deriva o nome do campo de saída baseado no campo de ID e sufixo
+ *
+ * @example
+ * deriveNameField("target_user_id", "_name") => "target_user_name"
+ * deriveNameField("id_user", "_name") => "id_user_name"
+ */
+export declare function deriveNameField(idField: string, suffix?: string): string;
+export declare function deriveEmailField(idField: string, suffix?: string): string;
+export declare function deriveUsernameField(idField: string, suffix?: string): string;
+/**
+ * Converte lista de campos de ID + mapeamentos explícitos em lista unificada
+ *
+ * Prioridade: userFieldsMapping > userIdFields
+ */
+export declare function resolveFieldMappings(userIdFields?: string[], userFieldsMapping?: QualiexUserFieldMapping[]): QualiexUserFieldMapping[];

package/dist/services/TranslationService.d.ts

@@ -0,0 +1,20 @@
+declare class TranslationService {
+    private cache;
+    private cacheTimestamps;
+    private readonly CACHE_TTL;
+    private loadingPromises;
+    private isCacheValid;
+    loadTranslations(locale: string): Promise<Record<string, string>>;
+    private fetchTranslations;
+    upsertTranslation(key: string, pt: string, en?: string, es?: string): Promise<void>;
+    bulkUpsertTranslations(translations: Array<{
+        key: string;
+        pt: string;
+        en?: string;
+        es?: string;
+    }>): Promise<void>;
+    clearCache(): void;
+    clearCacheForLocale(locale: string): void;
+}
+export declare const translationService: TranslationService;
+export {};

package/dist/setup.d.ts

@@ -0,0 +1,14 @@
+import { QueryClient } from '@tanstack/react-query';
+interface QualiexCoreConfig {
+    supabase: {
+        url: string;
+        anonKey: string;
+    };
+    theme?: 'light' | 'dark' | 'system';
+    queryClient?: QueryClient;
+}
+export declare function setupQualiexCore(config: QualiexCoreConfig): {
+    queryClient: QueryClient;
+    config: QualiexCoreConfig;
+};
+export {};

package/dist/sign/components/D4SignWidget.d.ts

@@ -0,0 +1,2 @@
+import type { D4SignWidgetProps } from '../types';
+export declare function D4SignWidget({ documentKey, signerEmail, signerName, keySigner, environment, onSign, onError, }: D4SignWidgetProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/components/DocumentSigner.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentSignerProps } from '../types';
+export declare function DocumentSigner({ file: fileProp, onDocumentSigned, onError, showEventLog }: DocumentSignerProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/components/SignConfigForm.d.ts

@@ -0,0 +1,2 @@
+import type { SignConfigFormProps } from '../types';
+export declare function SignConfigForm({ onSaved }: SignConfigFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/components/SignWidget.d.ts

@@ -0,0 +1,21 @@
+declare global {
+    interface Window {
+        Clicksign: new (signerId: string) => ClicksignInstance;
+    }
+}
+interface ClicksignInstance {
+    endpoint: string;
+    origin: string;
+    on: (event: string, callback: (data: unknown) => void) => void;
+    mount: (containerId: string) => void;
+    unmount: () => void;
+}
+interface SignWidgetProps {
+    signerId: string;
+    environment?: 'sandbox' | 'production';
+    onSign?: () => void;
+    onError?: (error: unknown) => void;
+    onClose?: () => void;
+}
+export declare function SignWidget({ signerId, environment, onSign, onError, onClose }: SignWidgetProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/sign/hooks/useSignConfig.d.ts

@@ -0,0 +1,6 @@
+import type { SignConfig } from '../types';
+export declare function useSignConfig(): {
+    config: SignConfig;
+    isLoading: boolean;
+    saveConfig: (apiKey: string, environment: "sandbox" | "production") => Promise<any>;
+};

package/dist/sign/index.d.ts

@@ -0,0 +1,7 @@
+export { DocumentSigner } from './components/DocumentSigner';
+export { SignWidget } from './components/SignWidget';
+export { D4SignWidget } from './components/D4SignWidget';
+export { SignConfigForm } from './components/SignConfigForm';
+export { useSignConfig } from './hooks/useSignConfig';
+export { signService } from './services/signService';
+export type { SignProvider, SignConfig, SignEnvelopeResult, SignedDocumentResult, DocumentSignerProps, SignWidgetProps, D4SignWidgetProps, SignConfigFormProps, } from './types';

package/dist/sign/services/signService.d.ts

@@ -0,0 +1,23 @@
+import type { SignEnvelopeResult, SignedDocumentResult, SignProvider } from '../types';
+export declare const signService: {
+    /**
+     * Resolve qual provedor está configurado para o alias.
+     * Tenta clicksign primeiro (backward compat), depois d4sign.
+     * Retorna o provedor resolvido.
+     */
+    resolveProvider(alias: string): Promise<SignProvider>;
+    createEnvelopeWithSigner(params: {
+        alias: string;
+        contentBase64: string;
+        filename: string;
+        signerEmail: string;
+        signerName: string;
+        provider?: SignProvider;
+    }): Promise<SignEnvelopeResult>;
+    getSignedDocument(params: {
+        alias: string;
+        envelopeId: string;
+        documentId: string;
+        provider?: SignProvider;
+    }): Promise<SignedDocumentResult>;
+};

package/dist/sign/types.d.ts

@@ -0,0 +1,53 @@
+export type SignProvider = 'clicksign' | 'd4sign';
+export interface SignConfig {
+    id: string;
+    alias: string;
+    provider: SignProvider;
+    api_key: string;
+    crypt_key: string | null;
+    uuid_safe: string | null;
+    environment: 'sandbox' | 'production';
+    monthly_limit: number | null;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+export interface SignEnvelopeResult {
+    success: boolean;
+    provider: SignProvider;
+    envelope_id: string;
+    document_id: string;
+    signer_id: string;
+    signer_email?: string;
+    environment: 'sandbox' | 'production';
+}
+export interface SignedDocumentResult {
+    success: boolean;
+    download_url: string | null;
+    document: Record<string, unknown> | null;
+}
+export interface DocumentSignerProps {
+    file?: File;
+    onDocumentSigned?: (data: SignEnvelopeResult) => void;
+    onError?: (error: Error) => void;
+    showEventLog?: boolean;
+}
+export interface SignWidgetProps {
+    signerId: string;
+    environment: 'sandbox' | 'production';
+    onSign?: () => void;
+    onError?: (error: Error) => void;
+    onClose?: () => void;
+}
+export interface D4SignWidgetProps {
+    documentKey: string;
+    signerEmail: string;
+    signerName?: string;
+    keySigner?: string;
+    environment: 'sandbox' | 'production';
+    onSign?: () => void;
+    onError?: (error: Error) => void;
+}
+export interface SignConfigFormProps {
+    onSaved?: () => void;
+}

package/dist/supabase/SupabaseSingleton.d.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from './types';
+export declare function getSupabaseClient(): SupabaseClient<Database>;

package/dist/supabase/client.d.ts

@@ -0,0 +1,2 @@
+export { getSupabaseClient } from './SupabaseSingleton';
+export { getPublicSupabaseClient } from './publicClient';

package/dist/supabase/publicClient.d.ts

@@ -0,0 +1,2 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+export declare function getPublicSupabaseClient(): SupabaseClient;