@eang/core/lib/src/eang.d.ts

eang - model driven enterprise event processing

import { ConsumerStream, NatsStreamService } from './NatsStreamingService.js';
import { NatsConnection } from '@nats-io/nats-core';
import { JetStreamClient, JetStreamManager, JetStreamPublishOptions } from '@nats-io/jetstream';
import { FunctionStartContext, IFunctionStopContext } from './context.js';
import { EntityEvent } from './entity.js';
import * as v from 'valibot';
export type EangFunctionHandler<TInput extends object = any, TOutput extends object = any, TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> = (input: TInput, eang: EangFunction<TEnv, TSecrets>, context?: FunctionStartContext) => Promise<IFunctionStopContext<TOutput>>;
export interface IPublishingOptions {
    tenant: string;
    organizationalUnit?: string;
    user: string;
    jetStreamOptions?: Partial<JetStreamPublishOptions>;
}
/**
 * Configuration for Eang classes with optional type-safe secrets and environment variables.
 *
 * All fields are optional and will be loaded from environment variables if not provided:
 * - tenant: env.EANG_TENANT
 * - organizationalUnit: env.EANG_ORGANIZATIONAL_UNIT
 * - servers: env.EANG_SERVERS
 * - user: env.EANG_USER
 * - password: env.EANG_PASSWORD
 *
 * @example
 * // Provide only secretsSchema, everything else from environment
 * const publisher = new EangPublisher<never, MySecrets>({
 *   secretsSchema: MySecretsSchema
 * })
 *
 * @example
 * // Type-safe environment variables only
 * const publisher = new EangPublisher<MyEnv>({
 *   envSchema: MyEnvSchema
 * })
 *
 * @example
 * // Both type-safe env and secrets
 * const publisher = new EangPublisher<MyEnv, MySecrets>({
 *   envSchema: MyEnvSchema,
 *   secretsSchema: MySecretsSchema
 * })
 */
export interface EangConfig<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> {
    tenant?: string;
    organizationalUnit?: string | undefined;
    servers?: string;
    user?: string;
    password?: string;
    secretsFilePath?: string;
    secrets?: TSecrets;
    secretsSchema?: v.BaseSchema<any, TSecrets, any>;
    env?: TEnv;
    envSchema?: v.BaseSchema<any, TEnv, any>;
    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
}
export interface EangFunctionConfig<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> extends EangConfig<TEnv, TSecrets> {
    instanceOf?: string;
}
export interface EangServiceConfig<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> extends EangConfig<TEnv, TSecrets> {
    instanceOf?: string;
    subscriptions?: string[];
}
export declare abstract class EangBase<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> {
    tenant: string;
    organizationalUnit?: string | undefined;
    servers: string;
    user: string;
    protected _password: string;
    protected _secretsFilePath: string | undefined;
    protected _secretsSchema: v.BaseSchema<any, TSecrets, any> | undefined;
    protected _logLevel: string;
    protected _secrets: TSecrets | undefined;
    protected _env: TEnv | undefined;
    protected _envSchema: v.BaseSchema<any, TEnv, any> | undefined;
    protected _nss: NatsStreamService;
    protected _natsConnection: {
        nc: NatsConnection;
        js: JetStreamClient;
        jsm: JetStreamManager;
    } | undefined;
    log: import("pino").Logger<never, boolean>;
    get secrets(): TSecrets;
    get env(): TEnv;
    protected get natConf(): {
        servers: string;
        user: string;
        pass: string;
    };
    constructor(conf: EangConfig<TEnv, TSecrets>);
    ensureStream(streamName: string, subjects: string[]): Promise<{
        created: boolean;
        streamInfo: import("@nats-io/jetstream").StreamInfo;
    }>;
    publish(events: EntityEvent[], options?: IPublishingOptions): Promise<import("@nats-io/jetstream").PubAck[]>;
    shutdown(): Promise<void>;
}
export declare class EangPublisher<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> extends EangBase<TEnv, TSecrets> {
    constructor(conf?: EangConfig<TEnv, TSecrets>);
}
export declare class EangFunction<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> extends EangBase<TEnv, TSecrets> {
    instanceOf: string;
    private _subscription;
    private _handler;
    constructor(options: {
        conf?: EangFunctionConfig<TEnv, TSecrets>;
        handler: EangFunctionHandler<any, any, TEnv, TSecrets>;
    });
    start(): Promise<void>;
    shutdown(): Promise<void>;
}
export declare class EangService<TEnv = {
    [key: string]: string;
}, TSecrets = {
    [key: string]: string;
}> extends EangBase<TEnv, TSecrets> {
    instanceOf: string;
    subscriptions: string[];
    constructor(conf?: EangServiceConfig<TEnv, TSecrets>);
    start(): Promise<ConsumerStream>;
}