@fluwa-tool/sdk 1.0.0

package/dist/core/Config.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Gerenciamento centralizado de configuração
+ * Responsabilidade única: manter e validar configurações
+ */
+import { FluwaConfig } from '../types';
+export interface IConfigManager {
+    getConfig(): FluwaConfig;
+    updateConfig(partial: Partial<FluwaConfig>): void;
+    isEnabled(): boolean;
+    getServerUrl(): string;
+    getAppName(): string;
+}
+/**
+ * Gerenciador de configuração
+ * Implementa pattern: Configuration Object
+ */
+export declare class ConfigManager implements IConfigManager {
+    private config;
+    constructor(initialConfig?: Partial<FluwaConfig>);
+    private validate;
+    getConfig(): FluwaConfig;
+    updateConfig(partial: Partial<FluwaConfig>): void;
+    isEnabled(): boolean;
+    getServerUrl(): string;
+    getAppName(): string;
+}
+export declare function getConfigManager(initialConfig?: Partial<FluwaConfig>): ConfigManager;
+export declare function resetConfig(): void;

package/dist/core/Config.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Gerenciamento centralizado de configuração
+ * Responsabilidade única: manter e validar configurações
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+exports.getConfigManager = getConfigManager;
+exports.resetConfig = resetConfig;
+const DEFAULT_CONFIG = {
+    serverUrl: 'http://localhost:5555',
+    enabled: true,
+    appName: 'DefaultApp',
+    debug: false,
+    requestTimeout: 5000,
+};
+/**
+ * Gerenciador de configuração
+ * Implementa pattern: Configuration Object
+ */
+class ConfigManager {
+    constructor(initialConfig) {
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...initialConfig,
+        };
+        this.validate();
+    }
+    validate() {
+        if (!this.config.serverUrl || typeof this.config.serverUrl !== 'string') {
+            throw new Error('serverUrl inválida');
+        }
+        if (typeof this.config.enabled !== 'boolean') {
+            throw new Error('enabled deve ser boolean');
+        }
+        if (!this.config.appName || typeof this.config.appName !== 'string') {
+            throw new Error('appName inválida');
+        }
+        if (this.config.requestTimeout && this.config.requestTimeout < 0) {
+            throw new Error('requestTimeout não pode ser negativa');
+        }
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(partial) {
+        this.config = {
+            ...this.config,
+            ...partial,
+        };
+        this.validate();
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+    getServerUrl() {
+        return this.config.serverUrl;
+    }
+    getAppName() {
+        return this.config.appName;
+    }
+}
+exports.ConfigManager = ConfigManager;
+// Instância singleton (lazy-loaded)
+let configInstance = null;
+function getConfigManager(initialConfig) {
+    if (!configInstance) {
+        configInstance = new ConfigManager(initialConfig);
+    }
+    return configInstance;
+}
+function resetConfig() {
+    configInstance = null;
+}

package/dist/core/IdGenerator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gerador de IDs únicos
+ * Responsabilidade única: gerar identificadores
+ */
+export interface IIdGenerator {
+    generate(): string;
+}
+/**
+ * Implementação de gerador de IDs
+ * Usa combinação de timestamp + random para garantir unicidade
+ */
+export declare class IdGenerator implements IIdGenerator {
+    /**
+     * Gera ID único no formato: timestamp_random
+     * Exemplo: 1710000000000_abc123def456
+     */
+    generate(): string;
+}
+export declare const idGenerator: IdGenerator;

package/dist/core/IdGenerator.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Gerador de IDs únicos
+ * Responsabilidade única: gerar identificadores
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idGenerator = exports.IdGenerator = void 0;
+/**
+ * Implementação de gerador de IDs
+ * Usa combinação de timestamp + random para garantir unicidade
+ */
+class IdGenerator {
+    /**
+     * Gera ID único no formato: timestamp_random
+     * Exemplo: 1710000000000_abc123def456
+     */
+    generate() {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substr(2, 9);
+        return `${timestamp}_${random}`;
+    }
+}
+exports.IdGenerator = IdGenerator;
+// Instância singleton
+exports.idGenerator = new IdGenerator();

package/dist/core/Logger.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Logger centralizado com níveis de severidade
+ * Responsabilidade única: logging estruturado
+ */
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR",
+    SUCCESS = "SUCCESS"
+}
+export interface ILogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, error?: Error | unknown): void;
+    success(message: string): void;
+    setLevel(level: LogLevel): void;
+}
+/**
+ * Implementação do logger
+ * Permite ativar/desativar diferentes níveis
+ */
+export declare class Logger implements ILogger {
+    private namespace;
+    private minLevel;
+    private readonly levelOrder;
+    constructor(namespace?: string, minLevel?: LogLevel);
+    private shouldLog;
+    private formatMessage;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, error?: Error | unknown): void;
+    success(message: string): void;
+    setLevel(level: LogLevel): void;
+}
+export declare const defaultLogger: Logger;

