@warlock.js/cascade/esm/database.d.ts

ORM for managing databases

/// <reference types="node" />
import { AsyncLocalStorage } from "async_hooks";
import type { ClientSession, ClientSessionOptions, Collection, Db, Document } from "mongodb";
import type { Connection } from "./connection";
export type DatabaseSessionTransaction = {
    session: ClientSession;
    database: Database;
};
export type DatabaseTransactionCallbackOptions = {
    rollback: symbol;
    commit: symbol;
    session: ClientSession;
};
export type DatabaseTransactionCallback = (options: DatabaseTransactionCallbackOptions) => Promise<symbol | void>;
export declare class Database {
    /**
     * MongoDB Internal Database instance
     */
    database: Db;
    /**
     * Current Connection
     */
    connection: Connection;
    sessionsContainer: AsyncLocalStorage<DatabaseSessionTransaction>;
    /**
     * Execute operations within a transaction (automatic commit/rollback)
     *
     * This is the recommended method for most use cases.
     * Automatically commits on success, rolls back on errors.
     *
     * @example
     * const user = await database.transaction(async (session) => {
     *   const user = await User.create({ name: "John" }, { session });
     *   const order = await Order.create({ userId: user.id }, { session });
     *   return user; // Auto commits on success
     * });
     */
    transaction<T>(callback: (session: ClientSession) => Promise<T>, sessionOptions?: ClientSessionOptions): Promise<T>;
    /**
     * Start a transaction with manual control
     *
     * Use this when you need explicit control over commit/rollback based on business logic.
     * Returns true if committed, false if rolled back.
     *
     * @example
     * const committed = await database.startTransaction(async ({ session, commit, rollback }) => {
     *   const user = await User.create({ name: "John" }, { session });
     *   const order = await Order.create({ userId: user.id }, { session });
     *
     *   // Conditional rollback based on business logic
     *   if (order.total > 10000) {
     *     console.log("Order too large, rolling back");
     *     return rollback; // Explicit rollback
     *   }
     *
     *   if (user.isBanned) {
     *     console.log("User banned, rolling back");
     *     return rollback; // Explicit rollback
     *   }
     *
     *   return commit; // Explicit commit
     * });
     *
     * if (committed) {
     *   console.log("Transaction committed successfully");
     * } else {
     *   console.log("Transaction was rolled back");
     * }
     */
    startTransaction(callback: DatabaseTransactionCallback, sessionOptions?: ClientSessionOptions): Promise<boolean>;
    /**
     * Get active session
     */
    getActiveSession(): DatabaseSessionTransaction;
    /**
     * Set connection instance
     */
    setConnection(connection: Connection): this;
    /**
     * Set database instance
     */
    setDatabase(database: Db): this;
    /**
     * Get database collection instance
     */
    collection<TSchema extends Document = Document>(collection: string): Collection<TSchema>;
    /**
     * List collection names
     */
    listCollectionNames(): Promise<any>;
    /**
     * Drop database
     */
    drop(): Promise<any>;
}
export declare const database: Database;
//# sourceMappingURL=database.d.ts.map