@syntropylog/adapters/dist/index.d.ts

External adapters for SyntropyLog framework

import { Kafka } from 'kafkajs';
import { IBrokerAdapter, BrokerMessage, MessageHandler, IHttpClientAdapter, AdapterHttpRequest, AdapterHttpResponse } from '@syntropylog/types';
import { AxiosRequestConfig, AxiosInstance } from 'axios';

declare class KafkaAdapter implements IBrokerAdapter {
    private readonly producer;
    private readonly consumer;
    constructor(kafkaInstance: Kafka, groupId: string);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    publish(topic: string, message: BrokerMessage): Promise<void>;
    subscribe(topic: string, handler: MessageHandler): Promise<void>;
}

declare class RabbitMQAdapter implements IBrokerAdapter {
    private connection;
    private channel;
    private connectionString;
    private exchangeName;
    private consumerTags;
    constructor(connectionString: string, exchangeName?: string);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    publish(topic: string, message: BrokerMessage): Promise<void>;
    subscribe(topic: string, handler: MessageHandler): Promise<void>;
    unsubscribe(topic: string): Promise<void>;
}

declare class NatsAdapter implements IBrokerAdapter {
    private readonly natsServers;
    private natsConnection;
    private codec;
    private subscriptions;
    constructor(natsServers?: string[]);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    publish(topic: string, message: BrokerMessage): Promise<void>;
    subscribe(topic: string, handler: MessageHandler): Promise<void>;
    unsubscribe(topic: string): Promise<void>;
    private natsHeadersToRecord;
    private recordToNatsHeaders;
}

/**
 * @file src/http/adapters/AxiosAdapter.ts
 * @description An implementation of the IHttpClientAdapter for the Axios library.
 * This class acts as a "translator," converting requests and responses
 * between the framework's generic format and the Axios-specific format.
 */

/**
 * @class AxiosAdapter
 * @description An adapter that allows SyntropyLog to instrument HTTP requests
 * made with the Axios library. It implements the `IHttpClientAdapter` interface.
 * @implements {IHttpClientAdapter}
 */
declare class AxiosAdapter implements IHttpClientAdapter {
    private readonly axiosInstance;
    /**
     * @constructor
     * @param {AxiosRequestConfig | AxiosInstance} config - Either a pre-configured
     * Axios instance or a configuration object to create a new instance.
     */
    constructor(config: AxiosRequestConfig | AxiosInstance);
    /**
     * Executes an HTTP request using the configured Axios instance.
     * It translates the generic `AdapterHttpRequest` into an `AxiosRequestConfig`,
     * sends the request, and then normalizes the Axios response or error back
     * into the framework's generic format (`AdapterHttpResponse` or `AdapterHttpError`).
     * @template T The expected type of the response data.
     * @param {AdapterHttpRequest} request The generic request object.
     * @returns {Promise<AdapterHttpResponse<T>>} A promise that resolves with the normalized response.
     * @throws {AdapterHttpError} Throws a normalized error if the request fails.
     */
    request<T>(request: AdapterHttpRequest): Promise<AdapterHttpResponse<T>>;
}

declare class FetchAdapter implements IHttpClientAdapter {
    request<T>(request: AdapterHttpRequest): Promise<AdapterHttpResponse<T>>;
}

interface SerializationContext {
    sanitize?: boolean;
    sensitiveFields?: string[];
    maxDepth?: number;
    timeout?: number;
}
interface SerializationResult {
    success: boolean;
    data?: any;
    error?: string;
    metadata: {
        serializer: string;
        complexity: 'low' | 'medium' | 'high';
        duration: number;
        timestamp: string;
    };
}
interface ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
}

declare class PrismaSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isPrismaQuery;
    private isPrismaError;
    private isPrismaClient;
    private assessQueryComplexity;
    private serializeQuery;
    private serializeError;
    private serializeClient;
}

declare class TypeORMSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isTypeORMQuery;
    private isTypeORMError;
    private isTypeORMEntity;
    private isTypeORMRepository;
    private isTypeORMConnection;
    private assessQueryComplexity;
    private assessEntityComplexity;
    private serializeQuery;
    private serializeError;
    private serializeEntity;
    private serializeRepository;
    private serializeConnection;
}

declare class MySQLSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isMySQLQuery;
    private isMySQLError;
    private isMySQLConnection;
    private isMySQLPool;
    private assessQueryComplexity;
    private serializeQuery;
    private serializeError;
    private serializeConnection;
    private serializePool;
}

declare class PostgreSQLSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isPostgreSQLQuery;
    private isPostgreSQLError;
    private isPostgreSQLClient;
    private isPostgreSQLPool;
    private assessQueryComplexity;
    private serializeQuery;
    private serializeError;
    private serializeClient;
    private serializePool;
}

declare class SQLServerSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isSQLServerQuery;
    private isSQLServerError;
    private isSQLServerConnection;
    private isSQLServerPool;
    private assessQueryComplexity;
    private serializeQuery;
    private serializeError;
    private serializeConnection;
    private serializePool;
}

declare class OracleSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isOracleQuery;
    private isOracleError;
    private isOracleConnection;
    private isOraclePool;
    private assessQueryComplexity;
    private serializeQuery;
    private serializeError;
    private serializeConnection;
    private serializePool;
}

declare class MongoDBSerializer implements ISerializer {
    name: string;
    priority: number;
    canSerialize(data: any): boolean;
    getComplexity(data: any): 'low' | 'medium' | 'high';
    serialize(data: any, context: SerializationContext): Promise<SerializationResult>;
    private isMongoDBQuery;
    private isMongoDBAggregation;
    private isMongoDBError;
    private assessQueryComplexity;
    private assessAggregationComplexity;
    private serializeQuery;
    private serializeAggregation;
    private serializeError;
    private sanitizePipeline;
    private sanitizeObject;
}

declare function registerAllSerializers(manager: any): void;
declare function getAllSerializers(): (PrismaSerializer | TypeORMSerializer | MySQLSerializer | PostgreSQLSerializer | SQLServerSerializer | OracleSerializer | MongoDBSerializer)[];

export { AxiosAdapter, FetchAdapter, KafkaAdapter, MongoDBSerializer, MySQLSerializer, NatsAdapter, OracleSerializer, PostgreSQLSerializer, PrismaSerializer, RabbitMQAdapter, SQLServerSerializer, TypeORMSerializer, getAllSerializers, registerAllSerializers };
export type { ISerializer, SerializationContext, SerializationResult };