package/dist/core/Logger.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Logger centralizado com níveis de severidade
+ * Responsabilidade única: logging estruturado
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = exports.Logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["WARN"] = "WARN";
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["SUCCESS"] = "SUCCESS";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Implementação do logger
+ * Permite ativar/desativar diferentes níveis
+ */
+class Logger {
+    constructor(namespace = 'Fluwa', minLevel = LogLevel.INFO) {
+        this.levelOrder = {
+            [LogLevel.DEBUG]: 0,
+            [LogLevel.INFO]: 1,
+            [LogLevel.WARN]: 2,
+            [LogLevel.ERROR]: 3,
+            [LogLevel.SUCCESS]: 1,
+        };
+        this.namespace = namespace;
+        this.minLevel = minLevel;
+    }
+    shouldLog(level) {
+        return this.levelOrder[level] >= this.levelOrder[this.minLevel];
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] [${this.namespace}:${level}] ${message}`;
+    }
+    debug(message, data) {
+        if (!this.shouldLog(LogLevel.DEBUG))
+            return;
+        console.log(this.formatMessage(LogLevel.DEBUG, message), data || '');
+    }
+    info(message, data) {
+        if (!this.shouldLog(LogLevel.INFO))
+            return;
+        console.log(this.formatMessage(LogLevel.INFO, message), data || '');
+    }
+    warn(message, data) {
+        if (!this.shouldLog(LogLevel.WARN))
+            return;
+        console.warn(this.formatMessage(LogLevel.WARN, message), data || '');
+    }
+    error(message, error) {
+        if (!this.shouldLog(LogLevel.ERROR))
+            return;
+        console.error(this.formatMessage(LogLevel.ERROR, message));
+        if (error instanceof Error) {
+            console.error(`Stack: ${error.stack}`);
+        }
+        else if (error) {
+            console.error('Details:', error);
+        }
+    }
+    success(message) {
+        if (!this.shouldLog(LogLevel.SUCCESS))
+            return;
+        console.log(`✓ ${this.formatMessage(LogLevel.SUCCESS, message)}`);
+    }
+    setLevel(level) {
+        this.minLevel = level;
+    }
+}
+exports.Logger = Logger;
+// Instância singleton do logger padrão
+exports.defaultLogger = new Logger('Fluwa', LogLevel.INFO);

package/dist/features/communication/HttpClient.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Cliente HTTP para comunicação com Fluwa Server
+ * Responsabilidade única: fazer requisições HTTP
+ */
+import { ILogger } from '../../core/Logger';
+export interface IHttpClient {
+    post<T>(endpoint: string, data: unknown): Promise<T>;
+    get<T>(endpoint: string, params?: Record<string, string>): Promise<T>;
+    put<T>(endpoint: string, data: unknown): Promise<T>;
+}
+/**
+ * Implementação do cliente HTTP
+ * Usa fetch nativo do navegador/Node.js
+ */
+export declare class HttpClient implements IHttpClient {
+    private baseUrl;
+    private logger;
+    private timeout;
+    constructor(baseUrl: string, logger: ILogger, timeout?: number);
+    /**
+     * Fazer POST request
+     * Implementa timeout automático
+     */
+    post<T>(endpoint: string, data: unknown): Promise<T>;
+    /**
+     * Fazer GET request com query parameters
+     */
+    get<T>(endpoint: string, params?: Record<string, string>): Promise<T>;
+    /**
+     * Fazer PUT request
+     */
+    put<T>(endpoint: string, data: unknown): Promise<T>;
+    /**
+     * Request genérica com timeout
+     */
+    private request;
+    /**
+     * Construir URL com query parameters
+     */
+    private buildUrl;
+}

package/dist/features/communication/HttpClient.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Cliente HTTP para comunicação com Fluwa Server
+ * Responsabilidade única: fazer requisições HTTP
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+/**
+ * Implementação do cliente HTTP
+ * Usa fetch nativo do navegador/Node.js
+ */
+class HttpClient {
+    constructor(baseUrl, logger, timeout = 5000) {
+        this.baseUrl = baseUrl;
+        this.logger = logger;
+        this.timeout = timeout;
+    }
+    /**
+     * Fazer POST request
+     * Implementa timeout automático
+     */
+    async post(endpoint, data) {
+        return this.request('POST', endpoint, { body: JSON.stringify(data) });
+    }
+    /**
+     * Fazer GET request com query parameters
+     */
+    async get(endpoint, params) {
+        const url = this.buildUrl(endpoint, params);
+        return this.request('GET', url);
+    }
+    /**
+     * Fazer PUT request
+     */
+    async put(endpoint, data) {
+        return this.request('PUT', endpoint, { body: JSON.stringify(data) });
+    }
+    /**
+     * Request genérica com timeout
+     */
+    async request(method, endpoint, options = {}) {
+        const url = endpoint.startsWith('http')
+            ? endpoint
+            : `${this.baseUrl}${endpoint}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Fluwa-Internal': 'true', // Marcar como requisição interna do Fluwa
+                    ...options.headers,
+                },
+                ...options,
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            const isTimeout = error instanceof Error && error.name === 'AbortError';
+            if (isTimeout) {
+                this.logger.warn(`Request timeout: ${endpoint}`);
+            }
+            else {
+                this.logger.error(`HTTP request failed: ${endpoint}`, error);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Construir URL com query parameters
+     */
+    buildUrl(endpoint, params) {
+        if (!params || Object.keys(params).length === 0) {
+            return endpoint;
+        }
+        const queryString = new URLSearchParams(params).toString();
+        return `${endpoint}?${queryString}`;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/features/communication/WebSocketClient.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Cliente WebSocket para comunicação bidirecional em tempo real
+ * Responsabilidade única: gerenciar conexão WebSocket
+ */
+import { ILogger } from '../../core/Logger';
+import { WebSocketMessage } from '../../types';
+export declare enum WebSocketState {
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    ERROR = "ERROR"
+}
+export interface IWebSocketClient {
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(message: WebSocketMessage): void;
+    isConnected(): boolean;
+    on(event: 'message' | 'connected' | 'disconnected' | 'error', callback: (data?: unknown) => void): void;
+}
+/**
+ * Implementação do cliente WebSocket
+ * Implementa pattern: Observer
+ */
+export declare class WebSocketClient implements IWebSocketClient {
+    private logger;
+    private ws;
+    private url;
+    private state;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private messageListeners;
+    private connectedListeners;
+    private disconnectedListeners;
+    private errorListeners;
+    constructor(serverUrl: string, logger: ILogger, appName?: string);
+    /**
+     * Conectar ao servidor WebSocket
+     */
+    connect(): Promise<void>;
+    /**
+     * Desconectar do WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Enviar mensagem via WebSocket
+     */
+    send(message: WebSocketMessage): void;
+    /**
+     * Verificar se está conectado
+     */
+    isConnected(): boolean;
+    /**
+     * Registrar listener para evento
+     */
+    on(event: 'message' | 'connected' | 'disconnected' | 'error', callback: (data?: unknown) => void): void;
+    /**
+     * Tentar reconectar com backoff exponencial
+     */
+    private reconnect;
+}

package/dist/features/communication/WebSocketClient.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Cliente WebSocket para comunicação bidirecional em tempo real
+ * Responsabilidade única: gerenciar conexão WebSocket
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = exports.WebSocketState = void 0;
+var WebSocketState;
+(function (WebSocketState) {
+    WebSocketState["CONNECTING"] = "CONNECTING";
+    WebSocketState["CONNECTED"] = "CONNECTED";
+    WebSocketState["DISCONNECTED"] = "DISCONNECTED";
+    WebSocketState["ERROR"] = "ERROR";
+})(WebSocketState || (exports.WebSocketState = WebSocketState = {}));
+/**
+ * Implementação do cliente WebSocket
+ * Implementa pattern: Observer
+ */
+class WebSocketClient {
+    constructor(serverUrl, logger, appName) {
+        this.logger = logger;
+        this.ws = null;
+        this.state = WebSocketState.DISCONNECTED;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 3000;
+        // Listeners para eventos
+        this.messageListeners = new Set();
+        this.connectedListeners = new Set();
+        this.disconnectedListeners = new Set();
+        this.errorListeners = new Set();
+        // Converter http:// para ws:// ou https:// para wss://
+        const wsUrl = serverUrl
+            .replace(/^https?:\/\//, (match) => {
+            return match.startsWith('https') ? 'wss://' : 'ws://';
+        })
+            .concat('/ws');
+        // Adicionar appName como query string se fornecido
+        this.url = appName ? `${wsUrl}?appName=${encodeURIComponent(appName)}` : wsUrl;
+    }
+    /**
+     * Conectar ao servidor WebSocket
+     */
+    async connect() {
+        if (this.state === WebSocketState.CONNECTED || this.state === WebSocketState.CONNECTING) {
+            return;
+        }
+        this.state = WebSocketState.CONNECTING;
+        this.logger.debug(`Conectando ao WebSocket: ${this.url}`);
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.url);
+                this.ws.onopen = () => {
+                    this.state = WebSocketState.CONNECTED;
+                    this.reconnectAttempts = 0;
+                    this.logger.success('WebSocket conectado');
+                    this.connectedListeners.forEach((cb) => cb());
+                    resolve();
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const message = JSON.parse(event.data);
+                        this.messageListeners.forEach((cb) => cb(message));
+                    }
+                    catch (error) {
+                        this.logger.warn('Erro ao parsear mensagem WebSocket', error);
+                    }
+                };
+                this.ws.onerror = (error) => {
+                    this.state = WebSocketState.ERROR;
+                    this.logger.error('Erro WebSocket', error);
+                    this.errorListeners.forEach((cb) => cb(error));
+                };
+                this.ws.onclose = () => {
+                    this.state = WebSocketState.DISCONNECTED;
+                    this.logger.warn('WebSocket desconectado');
+                    this.disconnectedListeners.forEach((cb) => cb());
+                    // Tentar reconectar
+                    this.reconnect();
+                };
+            }
+            catch (error) {
+                this.state = WebSocketState.ERROR;
+                this.logger.error('Erro ao criar WebSocket', error);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Desconectar do WebSocket
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.state = WebSocketState.DISCONNECTED;
+            this.maxReconnectAttempts = 0; // Previne reconexão automática
+        }
+    }
+    /**
+     * Enviar mensagem via WebSocket
+     */
+    send(message) {
+        if (!this.isConnected()) {
+            this.logger.warn('WebSocket não está conectado');
+            return;
+        }
+        try {
+            this.ws.send(JSON.stringify(message));
+        }
+        catch (error) {
+            this.logger.error('Erro ao enviar mensagem WebSocket', error);
+        }
+    }
+    /**
+     * Verificar se está conectado
+     */
+    isConnected() {
+        return this.state === WebSocketState.CONNECTED;
+    }
+    /**
+     * Registrar listener para evento
+     */
+    on(event, callback) {
+        switch (event) {
+            case 'message':
+                this.messageListeners.add(callback);
+                break;
+            case 'connected':
+                this.connectedListeners.add(callback);
+                break;
+            case 'disconnected':
+                this.disconnectedListeners.add(callback);
+                break;
+            case 'error':
+                this.errorListeners.add(callback);
+                break;
+        }
+    }
+    /**
+     * Tentar reconectar com backoff exponencial
+     */
+    reconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.logger.error(`Falha ao reconectar após ${this.maxReconnectAttempts} tentativas`);
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.logger.warn(`Tentando reconectar em ${delay}ms (tentativa ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        setTimeout(() => {
+            this.connect().catch((error) => {
+                this.logger.error('Reconexão falhou', error);
+            });
+        }, delay);
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/features/network/FetchInterceptor.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Interceptador de fetch nativo do navegador
+ * Responsabilidade única: interceptar e logar requisições fetch
+ */
+import { ILogger } from '../../core/Logger';
+import { IRequestLogger } from './RequestLogger';
+import { IMockResolver } from './MockResolver';
+export interface IFetchInterceptor {
+    install(): void;
+    uninstall(): void;
+}
+/**
+ * Implementação de interceptador de fetch
+ * Preserva fetch original e sobrescreve com versão interceptada
+ */
+export declare class FetchInterceptor implements IFetchInterceptor {
+    private logger;
+    private requestLogger;
+    private mockResolver;
+    private sessionId;
+    private appName;
+    private originalFetch;
+    private isInstalled;
+    constructor(logger: ILogger, requestLogger: IRequestLogger, mockResolver: IMockResolver, sessionId: string, appName: string);
+    /**
+     * Instalar o interceptador
+     * Substitui fetch global
+     */
+    install(): void;
+    /**
+     * Desinstalar o interceptador
+     * Restaura fetch original
+     */
+    uninstall(): void;
+    /**
+     * Criar versão interceptada de fetch
+     */
+    private createInterceptedFetch;
+    /**
+     * Parse seguro do body (string ou object)
+     */
+    private safeParseBody;
+    /**
+     * Gerar ID único para requisição
+     */
+    private generateId;
+    /**
+     * Sleep (para delays de mock)
+     */
+    private delay;
+}