bknd/dist/types/modules/ModuleManager.d.ts

Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.

import { type s } from "bknd/utils";
import { DebugLogger } from "../core/utils/DebugLogger";
import { Guard } from "../auth/authorize/Guard";
import { EventManager, Event } from "../core/events";
import type { Connection } from "../data/connection";
import { EntityManager } from "../data/entities/EntityManager";
import { Hono } from "hono";
import type { ServerEnv } from "./Controller";
import { type ModuleBuildContext } from "./Module";
import { AppServer } from "../modules/server/AppServer";
import { AppAuth } from "../auth/AppAuth";
import { AppData } from "../data/AppData";
import { AppFlows } from "../flows/AppFlows";
import { AppMedia } from "../media/AppMedia";
import type { PartialRec } from "../core/types";
export type { ModuleBuildContext };
export declare const MODULES: {
    readonly server: typeof AppServer;
    readonly data: typeof AppData;
    readonly auth: typeof AppAuth;
    readonly media: typeof AppMedia;
    readonly flows: typeof AppFlows;
};
export declare const MODULE_NAMES: ModuleKey[];
export type ModuleKey = keyof typeof MODULES;
export type Modules = {
    [K in keyof typeof MODULES]: InstanceType<(typeof MODULES)[K]>;
};
export type ModuleSchemas = {
    [K in keyof typeof MODULES]: ReturnType<(typeof MODULES)[K]["prototype"]["getSchema"]>;
};
export type ModuleConfigs = {
    [K in keyof ModuleSchemas]: s.Static<ModuleSchemas[K]>;
};
export type InitialModuleConfigs = {
    version?: number;
} & PartialRec<ModuleConfigs>;
declare enum Verbosity {
    silent = 0,
    error = 1,
    log = 2
}
export type ModuleManagerOptions = {
    initial?: InitialModuleConfigs;
    eventManager?: EventManager<any>;
    onUpdated?: <Module extends keyof Modules>(module: Module, config: ModuleConfigs[Module]) => Promise<void>;
    onFirstBoot?: () => Promise<void>;
    basePath?: string;
    onServerInit?: (server: Hono<ServerEnv>) => void;
    skipValidation?: boolean;
    seed?: (ctx: ModuleBuildContext) => Promise<void>;
    onModulesBuilt?: (ctx: ModuleBuildContext) => Promise<void>;
    storeSecrets?: boolean;
    secrets?: Record<string, any>;
    /** @deprecated */
    verbosity?: Verbosity;
};
declare abstract class ModuleManagerEvent<A = {}> extends Event<{
    ctx: ModuleBuildContext;
} & A> {
}
export declare class ModuleManagerConfigUpdateEvent<Module extends keyof ModuleConfigs> extends ModuleManagerEvent<{
    module: Module;
    config: ModuleConfigs[Module];
}> {
    static slug: string;
}
export declare class ModuleManagerSecretsExtractedEvent extends ModuleManagerEvent<{
    secrets: Record<string, any>;
}> {
    static slug: string;
}
export declare const ModuleManagerEvents: {
    ModuleManagerConfigUpdateEvent: typeof ModuleManagerConfigUpdateEvent;
    ModuleManagerSecretsExtractedEvent: typeof ModuleManagerSecretsExtractedEvent;
};
export declare class ModuleManager {
    protected readonly connection: Connection;
    options?: Partial<ModuleManagerOptions> | undefined;
    static Events: {
        ModuleManagerConfigUpdateEvent: typeof ModuleManagerConfigUpdateEvent;
        ModuleManagerSecretsExtractedEvent: typeof ModuleManagerSecretsExtractedEvent;
    };
    protected modules: Modules;
    em: EntityManager;
    server: Hono<ServerEnv>;
    emgr: EventManager;
    guard: Guard;
    mcp: ModuleBuildContext["mcp"];
    protected _built: boolean;
    protected logger: DebugLogger;
    constructor(connection: Connection, options?: Partial<ModuleManagerOptions> | undefined);
    protected onModuleConfigUpdated(key: string, config: any): void;
    private createModules;
    private get verbosity();
    isBuilt(): boolean;
    protected rebuildServer(): void;
    ctx(rebuild?: boolean): ModuleBuildContext;
    extractSecrets(): {
        configs: any;
        secrets: Pick<{
            [x: string]: any;
        }, string>;
        extractedKeys: string[];
    };
    protected setConfigs(configs: ModuleConfigs): Promise<void>;
    build(opts?: any): Promise<this>;
    protected buildModules(options?: {
        graceful?: boolean;
        ignoreFlags?: boolean;
        drop?: boolean;
    }): Promise<{
        built: boolean;
        modules: ModuleKey[];
        synced: boolean;
        saved: boolean;
        reloaded: boolean;
    }>;
    get<K extends keyof Modules>(key: K): Modules[K];
    version(): number;
    built(): boolean;
    configs(): ModuleConfigs;
    getSchema(): {
        version: number;
    } & ModuleSchemas;
    toJSON(secrets?: boolean): {
        version: number;
    } & ModuleConfigs;
}
export declare function getDefaultSchema(): any;
export declare function getDefaultConfig(): ModuleConfigs;