@bazilio-san/af-stream/dist/types/interfaces.d.ts

Data stream from database table

/// <reference types="node" />
import EventEmitter from 'events';
import { CallbackOrPromise, PoolOptions } from 'tarn/dist/Pool';
export declare type TEventRecord = {
    [fieldName: string | symbol]: any;
};
export declare type Nullable<T> = T | null;
/**
 * Data from the database, along with related information, to be sent to WSO2 over TCP as JSON
 */
export interface IRecordsComposite {
    sessionId: string;
    streamId: string;
    eventsPacket: TEventRecord[] | TEventRecord;
    tcpHeaderLength?: number;
    isSingleRecordAsObject?: boolean;
    first?: TEventRecord;
    last?: TEventRecord;
    sendCount?: number;
    sentBufferLength?: number;
}
/** Information for assembling TCP WSO2 messages */
export interface IEventComposite {
    sessionId: string;
    streamId: string;
    json: string;
}
export interface IEcho extends Function {
    echo: Function;
    error: Function;
    info: Function;
    debug: Function;
    silly: Function;
}
export interface ILoggerEx {
    error: Function;
    warn: Function;
    info: Function;
    debug: Function;
    silly: Function;
    isLevel: Function;
}
export interface TAccessPoint {
    consulServiceName: string;
    id: string;
    title: string;
    port: Nullable<number>;
    host: Nullable<string>;
    token: string;
    socketRequestId: string;
    waitForHostPortUpdated: (timeout: number) => Promise<boolean>;
}
export interface ISenderConfig {
    type: 'console' | 'tcp' | 'ws' | 'callback' | 'emitter';
    host?: string;
    port?: number;
    accessPoint?: TAccessPoint;
    eventCallback?: Function;
    emitSingleEvent?: boolean;
    emitId?: string;
}
export interface ISender {
    sendEvents: Function;
    connect: Function;
    eventCallback?: Function;
}
export declare type TDbRecord = {
    [fieldName: string | symbol]: any;
};
export declare type TYMDms = string;
export declare type TFieldType = string;
export declare type TFieldsTypes = {
    [fieldName: string]: TFieldType;
};
export declare type TFieldList = string[];
export declare type TFields = TFieldsTypes | TFieldList;
export interface IDbConfig {
    dialect: 'mssql' | 'pg';
    options?: any;
    host?: string;
    server?: string;
    port: number;
    database: string;
    user: string;
    password: string;
}
export interface IPoolOptions<T> extends Omit<PoolOptions<T>, 'create' | 'destroy'> {
    create?: CallbackOrPromise<T>;
    destroy?: (resource: T) => any;
}
export interface IMsSqlConfig {
    driver?: string | undefined;
    user?: string | undefined;
    password?: string | undefined;
    server: string;
    port?: number | undefined;
    domain?: string | undefined;
    database?: string | undefined;
    arrayRowMode?: boolean | undefined;
    beforeConnect?: Function;
    options?: {
        beforeConnect?: void | undefined;
        connectionString?: string | undefined;
        enableArithAbort?: boolean | undefined;
        instanceName?: string | undefined;
        trustedConnection?: boolean | undefined;
        useUTC?: boolean | undefined;
    };
    pool: IPoolOptions<any>;
    trustServerCertificate?: boolean | undefined;
    stream?: boolean | undefined;
    parseJSON?: boolean | undefined;
    requestTimeout?: number | undefined;
    connectionTimeout?: number | undefined;
}
export interface IPostgresClientConfig {
    user?: string | undefined;
    database?: string | undefined;
    password?: string | (() => string | Promise<string>) | undefined;
    port?: number | undefined;
    host?: string | undefined;
    connectionString?: string | undefined;
    keepAlive?: boolean | undefined;
    statement_timeout?: false | number | undefined;
    parseInputDatesAsUTC?: boolean | undefined;
    ssl?: any;
    keepAliveInitialDelayMillis?: number | undefined;
    idle_in_transaction_session_timeout?: number | undefined;
    application_name?: string | undefined;
    connectionTimeoutMillis?: number | undefined;
    options?: string | undefined;
}
export interface IPostgresConfig extends IPostgresClientConfig {
    max?: number | undefined;
    min?: number | undefined;
    idleTimeoutMillis?: number | undefined;
    log?: ((...messages: any[]) => void) | undefined;
    allowExitOnIdle?: boolean | undefined;
    maxUses?: number | undefined;
}
export interface IStreamConfig {
    streamId: string;
    fetchIntervalSec?: number;
    bufferMultiplier?: number;
    maxBufferSize?: number;
    src: {
        schema: string;
        table: string;
        idFields: string[];
        timezoneOfTsField?: string;
        tsField: string;
        dbOptions: IMsSqlConfig | IPostgresConfig;
        dbConfig: IDbConfig;
    };
    fields: TFields;
    printInfoIntervalSec?: number;
}
export interface ISenderConstructorOptions {
    streamConfig: IStreamConfig;
    senderConfig: ISenderConfig;
    serviceName: string;
    logger: ILoggerEx;
    echo: IEcho;
    exitOnError: Function;
    eventEmitter: EventEmitter;
}
export interface IDbConstructorOptions {
    streamConfig: IStreamConfig;
    logger: ILoggerEx;
    eventEmitter: EventEmitter;
    exitOnError: Function;
    dbOptions: IMsSqlConfig | IPostgresConfig;
    dbConfig: IDbConfig;
    millis2dbFn: Function;
}
export declare type TSlot = [leftIndex: number | null, foundIndex: number | null, rightIndex: number | null];
export interface IEmPortionOfDataSql {
    streamId: string;
    sql: string;
    startTs: number;
    endTs: number;
    limit: number;
    dbInfo: string;
}
export interface IEmPortionOfDataCount {
    streamId: string;
    sql: string;
    count: number;
}
export interface IEmVirtualHourChanged {
    prevN: number;
    currN: number;
    prevHZ: number;
    currHZ: number;
    prevTs: number;
    currTs: number;
}
export interface IEmVirtualDateChanged {
    prevN: number;
    currN: number;
    prevTs: number;
    currTs: number;
}
export interface IEmSubtractedLastTimeRecords {
    streamId: string;
    subtractedLastTimeRecords: TDbRecord[];
}
export interface IEmCurrentLastTimeRecords {
    streamId: string;
    currentLastTimeRecords: TDbRecord[];
}
export interface IEmBeforeLoadNextPortion {
    streamId: string;
    startTs: number;
    endTs: number;
}
export interface IEmAfterLoadNextPortion {
    streamId: string;
    startTs: number;
    endTs: number;
    lastRecordTs: number;
    last: TEventRecord | null;
    vt: number;
}
export interface IEmSaveLastTs {
    streamId: string;
    lastTs: number;
}
//# sourceMappingURL=interfaces.d.ts.map