@fluent-org/logger/build/src/protocol.d.ts

A node fluent protocol compatible logger

import EventTime from "./event_time";
import { Readable } from "stream";
export declare type SharedKey = string;
export declare type SharedKeyNonce = string | Uint8Array;
export declare type AuthSalt = string | Uint8Array;
export declare type Keepalive = boolean;
export declare type HeloOptions = {
    nonce: SharedKeyNonce;
    auth?: AuthSalt;
    keepalive?: Keepalive;
};
export declare type HeloMessage = ["HELO", HeloOptions];
export declare type ClientHostname = string;
export declare type SharedKeySalt = string | Uint8Array;
export declare type SharedKeyHexDigest = string;
export declare type Username = string;
export declare type Password = string;
export declare type PasswordDigest = string;
export declare type PingMessage = [
    "PING",
    ClientHostname,
    SharedKeySalt,
    SharedKeyHexDigest,
    Username,
    Password
];
export declare type Authenticated = boolean;
export declare type Reason = string;
export declare type ServerHostname = string;
export declare type PongMessage = [
    "PONG",
    Authenticated,
    Reason,
    ServerHostname,
    SharedKeyHexDigest
];
export declare type Chunk = string;
export declare type AckMessage = {
    ack: Chunk;
};
export declare type Option = {
    size?: number;
    chunk?: Chunk;
    compressed?: "gzip";
};
export declare type CompressedOption = Option & {
    compressed: "gzip";
};
export declare type Tag = string;
export declare type Time = number | EventTime;
export declare type EventRecord = Record<string, any>;
export declare type MessagePackEventStream = Uint8Array;
export declare type Entry = [Time, EventRecord];
export declare type MessageMode = [Tag, Time, EventRecord, Option?];
export declare type ForwardMode = [Tag, Entry[], Option?];
export declare type PackedForwardMode = [Tag, MessagePackEventStream, Option?];
export declare type CompressedPackedForwardMode = [
    Tag,
    MessagePackEventStream,
    CompressedOption
];
export declare type ServerHandshakeMessage = HeloMessage | PongMessage;
export declare type ClientHandshakeMessage = PingMessage;
export declare type ServerTransportMessage = AckMessage;
export declare type ClientTransportMessage = MessageMode | ForwardMode | PackedForwardMode | CompressedPackedForwardMode;
export declare type ServerMessage = ServerTransportMessage | ServerHandshakeMessage;
export declare type ClientMessage = ClientTransportMessage | ClientHandshakeMessage;
export declare type ServerKeyInfo = {
    key: SharedKey;
    nonce: SharedKeyNonce;
};
export declare type SharedKeyInfo = ServerKeyInfo & {
    salt: SharedKeySalt;
};
export declare type ClientAuthInfo = {
    salt: AuthSalt;
    username: Username;
    password: Password;
};
export declare type ServerAuthInfo = {
    salt: AuthSalt;
    userDict: Record<Username, Password>;
};
declare type PingResult = {
    sharedKeyInfo: SharedKeyInfo;
};
export declare const isHelo: (message: any) => message is HeloMessage;
export declare const isPing: (message: any) => message is PingMessage;
export declare const isPong: (message: any) => message is PongMessage;
export declare const isAck: (message: any) => message is AckMessage;
export declare const isTime: (data: any) => data is Time;
export declare const isOption: (data: any) => data is Option | undefined;
export declare const isTag: (data: any) => data is string;
export declare const isEventRecord: (data: any) => data is EventRecord;
export declare const isEntry: (data: any) => data is Entry;
export declare const isMessageMode: (message: any) => message is MessageMode;
export declare const isForwardMode: (message: any) => message is ForwardMode;
export declare const isPackedForwardMode: (message: any) => message is PackedForwardMode;
export declare const isCompressedPackedForwardMode: (message: any) => message is CompressedPackedForwardMode;
export declare const isServerHandshakeMessage: (message: any) => message is ServerHandshakeMessage;
export declare const isClientHandshakeMessage: (message: any) => message is PingMessage;
export declare const isServerTransportMessage: (message: any) => message is AckMessage;
export declare const isClientTransportMessage: (message: any) => message is ClientTransportMessage;
export declare const isServerMessage: (message: any) => message is ServerMessage;
export declare const isClientMessage: (message: any) => message is ClientMessage;
export declare const generateHelo: (nonce: SharedKeyNonce, auth: AuthSalt, keepalive: Keepalive) => HeloMessage;
export declare const parseHelo: (m: HeloMessage) => HeloOptions;
export declare const generatePing: (hostname: ClientHostname, sharedKeyInfo: SharedKeyInfo, authInfo?: ClientAuthInfo | undefined) => PingMessage;
/**
 * Validates a PING message from the client
 *
 * Assumes a valid structure (isPing has been called)
 *
 * @param m The ping message to validate
 * @param serverHostname The hostname of the client
 * @param serverKeyInfo The key info known to the server
 * @param authInfo Authentication information to validate (optional, auth not required if missing)
 * @returns An object with the complete SharedKeyInfo
 * @throws Error on mismatches
 */
