bknd/dist/types/App.d.ts

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

import type { CreateUserPayload } from "./auth/AppAuth";
import { McpClient } from "bknd/utils";
import { Event } from "./core/events";
import type { em as prototypeEm } from "./data/prototype";
import { Connection } from "./data/connection/Connection";
import type { Hono } from "hono";
import { type ModuleConfigs, type Modules, ModuleManager, type ModuleBuildContext, type ModuleManagerOptions } from "./modules/ModuleManager";
import { AdminController, type AdminControllerOptions } from "./modules/server/AdminController";
import type { MaybePromise, PartialRec } from "./core/types";
import type { ServerEnv } from "./modules/Controller";
import type { IEmailDriver, ICacheDriver } from "./core/drivers";
import { Api, type ApiOptions } from "./Api";
export type AppPluginConfig = {
    /**
     * The name of the plugin.
     */
    name: string;
    /**
     * The schema of the plugin.
     */
    schema?: () => MaybePromise<ReturnType<typeof prototypeEm> | void>;
    /**
     * Called before the app is built.
     */
    beforeBuild?: () => MaybePromise<void>;
    /**
     * Called after the app is built.
     */
    onBuilt?: () => MaybePromise<void>;
    /**
     * Called when the server is initialized.
     */
    onServerInit?: (server: Hono<ServerEnv>) => MaybePromise<void>;
    /**
     * Called when the app is booted.
     */
    onBoot?: () => MaybePromise<void>;
    /**
     * Called when the app is first booted.
     */
    onFirstBoot?: () => MaybePromise<void>;
};
export type AppPlugin = (app: App) => AppPluginConfig;
declare abstract class AppEvent<A = {}> extends Event<{
    app: App;
} & A> {
}
export declare class AppConfigUpdatedEvent extends AppEvent<{
    module: string;
    config: ModuleConfigs[keyof ModuleConfigs];
}> {
    static slug: string;
}
/**
 * @type {Event<{ app: App }>}
 */
export declare class AppBuiltEvent extends AppEvent {
    static slug: string;
}
export declare class AppFirstBoot extends AppEvent {
    static slug: string;
}
export declare class AppRequest extends AppEvent<{
    request: Request;
}> {
    static slug: string;
}
export declare class AppBeforeResponse extends AppEvent<{
    request: Request;
    response: Response;
}> {
    static slug: string;
}
export declare const AppEvents: {
    readonly AppConfigUpdatedEvent: typeof AppConfigUpdatedEvent;
    readonly AppBuiltEvent: typeof AppBuiltEvent;
    readonly AppFirstBoot: typeof AppFirstBoot;
    readonly AppRequest: typeof AppRequest;
    readonly AppBeforeResponse: typeof AppBeforeResponse;
};
export type AppOptions = {
    plugins?: AppPlugin[];
    seed?: (ctx: ModuleBuildContext & {
        app: App;
    }) => Promise<void>;
    manager?: Omit<ModuleManagerOptions, "initial" | "onUpdated" | "seed">;
    asyncEventsMode?: "sync" | "async" | "none";
    drivers?: {
        email?: IEmailDriver;
        cache?: ICacheDriver;
    };
    mode?: "db" | "code";
    readonly?: boolean;
};
export type CreateAppConfig = {
    connection?: Connection | {
        url: string;
    };
    config?: PartialRec<ModuleConfigs>;
    options?: AppOptions;
};
export type AppConfig = {
    version: number;
} & ModuleConfigs;
export type LocalApiOptions = Request | ApiOptions;
export declare class App<C extends Connection = Connection, Config extends PartialRec<ModuleConfigs> = PartialRec<ModuleConfigs>, Options extends AppOptions = AppOptions> {
    connection: C;
    options?: Options | undefined;
    static readonly Events: {
        readonly AppConfigUpdatedEvent: typeof AppConfigUpdatedEvent;
        readonly AppBuiltEvent: typeof AppBuiltEvent;
        readonly AppFirstBoot: typeof AppFirstBoot;
        readonly AppRequest: typeof AppRequest;
        readonly AppBeforeResponse: typeof AppBeforeResponse;
    };
    modules: ModuleManager;
    adminController?: AdminController;
    _id: string;
    plugins: Map<string, AppPluginConfig>;
    drivers: Options["drivers"];
    private trigger_first_boot;
    private _building;
    private _systemController;
    constructor(connection: C, _config?: Config, options?: Options | undefined);
    get mode(): "db" | "code";
    isReadOnly(): boolean;
    get emgr(): import(".").EventManager<any>;
    protected runPlugins<Key extends keyof AppPluginConfig>(key: Key, ...args: any[]): Promise<{
        name: string;
        result: any;
    }[]>;
    build(options?: {
        sync?: boolean;
        forceBuild?: boolean;
        [key: string]: any;
    }): Promise<void>;
    get server(): Hono<ServerEnv, import("hono/types").BlankSchema, "/">;
    get em(): import(".").EntityManager<import(".").DB>;
    get mcp(): import("jsonv-ts/mcp").McpServer<{}, import("jsonv-ts/mcp").Tool<any, any, any, any>[], import("jsonv-ts/mcp").Resource<any, any, any, any>[]> | null | undefined;
    get fetch(): Hono["fetch"];
    get module(): Modules;
    getSchema(): {
        version: number;
    } & import(".").ModuleSchemas;
    version(): number;
    isBuilt(): boolean;
    registerAdminController(config?: AdminControllerOptions): this;
    toJSON(secrets?: boolean): {
        version: number;
    } & ModuleConfigs;
    static create(config: CreateAppConfig): App<Connection<unknown>, PartialRec<ModuleConfigs>, AppOptions>;
    createUser(p: CreateUserPayload): Promise<import(".").Users>;
    getApi(options?: LocalApiOptions): Api;
    getMcpClient(): McpClient;
    onUpdated<Module extends keyof Modules>(module: Module, config: ModuleConfigs[Module]): Promise<void>;
    protected onFirstBoot(): Promise<void>;
    protected onServerInit(server: Hono<ServerEnv>): Promise<void>;
    protected onModulesBuilt(ctx: ModuleBuildContext): Promise<void>;
}
export declare function createApp(config?: CreateAppConfig): App<Connection<unknown>, PartialRec<ModuleConfigs>, AppOptions>;
export {};