@warlock.js/cascade 4.0.162 → 4.0.164

package/esm/types.d.ts

@@ -0,0 +1,371 @@
+/**
+ * Strict mode configuration for handling unknown fields during validation.
+ *
+ * Controls how the model behaves when encountering fields not defined in the schema.
+ *
+ * - `"strip"` - Remove unknown fields silently (default, recommended for APIs)
+ * - `"fail"` - Throw validation error on unknown fields (strict validation)
+ * - `"allow"` - Allow unknown fields to pass through (permissive)
+ *
+ * @example
+ * ```typescript
+ * import { Model, type StrictMode } from "@warlock.js/cascade";
+ *
+ * class User extends Model {
+ *   public static strictMode: StrictMode = "fail";
+ * }
+ * ```
+ */
+export type StrictMode = "strip" | "fail" | "allow";
+/**
+ * Delete strategy for model destruction.
+ *
+ * Controls how models are deleted from the database:
+ *
+ * - `"trash"` - Moves document to a trash/recycle bin collection, then deletes
+ * - `"permanent"` - Actually deletes the document from the database (hard delete)
+ * - `"soft"` - Sets a `deletedAt` timestamp instead of deleting (soft delete)
+ *
+ * Priority order (highest to lowest):
+ * 1. destroy() method options
+ * 2. Model static property (deleteStrategy)
+ * 3. Data source default configuration
+ *
+ * @example
+ * ```typescript
+ * class User extends Model {
+ *   public static deleteStrategy: DeleteStrategy = "soft";
+ * }
+ *
+ * // Override at call time
+ * await user.destroy({ strategy: "permanent" });
+ * ```
+ */
+export type DeleteStrategy = "trash" | "permanent" | "soft";
+/**
+ * Naming convention for database column names.
+ *
+ * Different databases have different naming conventions:
+ * - `"camelCase"` - MongoDB standard (createdAt, updatedAt, deletedAt)
+ * - `"snake_case"` - PostgreSQL/MySQL standard (created_at, updated_at, deleted_at)
+ *
+ * This affects default column names for timestamps and other system columns.
+ *
+ * @example
+ * ```typescript
+ * // PostgreSQL driver defaults
+ * namingConvention: "snake_case"
+ * // Results in: created_at, updated_at, deleted_at
+ *
+ * // MongoDB driver defaults
+ * namingConvention: "camelCase"
+ * // Results in: createdAt, updatedAt, deletedAt
+ * ```
+ */
+export type NamingConvention = "camelCase" | "snake_case";
+/**
+ * Unified model default configuration.
+ *
+ * These settings define default behaviors for models. The configuration
+ * follows a 4-tier hierarchy (highest to lowest precedence):
+ *
+ * 1. Model static property (explicit override)
+ * 2. Database config modelDefaults
+ * 3. Driver defaults (SQL vs NoSQL conventions)
+ * 4. Framework defaults (fallback values)
+ *
+ * @example
+ * ```typescript
+ * // PostgreSQL driver provides defaults:
+ * const postgresDefaults: ModelDefaults = {
+ *   namingConvention: "snake_case",
+ *   createdAtColumn: "created_at",
+ *   updatedAtColumn: "updated_at",
+ *   deletedAtColumn: "deleted_at",
+ *   timestamps: true,
+ *   autoGenerateId: false, // SQL handles this
+ * };
+ *
+ * // Override in database config:
+ * {
+ *   modelDefaults: {
+ *     randomIncrement: true,
+ *     initialId: 1000,
+ *     deleteStrategy: "soft",
+ *   }
+ * }
+ *
+ * // Override in specific model:
+ * class User extends Model {
+ *   public static createdAtColumn = "creation_date"; // Highest priority
+ *   public static updatedAtColumn = false; // Disable updatedAt
+ * }
+ * ```
+ */
+export type ModelDefaults = {
+    /**
+     * Auto-generate incremental `id` field on insert (NoSQL only).
+     *
+     * When enabled, the ID generator creates a sequential integer ID
+     * separate from the database's native ID (_id for MongoDB).
+     *
+     * **Note:** SQL databases use native AUTO_INCREMENT and don't need this.
+     *
+     * @default true (MongoDB), false (PostgreSQL)
+     */
+    autoGenerateId?: boolean;
+    /**
+     * Initial ID value for the first record.
+     *
+     * @default 1
+     *
+     * @example
+     * ```typescript
+     * initialId: 1000 // Start from 1000
+     * ```
+     */
+    initialId?: number;
+    /**
+     * Randomly generate the initial ID.
+     *
+     * Can be:
+     * - `true`: Generate random ID between 10000-499999
+     * - Function: Custom random ID generator
+     * - `false`: Use `initialId` or default to 1
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * randomInitialId: true // Random 10000-499999
+     * randomInitialId: () => Math.floor(Math.random() * 1000000)
+     * ```
+     */
+    randomInitialId?: boolean | (() => number);
+    /**
+     * Amount to increment ID by for each new record.
+     *
+     * @default 1
+     *
+     * @example
+     * ```typescript
+     * incrementIdBy: 5 // Increment by 5
+     * ```
+     */
+    incrementIdBy?: number;
+    /**
+     * Randomly generate the increment amount.
+     *
+     * Can be:
+     * - `true`: Generate random increment between 1-10
+     * - Function: Custom random increment generator
+     * - `false`: Use `incrementIdBy` or default to 1
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * randomIncrement: true // Random 1-10
+     * randomIncrement: () => Math.floor(Math.random() * 100)
+     * ```
+     */
+    randomIncrement?: boolean | (() => number);
+    /**
+     * Enable/disable automatic timestamp management.
+     *
+     * When enabled, createdAt and updatedAt are automatically managed.
+     * When disabled, no timestamps are added.
+     *
+     * @default true
+     */
+    timestamps?: boolean;
+    /**
+     * Column name for creation timestamp.
+     *
+     * Set to `false` to disable createdAt entirely.
+     *
+     * @default "createdAt" (MongoDB), "created_at" (PostgreSQL)
+     *
+     * @example
+     * ```typescript
+     * createdAtColumn: "creation_date"
+     * createdAtColumn: false // Disable
+     * ```
+     */
+    createdAtColumn?: string | false;
+    /**
+     * Column name for update timestamp.
+     *
+     * Set to `false` to disable updatedAt entirely.
+     *
+     * @default "updatedAt" (MongoDB), "updated_at" (PostgreSQL)
+     *
+     * @example
+     * ```typescript
+     * updatedAtColumn: "last_modified"
+     * updatedAtColumn: false // Disable
+     * ```
+     */
+    updatedAtColumn?: string | false;
+    /**
+     * Delete strategy for this model.
+     *
+     * Controls how models are deleted:
+     * - `"trash"` - Moves to trash collection, then deletes
+     * - `"permanent"` - Direct deletion (hard delete)
+     * - `"soft"` - Sets deletedAt timestamp (soft delete)
+     *
+     * @default "permanent"
+     *
+     * @example
+     * ```typescript
+     * deleteStrategy: "soft"
+     * ```
+     */
+    deleteStrategy?: DeleteStrategy;
+    /**
+     * Column name for soft delete timestamp.
+     *
+     * Used when delete strategy is "soft".
+     * Set to `false` to use a different mechanism.
+     *
+     * @default "deletedAt" (MongoDB), "deleted_at" (PostgreSQL)
+     *
+     * @example
+     * ```typescript
+     * deletedAtColumn: "archived_at"
+     * ```
+     */
+    deletedAtColumn?: string | false;
+    /**
+     * Trash table/collection name override.
+     *
+     * Can be:
+     * - String: Fixed name for all models
+     * - Function: Generate trash table name based on model table
+     * - `undefined`: Use default pattern `{table}Trash`
+     *
+     * Used when delete strategy is "trash".
+     *
+     * @default undefined (uses {table}Trash pattern)
+     *
+     * @example
+     * ```typescript
+     * trashTable: "RecycleBin" // All models use same trash
+     * trashTable: (table) => `archive_${table}` // Dynamic naming
+     * ```
+     */
+    trashTable?: string | ((tableName: string) => string);
+    /**
+     * Strict mode behavior for unknown fields.
+     *
+     * - `"strip"`: Remove unknown fields silently (default)
+     * - `"fail"`: Throw validation error on unknown fields
+     * - `"allow"`: Allow unknown fields to pass through
+     *
+     * @default "strip"
+     *
+     * @example
+     * ```typescript
+     * strictMode: "fail" // Strict validation
+     * ```
+     */
+    strictMode?: StrictMode;
+    /**
+     * Naming convention for database column names.
+     *
+     * Affects default names for timestamps and other system columns.
+     *
+     * @default "camelCase" (MongoDB), "snake_case" (PostgreSQL)
+     *
+     * @example
+     * ```typescript
+     * namingConvention: "snake_case"
+     * // Results in: created_at, updated_at, deleted_at
+     * ```
+     */
+    namingConvention?: NamingConvention;
+};
+/**
+ * UUID generation strategy for primary keys.
+ *
+ * Each driver maps this to its native expression:
+ * - `"v4"`: PG → `gen_random_uuid()` (PG 13+), MySQL → `UUID()`
+ * - `"v7"`: PG → `uuid_generate_v7()` (PG 18+)
+ *
+ * @example
+ * ```typescript
+ * // In database config
+ * migrationDefaults: {
+ *   uuidStrategy: "v7", // Use UUID v7 (PG 18+)
+ * }
+ * ```
+ */
+export type UuidStrategy = "v4" | "v7";
+/**
+ * Migration-level defaults configurable per data source.
+ *
+ * These settings affect DDL operations (schema changes) and are
+ * separate from runtime model behavior (`ModelDefaults`).
+ *
+ * The configuration follows a 3-tier hierarchy (highest to lowest):
+ * 1. Inline migration call (explicit `.default("...")`)
+ * 2. DataSource `migrationDefaults` (this type)
+ * 3. Driver migration defaults (e.g., PG defaults to v4)
+ *
+ * @example
+ * ```typescript
+ * // Use UUID v7 for all migrations on this data source
+ * migrationDefaults: {
+ *   uuidStrategy: "v7",
+ * }
+ *
+ * // Use a custom UUID extension
+ * migrationDefaults: {
+ *   uuidExpression: "uuid_generate_v1mc()",
+ * }
+ * ```
+ */
+export type MigrationDefaults = {
+    /**
+     * UUID generation strategy for `primaryUuid()` migration shortcut.
+     * Each driver maps this to its native SQL/expression.
+     *
+     * @default "v4"
+     */
+    uuidStrategy?: UuidStrategy;
+    /**
+     * Raw SQL/expression override for UUID generation.
+     * Takes precedence over `uuidStrategy` when set.
+     *
+     * Use for custom extensions (e.g., `uuid-ossp`, `pgcrypto`)
+     * or non-standard UUID generation functions.
+     *
+     * @example "uuid_generate_v1mc()"
+     */
+    uuidExpression?: string;
+    /**
+     * Default primary key type for `Migration.create()`.
+     *
+     * Controls which primary key column is automatically added when using
+     * the declarative `Migration.create()` factory. Individual migrations
+     * can still override this by passing `{ primaryKey: false }` in options.
+     *
+     * - `"uuid"` — UUID primary key via `primaryUuid()` (default for PostgreSQL)
+     * - `"int"` — Auto-increment integer via `id()`
+     * - `"bigInt"` — Big auto-increment integer via `bigId()`
+     *
+     * @default "int"
+     *
+     * @example
+     * ```typescript
+     * // src/config/database.ts
+     * migrationOptions: {
+     *   uuidStrategy: "v7",
+     *   primaryKey: "uuid",
+     * }
+     * ```
+     */
+    primaryKey?: "uuid" | "int" | "bigInt";
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,WAAW,GAAG,MAAM,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,aAAa,GAAG;IAK1B;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IAE3C;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IAM3C;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAEjC;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAMjC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAEjC;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAMtD;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IAMxB;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAMF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;CACxC,CAAC"}

package/esm/utils/connect-to-database.d.ts

@@ -0,0 +1,307 @@
+import { DriverContract, TransactionContext } from "../contracts";
+import { DataSource } from "../data-source/data-source";
+import type { DeleteStrategy, MigrationDefaults, ModelDefaults } from "../types";
+/**
+ * Supported database driver types.
+ */
+export type DatabaseDriver = "mongodb" | "postgres" | "mysql";
+/**
+ * Default model configuration options.
+ *
+ * These settings will be applied to all models using this data source,
+ * unless overridden by individual model static properties.
+ *
+ * This is a re-export of Partial<ModelDefaults> for backward compatibility
+ * and to provide clearer naming in the connection config context.
+ *
+ * The full hierarchy is:
+ * 1. Model static property (highest priority)
+ * 2. Database config modelDefaults (this type)
+ * 3. Driver defaults (e.g., snake_case for PostgreSQL, camelCase for MongoDB)
+ * 4. Framework defaults (fallback values)
+ *
+ * @see ModelDefaults for complete type definition and documentation
+ */
+export type ModelDefaultConfig = Partial<ModelDefaults>;
+/**
+ * Connection options for establishing a database connection.
+ *
+ * Generic type that separates concerns:
+ * - Shared config (driver, name, database, connection details)
+ * - Driver options (cascade-next driver-specific settings)
+ * - Client options (native database client settings)
+ * - Model options (default model behaviors)
+ *
+ * @template TDriverOptions - Driver-specific options (e.g., MongoDriverOptions)
+ * @template TClientOptions - Native client options (e.g., MongoClientOptions from mongodb package)
+ *
+ * @example
+ * ```typescript
+ * // MongoDB
+ * import type { MongoClientOptions } from "mongodb";
+ * import type { MongoDriverOptions } from "@warlock.js/cascade";
+ *
+ * const config: ConnectionOptions<MongoDriverOptions, MongoClientOptions> = {
+ *   driver: "mongodb",
+ *   database: "myapp",
+ *   host: "localhost",
+ *   port: 27017,
+ *   driverOptions: {
+ *     autoGenerateId: true,
+ *     counterCollection: "counters",
+ *   },
+ *   clientOptions: {
+ *     minPoolSize: 5,
+ *     maxPoolSize: 10,
+ *   },
+ *   modelOptions: {
+ *     randomIncrement: true,
+ *     initialId: 1000,
+ *   },
+ * };
+ * ```
+ */
+export type ConnectionOptions<TDriverOptions = any, TClientOptions = any> = {
+    /**
+     * Database driver to use.
+     * @default "mongodb"
+     */
+    driver?: DatabaseDriver;
+    /**
+     * Unique name for this data source.
+     * Used for registration in DataSourceRegistry.
+     * @default "default"
+     */
+    name?: string;
+    /**
+     * Whether this should be the default data source.
+     * @default true
+     */
+    isDefault?: boolean;
+    /**
+     * Database name (required).
+     */
+    database: string;
+    /**
+     * Enable database operation logging (queries, execution time, parameters).
+     * Highly recommended to keep this disabled in production to prevent sensitive data leakage.
+     *
+     * @default false
+     */
+    logging?: boolean;
+    /**
+     * Database connection URI.
+     * Alternative to specifying host/port separately.
+     *
+     * @example "mongodb://localhost:27017/mydb"
+     * @example "postgresql://user:pass@localhost:5432/mydb"
+     */
+    uri?: string;
+    /**
+     * Database host.
+     * @default "localhost"
+     */
+    host?: string;
+    /**
+     * Database port.
+     * @default 27017 (MongoDB), 5432 (PostgreSQL)
+     */
+    port?: number;
+    /**
+     * Database username for authentication.
+     */
+    username?: string;
+    /**
+     * Database password for authentication.
+     */
+    password?: string;
+    /**
+     * Authentication source database.
+     * Typically "admin" for MongoDB.
+     */
+    authSource?: string;
+    /**
+     * Driver-specific options.
+     *
+     * For MongoDB: { autoGenerateId, counterCollection, transactionOptions }
+     * For PostgreSQL: { schema, ... }
+     */
+    driverOptions?: TDriverOptions;
+    /**
+     * Native database client options.
+     *
+     * For MongoDB: MongoClientOptions from 'mongodb' package
+     * For PostgreSQL: PoolConfig from 'pg' package
+     */
+    clientOptions?: TClientOptions;
+    /**
+     * Default model configuration for all models using this data source.
+     *
+     * These settings override driver defaults but are overridden by
+     * individual model static properties.
+     *
+     * **Configuration Hierarchy (highest to lowest):**
+     * 1. Model static property - `User.createdAtColumn = "creation_date"`
+     * 2. **modelOptions (this)** - Database-wide overrides
+     * 3. Driver defaults - PostgreSQL: snake_case, MongoDB: camelCase
+     * 4. Framework defaults - Fallback values
+     *
+     * @example
+     * ```typescript
+     * // PostgreSQL database with custom settings
+     * {
+     *   driver: "postgres",
+     *   modelOptions: {
+     *     // Override PostgreSQL default (snake_case) to use camelCase
+     *     namingConvention: "camelCase",
+     *     createdAtColumn: "createdAt",
+     *     updatedAtColumn: "updatedAt",
+     *
+     *     // ID generation settings (for MongoDB)
+     *     randomIncrement: true,
+     *     initialId: 1000,
+     *
+     *     // Deletion settings
+     *     deleteStrategy: "soft",
+     *     trashTable: "archive", // All models use same trash table
+     *   }
+     * }
+     *
+     * // MongoDB database with defaults
+     * {
+     *   driver: "mongodb",
+     *   modelOptions: {
+     *     // MongoDB already uses camelCase by default
+     *     randomIncrement: true,
+     *     initialId: 10000,
+     *     deleteStrategy: "trash", // Use RecycleBin
+     *   }
+     * }
+     * ```
+     */
+    modelOptions?: ModelDefaultConfig;
+    /**
+     * Migration-level defaults (UUID strategy, etc.).
+     *
+     * These defaults override driver migration defaults but can be
+     * overridden by individual migration calls.
+     *
+     * @default undefined (uses driver defaults)
+     *
+     * @example
+     * ```typescript
+     * migrationDefaults: {
+     *   uuidStrategy: "v7", // Use UUID v7 for all migrations
+     * }
+     * ```
+     */
+    migrationOptions?: MigrationDefaults;
+    /**
+     * Default delete strategy for models using this data source.
+     *
+     * - MongoDB: Typically `"trash"` (uses RecycleBin collection)
+     * - PostgreSQL: Typically `"permanent"` or `"soft"`
+     *
+     * Can be overridden by model static property or destroy() options.
+     *
+     * @default undefined (falls back to "permanent")
+     */
+    defaultDeleteStrategy?: DeleteStrategy;
+    /**
+     * Default trash table/collection name for "trash" delete strategy.
+     *
+     * - MongoDB: Typically `"RecycleBin"`
+     * - If not set, defaults to `{table}Trash` pattern
+     *
+     * Can be overridden by Model.trashTable static property.
+     *
+     * @default undefined (uses {table}Trash pattern)
+     */
+    defaultTrashTable?: string;
+    /**
+     * Migration configuration options.
+     */
+    migrations?: {
+        /**
+         * Whether to wrap migrations in database transactions.
+         *
+         * Overrides driver defaults:
+         * - PostgreSQL default: `true` (DDL is transactional)
+         * - MongoDB default: `false` (DDL cannot be transactional)
+         *
+         * Individual migrations can override this with their own `transactional` property.
+         *
+         * @default undefined (uses driver default)
+         */
+        transactional?: boolean;
+        /**
+         * Name of the migrations tracking table/collection.
+         *
+         * @default "_migrations"
+         */
+        table?: string;
+    };
+};
+/**
+ * Connect to a database and register the data source.
+ *
+ * This is a high-level utility function that simplifies database connection
+ * for small to medium projects. It handles driver instantiation, connection,
+ * data source creation, and automatic registration.
+ *
+ * **Supported Drivers:**
+ * - `mongodb` (default) - MongoDB driver with optional auto ID generation
+ * - `postgres` - PostgreSQL driver (not yet implemented)
+ * - `mysql` - MySQL driver (not yet implemented)
+ *
+ * **Features:**
+ * - Automatic driver instantiation based on driver name
+ * - Connection establishment and error handling
+ * - DataSource creation and registration
+ * - Support for MongoDB-specific features (ID generation, transactions)
+ *
+ * @param options - Connection configuration options
+ * @returns A connected and registered DataSource instance
+ * @throws {Error} If connection fails or driver is not implemented
+ *
+ * @example
+ * ```typescript
+ * // MongoDB with new structure
+ * const dataSource = await connectToDatabase({
+ *   driver: "mongodb",
+ *   database: "myapp",
+ *   host: "localhost",
+ *   port: 27017,
+ *   driverOptions: {
+ *     autoGenerateId: true,
+ *   },
+ *   clientOptions: {
+ *     minPoolSize: 5,
+ *     maxPoolSize: 10,
+ *   },
+ *   modelOptions: {
+ *     randomIncrement: true,
+ *     initialId: 1000,
+ *   },
+ * });
+ * ```
+ */
+export declare function connectToDatabase<TDriverOptions = any, TClientOptions = any>(options: ConnectionOptions<TDriverOptions, TClientOptions>): Promise<DataSource>;
+/**
+ * Get current driver instance.
+ *
+ * @example
+ * ```typescript
+ * const driver = getDatabaseDriver();
+ *
+ * // Pass type to return Postgres driver type
+ * const pgDriver = getDatabaseDriver<PostgresDriver>();
+ * ```
+ */
+export declare function getDatabaseDriver<T extends DriverContract = any>(): T;
+/**
+ * Perform database transaction(s)
+ * Shorthand to `dataSourceRegister.get().driver.transaction
+ */
+export declare function transaction<T = any>(fn: (ctx: TransactionContext) => Promise<T>, options?: Record<string, unknown>): Promise<T>;
+//# sourceMappingURL=connect-to-database.d.ts.map

package/esm/utils/connect-to-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-to-database.d.ts","sourceRoot":"","sources":["../../src/utils/connect-to-database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAIxD,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEjF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,iBAAiB,CAAC,cAAc,GAAG,GAAG,EAAE,cAAc,GAAG,GAAG,IAAI;IAK1E;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;IAExB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAMlB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAMpB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;IAM/B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;IAM/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAElC;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IAMrC;;;;;;;;;OASG;IACH,qBAAqB,CAAC,EAAE,cAAc,CAAC;IAEvC;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAM3B;;OAEG;IACH,UAAU,CAAC,EAAE;QACX;;;;;;;;;;WAUG;QACH,aAAa,CAAC,EAAE,OAAO,CAAC;QAExB;;;;WAIG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,iBAAiB,CAAC,cAAc,GAAG,GAAG,EAAE,cAAc,GAAG,GAAG,EAChF,OAAO,EAAE,iBAAiB,CAAC,cAAc,EAAE,cAAc,CAAC,GACzD,OAAO,CAAC,UAAU,CAAC,CA+ErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,cAAc,GAAG,GAAG,KAAK,CAAC,CAIrE;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,EAAE,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,EAC3C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,CAAC,CAAC,CAEZ"}