export declare const checkPing: (m: PingMessage, serverHostname: ServerHostname, serverKeyInfo: ServerKeyInfo, authInfo?: ServerAuthInfo | undefined) => PingResult;
export declare const generatePong: (hostname: ServerHostname, authenticated: Authenticated, reason: Reason, sharedKeyInfo?: SharedKeyInfo | undefined) => PongMessage;
/**
 * Checks the PONG message from the server
 *
 * Assumes a valid structure (isPong has been called)
 * @param m The PONG message from the server to validate
 * @param clientHostname The client hostname
 * @param sharedKeyInfo The client shared key information
 * @throws Error on validation issues
 */
export declare const checkPong: (m: PongMessage, clientHostname: ClientHostname, sharedKeyInfo: SharedKeyInfo) => void;
export declare const generateAck: (ack: string) => AckMessage;
export declare const generateMessageMode: (tag: Tag, time: Time, event: EventRecord, chunk?: string | undefined) => MessageMode;
export declare const generateForwardMode: (tag: Tag, entries: Entry[], chunk?: string | undefined) => ForwardMode;
export declare const generatePackedForwardMode: (tag: Tag, packedEntries: Uint8Array[], packedEntryLength: number, chunk?: string | undefined) => PackedForwardMode;
export declare const generateCompressedPackedForwardMode: (tag: Tag, packedEntries: Uint8Array[], packedEntryLength: number, chunk?: string | undefined) => CompressedPackedForwardMode;
export declare const generateEntry: (time: Time, event: EventRecord) => Entry;
export declare type DecodedEntries = {
    tag: Tag;
    entries: Entry[];
    /**
     * The chunk from the transport message, if any, used for acks
     */
    chunk?: Chunk;
};
/**
 * Parses a transport message from the client
 *
 * @param message The transport message to parse
 * @returns An object with the decoded entries from the object
 */
export declare const parseTransport: (message: ClientTransportMessage) => DecodedEntries;
export declare const encode: (item: any) => Uint8Array;
export declare const decode: (data: Uint8Array) => unknown;
export declare const packEntry: (entry: Entry) => Uint8Array;
export declare const decodeServerMessage: (data: Uint8Array) => ServerMessage;
export declare const decodeClientMessage: (data: Uint8Array) => ClientMessage;
export declare const encodeMessage: (item: ServerMessage | ClientMessage) => Uint8Array;
/**
 * Decodes a stream of data from the client
 *
 * @param dataStream A Readable to read the data from
 * @returns An iterable of messages from the client, not type checked
 */
export declare const decodeClientStream: (dataStream: Readable) => AsyncIterable<ClientMessage>;
/**
 * Decodes a stream of data from the server
 *
 * @param dataStream A Readable to read the data from
 * @returns An iterable of messages from the server, not type checked
 */
export declare const decodeServerStream: (dataStream: Readable) => AsyncIterable<ServerMessage>;
/**
 * Decodes a sequence of entries from a Buffer
 *
 * Useful for PackedForward|CompressedPackedForward event modes
 * @param data The data to unpack
 * @returns The entries from the data
 */
export declare const decodeEntries: (data: Uint8Array) => Entry[];
export {};