bf-lib/system/Types.d.ts

import { EnumLiteralsOf, IUserEntity } from 'bf-types';
import { ClientConfig, NexusConfig, Nullable } from '../common/types';
import { Nexus } from './Nexus';
export declare type HeadersType = Record<string, string>;
export declare type ObjectType = Record<string, any>;
export declare type Lock<T> = (suppliedKey: symbol) => T;
export declare type InitSettings = {
    nexus: NexusConfig;
    client: ClientConfig;
    auth: ClientAuth;
    logging: SystemLoggerOptions;
    impersonate?: Record<string, string>;
    protected?: boolean;
};
export declare type SystemLogLevel = 'debug' | 'info' | 'warn' | 'error';
export declare type SystemLogLevelMask = SystemLogLevel[];
export declare type SystemLoggerOptions = {
    logger: SystemLogger;
    mask: SystemLogLevelMask;
};
export interface SystemLogger {
    debug: (message: any) => void;
    info: (message: any) => void;
    warn: (message: any) => void;
    error: (message: any) => void;
}
export interface SystemWrapper {
    init(settings: InitSettings): void;
    sealModule<T extends ObjectType>(module: T): Lock<T>;
}
export interface SystemInstance {
    nexus: Nexus;
    isProtected(): boolean;
    getHttpHeaders(): Record<string, string>;
    getImpersonationHeaders(): Record<string, string>;
    setHttpHeader(key: string, value: string): void;
    getEventBus(): EventBus;
    getLibModule: <T>(type: LibModule) => T;
}
export declare type System = SystemInstance & SystemWrapper;
export declare type LibModule = EnumLiteralsOf<typeof LibModule>;
export declare const LibModule: Readonly<{
    readonly API: symbol;
    readonly AUTH: symbol;
    readonly MODULE: symbol;
    readonly MULTITOOL: symbol;
}>;
export interface ClientAuth {
    connect(nexusUrl: string): Promise<Nullable<IUserEntity>> | Nullable<IUserEntity>;
    afterConnect?: (system: SystemInstance) => void;
    afterDisconnect?: (system: SystemInstance) => void;
    reconnect(system: SystemInstance): Promise<Nullable<IUserEntity>> | Nullable<IUserEntity>;
    disconnect(system: SystemInstance): void;
}
export declare type Event<T> = {
    topic: string;
    data: T;
};
export declare type EventHandler<T> = (event: Event<T>) => void;
export declare type EventHandlerSet = Set<EventHandler<any>>;
export declare type EventHandlerMap = Map<string, EventHandlerSet>;
/**
 * An EventBus is used by the system for interal, decoupled communication
 * between different modules
 */
export interface EventBus {
    publish(channel: string, event: Event<any>): void;
    subscribe(channel: string, handler: EventHandler<any>): void;
}