froge/dist/index.d.ts

Jump-start your NodeJS/Bun/... services with dependency & lifecycle management and handy helper methods

import envHelper from './env';
import { type Plug } from './plug';
type MaybePromise<T> = T | Promise<T>;
type UnpackPromise<T> = T extends Promise<infer R> ? R : T;
type UnpackAsyncFunction<T> = T extends (...args: any) => infer R ? UnpackPromise<R> : T;
type UnpackAsyncMap<Map extends {}> = {
    [K in keyof Map]: UnpackAsyncFunction<Map[K]>;
};
export interface CommonFrogeContext<ServiceMap extends {}> {
    services: ServiceMap;
    envs: typeof envHelper;
}
export interface FrogeContext<ServiceMap extends {}> extends CommonFrogeContext<ServiceMap> {
    log: (...items: any) => void;
    plug: <T extends NonNullable<unknown>>() => Plug<T>;
}
type PlugCallback<T extends keyof ServiceMap, ServiceMap extends {}> = ServiceMap[T] extends Plug<infer S> ? (ctx: FrogeContext<ServiceMap>) => MaybePromise<() => S> : never;
export interface FrogeConfig {
    /** Start services which don't depend on each other in parallel */
    parallelStartGroups: boolean;
    /** Stop services which don't depend on each other in parallel */
    parallelStopGroups: boolean;
    /** Kill the process if shutdown took longer than expected */
    gracefulShutdownTimeoutMs?: number;
    /** Force exit the current process after shutdown is completed */
    forceExitAfterShutdown: boolean;
    /** Print info logs */
    verbose: boolean;
}
type PluginFactory<ServiceMapIn extends {}, ServiceMapOut extends {}> = (ctx: CommonFrogeContext<ServiceMapIn>) => FrogeServer<ServiceMapOut, any> | Promise<FrogeServer<ServiceMapOut, any>>;
declare class FrogeServer<ServiceMap extends Record<string, any>, ServiceGroups extends Record<string, Record<string, any>>> {
    private map;
    private groups;
    private config;
    private plugins;
    private currentLevel;
    private symbol;
    configure(config: Partial<FrogeConfig>): this;
    readonly services: ServiceMap;
    up<NewServices extends ({
        [T in keyof ServiceMap]?: PlugCallback<T, ServiceMap>;
    } & Record<string, (ctx: FrogeContext<ServiceMap>) => any>), GroupKey extends string | undefined>(services: NewServices, group?: GroupKey): FrogeServer<ServiceMap & UnpackAsyncMap<NewServices>, ServiceGroups & (GroupKey extends string ? (GroupKey extends keyof ServiceGroups ? never : Record<GroupKey, ServiceMap & UnpackAsyncMap<NewServices>>) : {})>;
    down<NewDestroyers extends {
        [T in keyof ServiceMap]?: (service: ServiceMap[T]) => MaybePromise<void>;
    }>(destroyers: NewDestroyers): this;
    use<ServiceMap2 extends {
        [T in keyof ServiceMap]?: never;
    } & Record<string, any>>(other: FrogeServer<ServiceMap2, any> | PluginFactory<ServiceMap, ServiceMap2>, 
    /** Change plugin config to match main instance */
    pushConfig?: boolean): FrogeServer<ServiceMap & ServiceMap2, ServiceGroups>;
    private startPlugins;
    private stopPlugins;
    private startService;
    private stopService;
    private startInternal;
    only<K extends keyof ServiceMap & string>(key: K): Promise<ServiceMap[K]>;
    start(): Promise<this>;
    stop(reasonText?: string): Promise<void>;
    launch(): Promise<this>;
    shutdown(reasonText?: string): Promise<void>;
}
export type { FrogeServer };
export { envHelper as envs };
export type { Plug } from './plug';
export type InferContext<S extends FrogeServer<any, any>, K> = S extends FrogeServer<any, infer G> ? K extends keyof G ? FrogeContext<G[K]> : never : never;
export default function froge(): FrogeServer<{}, {}>;