@warlock.js/cascade 4.0.48 → 4.0.58

package/esm/utils/connect-to-database.js

@@ -0,0 +1,92 @@
+import {DataSource}from'../data-source/data-source.js';import {dataSourceRegistry}from'../data-source/data-source-registry.js';import {MongoDbDriver}from'../drivers/mongo/mongodb-driver.js';/**
+ * 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,
+ *   },
+ * });
+ * ```
+ */
+async function connectToDatabase(options) {
+    // Default values
+    const driverType = options.driver ?? "mongodb";
+    const dataSourceName = options.name ?? "default";
+    const isDefault = options.isDefault ?? true;
+    // Create driver based on type
+    let driver;
+    switch (driverType) {
+        case "mongodb": {
+            driver = new MongoDbDriver({
+                database: options.database,
+                uri: options.uri,
+                host: options.host,
+                port: options.port,
+                username: options.username,
+                password: options.password,
+                authSource: options.authSource,
+                clientOptions: options.clientOptions,
+            }, options.driverOptions);
+            break;
+        }
+        case "postgres":
+            throw new Error("PostgreSQL driver is not yet implemented. Coming soon!");
+        case "mysql":
+            throw new Error("MySQL driver is not yet implemented. Coming soon!");
+        default:
+            throw new Error(`Unknown driver: "${driverType}". Supported drivers: mongodb, postgres, mysql`);
+    }
+    // Create data source
+    const dataSource = new DataSource({
+        name: dataSourceName,
+        driver,
+        isDefault,
+        defaultDeleteStrategy: options.defaultDeleteStrategy,
+        defaultTrashTable: options.defaultTrashTable,
+        modelDefaults: options.modelOptions,
+    });
+    // Register data source
+    dataSourceRegistry.register(dataSource);
+    // Connect to the database
+    try {
+        await driver.connect();
+    }
+    catch (error) {
+        throw new Error(`Failed to connect to ${driverType} database: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return dataSource;
+}export{connectToDatabase};//# sourceMappingURL=connect-to-database.js.map

package/esm/utils/connect-to-database.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-to-database.js","sources":["../../src/utils/connect-to-database.ts"],"sourcesContent":[null],"names":[],"mappings":"8LA0PA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,eAAe,iBAAiB,CACrC,OAA0D,EAAA;;AAG1D,IAAA,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,IAAI,SAAS,CAAC;AAC/C,IAAA,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,IAAI,SAAS,CAAC;AACjD,IAAA,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC;;AAG5C,IAAA,IAAI,MAAsB,CAAC;AAE3B,IAAA,QAAQ,UAAU;QAChB,KAAK,SAAS,EAAE;YACd,MAAM,GAAG,IAAI,aAAa,CACxB;gBACE,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,aAAa,EAAE,OAAO,CAAC,aAAoB;AAC5C,aAAA,EACD,OAAO,CAAC,aAAoB,CAC7B,CAAC;YACF,MAAM;AACP,SAAA;AAED,QAAA,KAAK,UAAU;AACb,YAAA,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;AAE5E,QAAA,KAAK,OAAO;AACV,YAAA,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;AAEvE,QAAA;AACE,YAAA,MAAM,IAAI,KAAK,CACb,oBAAoB,UAAU,CAAA,8CAAA,CAAgD,CAC/E,CAAC;AACL,KAAA;;AAGD,IAAA,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC;AAChC,QAAA,IAAI,EAAE,cAAc;QACpB,MAAM;QACN,SAAS;QACT,qBAAqB,EAAE,OAAO,CAAC,qBAAqB;QACpD,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;QAC5C,aAAa,EAAE,OAAO,CAAC,YAAY;AACpC,KAAA,CAAC,CAAC;;AAGH,IAAA,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;;IAGxC,IAAI;AACF,QAAA,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;AACxB,KAAA;AAAC,IAAA,OAAO,KAAK,EAAE;QACd,MAAM,IAAI,KAAK,CACb,CAAwB,qBAAA,EAAA,UAAU,cAAc,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAE,CAAA,CACzG,CAAC;AACH,KAAA;AAED,IAAA,OAAO,UAAU,CAAC;AACpB"}

package/esm/utils/database-writer.utils.d.ts

@@ -0,0 +1,15 @@
+import { type Model } from "../model/model";
+type transformCallbackOptions = {
+    model: Model;
+    column: string;
+    value: any;
+    isChanged: boolean;
+    isNew: boolean;
+};
+type ModelTransformCallback = (options: transformCallbackOptions) => string;
+/**
+ * Transfer value before saving it into the database
+ */
+export declare function useModelTransformer(callback: ModelTransformCallback): TransformerCallback;
+export {};
+//# sourceMappingURL=database-writer.utils.d.ts.map

package/esm/utils/database-writer.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer.utils.d.ts","sourceRoot":"","sources":["../../src/utils/database-writer.utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,GAAG,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,KAAK,sBAAsB,GAAG,CAAC,OAAO,EAAE,wBAAwB,KAAK,MAAM,CAAC;AAE5E;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,sBAAsB,uBAWnE"}

package/esm/utils/database-writer.utils.js

@@ -0,0 +1,14 @@
+/**
+ * Transfer value before saving it into the database
+ */
+function useModelTransformer(callback) {
+    const transformCallback = (data, { context }) => {
+        const model = context.rootContext?.model;
+        const column = context.key;
+        const value = data;
+        const isChanged = model.isDirty(column);
+        const isNew = model.isNew;
+        return callback({ model, column, value, isChanged, isNew });
+    };
+    return transformCallback;
+}export{useModelTransformer};//# sourceMappingURL=database-writer.utils.js.map

package/esm/utils/database-writer.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer.utils.js","sources":["../../src/utils/database-writer.utils.ts"],"sourcesContent":[null],"names":[],"mappings":"AAaA;;AAEG;AACG,SAAU,mBAAmB,CAAC,QAAgC,EAAA;IAClE,MAAM,iBAAiB,GAAwB,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,KAAI;AACnE,QAAA,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,EAAE,KAAc,CAAC;AAClD,QAAA,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC;QACnB,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AACxC,QAAA,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;AAC1B,QAAA,OAAO,QAAQ,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;AAC9D,KAAC,CAAC;AAEF,IAAA,OAAO,iBAAiB,CAAC;AAC3B"}

package/esm/utils/define-model.js

@@ -0,0 +1,100 @@
+import {Model}from'../model/model.js';import {registerModelInRegistry}from'../model/register-model.js';/**
+ * Define a model with a clean, concise API.
+ *
+ * This utility function creates a Model class with the specified configuration,
+ * reducing boilerplate and providing a more declarative way to define models.
+ *
+ * @param options - Model configuration options
+ * @returns A Model class with the specified configuration
+ *
+ * @example
+ * ```typescript
+ * import { defineModel } from "@warlock.js/cascade";
+ * import { v } from "@warlock.js/seal";
+ *
+ * export const User = defineModel({
+ *   table: "users",
+ *   schema: v.object({
+ *     name: v.string().required().trim(),
+ *     email: v.string().email().required().lowercase(),
+ *     password: v.string().required().min(6),
+ *     role: v.string().default("user"),
+ *   }),
+ *   deleteStrategy: "soft",
+ * });
+ *
+ * // Usage
+ * const user = await User.create({
+ *   name: "John Doe",
+ *   email: "john@example.com",
+ *   password: "secret123",
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With type inference
+ * export const Post = defineModel({
+ *   table: "posts",
+ *   schema: v.object({
+ *     title: v.string().required(),
+ *     content: v.string().required(),
+ *     authorId: v.number().required(),
+ *     published: v.boolean().default(false),
+ *   }),
+ * });
+ *
+ * // TypeScript knows the exact type!
+ * const post = await Post.create({
+ *   title: "Hello World",
+ *   content: "My first post",
+ *   authorId: 1,
+ * });
+ *
+ * console.log(post.title); // ✅ Type-safe!
+ * ```
+ */
+function defineModel(options) {
+    class DefinedModel extends Model {
+        /**
+         * Table/collection name
+         */
+        static table = options.table;
+        /**
+         * Validation schema
+         */
+        static schema = options.schema;
+        /**
+         * Delete strategy
+         */
+        static deleteStrategy = options.deleteStrategy || "trash";
+        /**
+         * Strict mode
+         */
+        static strictMode = options.strictMode || "strip";
+        /**
+         * Auto-generate ID
+         */
+        static autoGenerateId = options.autoGenerateId || false;
+        /**
+         * Random increment
+         */
+        static randomIncrement = options.randomIncrement || false;
+        /**
+         * Initial ID
+         */
+        static initialId = options.initialId || 1;
+    }
+    // Apply custom instance properties (getters/setters/methods)
+    if (options.properties) {
+        Object.defineProperties(DefinedModel.prototype, Object.getOwnPropertyDescriptors(options.properties));
+    }
+    if (options.name) {
+        registerModelInRegistry(options.name, DefinedModel);
+    }
+    // Apply custom static methods
+    if (options.statics) {
+        Object.defineProperties(DefinedModel, Object.getOwnPropertyDescriptors(options.statics));
+    }
+    return DefinedModel;
+}export{defineModel};//# sourceMappingURL=define-model.js.map

package/esm/utils/define-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-model.js","sources":["../../src/utils/define-model.ts"],"sourcesContent":[null],"names":[],"mappings":"uGAuGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDG;AACG,SAAU,WAAW,CAMzB,OAIC,EAAA;IAID,MAAM,YAAa,SAAQ,KAAqB,CAAA;AAC9C;;AAEG;AACI,QAAA,OAAO,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;AAEpC;;AAEG;AACI,QAAA,OAAO,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;AAEtC;;AAEG;QACI,OAAO,cAAc,GAAmB,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC;AAEjF;;AAEG;QACI,OAAO,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC;AAEzD;;AAEG;QACI,OAAO,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,KAAK,CAAC;AAE/D;;AAEG;QACI,OAAO,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,KAAK,CAAC;AAEjE;;AAEG;QACI,OAAO,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,CAAC,CAAC;;;IAInD,IAAI,OAAO,CAAC,UAAU,EAAE;AACtB,QAAA,MAAM,CAAC,gBAAgB,CACrB,YAAY,CAAC,SAAS,EACtB,MAAM,CAAC,yBAAyB,CAAC,OAAO,CAAC,UAAU,CAAC,CACrD,CAAC;AACH,KAAA;IAED,IAAI,OAAO,CAAC,IAAI,EAAE;AAChB,QAAA,uBAAuB,CAAC,OAAO,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AACrD,KAAA;;IAGD,IAAI,OAAO,CAAC,OAAO,EAAE;AACnB,QAAA,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,yBAAyB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AAC1F,KAAA;AAQD,IAAA,OAAO,YAAqC,CAAC;AAC/C"}

package/esm/utils/once-connected.d.ts

@@ -0,0 +1,146 @@
+import type { DataSource } from "../data-source/data-source";
+/**
+ * Execute a callback once the driver is connected.
+ *
+ * If the driver is already connected, the callback is executed immediately.
+ * Otherwise, it waits for the "connected" event.
+ *
+ * **Use Case:**
+ * Useful for ensuring database-dependent operations only run after connection
+ * is established, especially in small to medium projects with a single data source.
+ *
+ * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+ * @param callback - Function to execute once connected (optional if first param is callback)
+ *
+ * @example
+ * ```typescript
+ * // With default data source (just callback)
+ * await connectToDatabase({ database: "myapp" });
+ *
+ * onceConnected((ds) => {
+ *   console.log("Database is ready!");
+ *   console.log("Connected to:", ds.name);
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source name
+ * onceConnected("primary", (ds) => {
+ *   console.log("Primary database is ready!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source instance
+ * const dataSource = await connectToDatabase({ database: "myapp" });
+ *
+ * onceConnected(dataSource, (ds) => {
+ *   console.log("Database is ready!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With driver instance
+ * const driver = new MongoDbDriver(config);
+ * const dataSource = new DataSource({ name: "primary", driver });
+ *
+ * onceConnected(dataSource, () => {
+ *   // Start application server
+ *   app.listen(3000);
+ * });
+ *
+ * // Connect after setting up the callback
+ * await driver.connect();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Chaining operations
+ * onceConnected(async (ds) => {
+ *   // Seed database
+ *   await seedDatabase();
+ *
+ *   // Run migrations
+ *   await runMigrations();
+ *
+ *   console.log("Database ready!");
+ * });
+ * ```
+ */
+export declare function onceConnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
+/**
+ * Execute a callback once the driver is disconnected.
+ *
+ * If the driver is already disconnected, the callback is executed immediately.
+ * Otherwise, it waits for the "disconnected" event.
+ *
+ * **Use Case:**
+ * Useful for cleanup operations, graceful shutdown, or reconnection logic.
+ *
+ * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+ * @param callback - Function to execute once disconnected (optional if first param is callback)
+ *
+ * @example
+ * ```typescript
+ * // With default data source (just callback)
+ * await connectToDatabase({ database: "myapp" });
+ *
+ * onceDisconnected((ds) => {
+ *   console.log("Database disconnected!");
+ *   console.log("Attempting reconnection...");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source name
+ * onceDisconnected("primary", (ds) => {
+ *   console.log("Primary database disconnected!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source instance
+ * const dataSource = await connectToDatabase({ database: "myapp" });
+ *
+ * onceDisconnected(dataSource, (ds) => {
+ *   console.log("Database disconnected!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Graceful shutdown with default data source
+ * process.on("SIGTERM", async () => {
+ *   console.log("Shutting down...");
+ *
+ *   onceDisconnected(() => {
+ *     console.log("Database closed, exiting process");
+ *     process.exit(0);
+ *   });
+ *
+ *   const dataSource = DataSourceRegistry.getDefault();
+ *   await dataSource?.driver.disconnect();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cleanup resources on disconnect
+ * onceDisconnected(async (ds) => {
+ *   // Close file handles
+ *   await closeFileHandles();
+ *
+ *   // Clear caches
+ *   clearCaches();
+ *
+ *   console.log("Cleanup complete");
+ * });
+ * ```
+ */
+export declare function onceDisconnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
+//# sourceMappingURL=once-connected.d.ts.map

package/esm/utils/once-connected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once-connected.d.ts","sourceRoot":"","sources":["../../src/utils/once-connected.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,wBAAgB,aAAa,CAC3B,0BAA0B,EACtB,UAAU,GACV,MAAM,GACN,CAAC,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC,EACtC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAC1C,IAAI,CA2DN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,wBAAgB,gBAAgB,CAC9B,0BAA0B,EACtB,UAAU,GACV,MAAM,GACN,CAAC,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC,EACtC,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAC1C,IAAI,CA2DN"}

package/esm/utils/once-connected.js

@@ -0,0 +1,252 @@
+import {dataSourceRegistry}from'../data-source/data-source-registry.js';/**
+ * Execute a callback once the driver is connected.
+ *
+ * If the driver is already connected, the callback is executed immediately.
+ * Otherwise, it waits for the "connected" event.
+ *
+ * **Use Case:**
+ * Useful for ensuring database-dependent operations only run after connection
+ * is established, especially in small to medium projects with a single data source.
+ *
+ * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+ * @param callback - Function to execute once connected (optional if first param is callback)
+ *
+ * @example
+ * ```typescript
+ * // With default data source (just callback)
+ * await connectToDatabase({ database: "myapp" });
+ *
+ * onceConnected((ds) => {
+ *   console.log("Database is ready!");
+ *   console.log("Connected to:", ds.name);
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source name
+ * onceConnected("primary", (ds) => {
+ *   console.log("Primary database is ready!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source instance
+ * const dataSource = await connectToDatabase({ database: "myapp" });
+ *
+ * onceConnected(dataSource, (ds) => {
+ *   console.log("Database is ready!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With driver instance
+ * const driver = new MongoDbDriver(config);
+ * const dataSource = new DataSource({ name: "primary", driver });
+ *
+ * onceConnected(dataSource, () => {
+ *   // Start application server
+ *   app.listen(3000);
+ * });
+ *
+ * // Connect after setting up the callback
+ * await driver.connect();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Chaining operations
+ * onceConnected(async (ds) => {
+ *   // Seed database
+ *   await seedDatabase();
+ *
+ *   // Run migrations
+ *   await runMigrations();
+ *
+ *   console.log("Database ready!");
+ * });
+ * ```
+ */
+function onceConnected(dataSourceOrNameOrCallback, callback) {
+    // Determine if first parameter is a callback
+    let targetDataSource;
+    let actualCallback;
+    if (typeof dataSourceOrNameOrCallback === "function") {
+        // First param is callback, use default data source
+        actualCallback = dataSourceOrNameOrCallback;
+        targetDataSource = "default";
+    }
+    else {
+        // First param is data source name or instance
+        if (!callback) {
+            throw new Error("Callback is required when providing a data source name or instance.");
+        }
+        actualCallback = callback;
+        targetDataSource = dataSourceOrNameOrCallback;
+    }
+    // Try to get the data source if it's a string
+    let resolvedDataSource;
+    if (typeof targetDataSource === "string") {
+        try {
+            resolvedDataSource =
+                targetDataSource === "default"
+                    ? dataSourceRegistry.get()
+                    : dataSourceRegistry.get(targetDataSource);
+        }
+        catch {
+            // Data source not registered yet, will wait for event
+        }
+    }
+    else {
+        resolvedDataSource = targetDataSource;
+    }
+    // If data source is resolved and already connected, fire immediately
+    if (resolvedDataSource && resolvedDataSource.driver.isConnected) {
+        actualCallback(resolvedDataSource);
+        return;
+    }
+    // Otherwise, wait for the connected event
+    const listener = (ds) => {
+        const matches = typeof targetDataSource === "string"
+            ? targetDataSource === "default"
+                ? ds.isDefault
+                : ds.name === targetDataSource
+            : ds === targetDataSource;
+        if (matches) {
+            actualCallback(ds);
+        }
+        else {
+            // Not the one we're looking for, keep listening
+            dataSourceRegistry.once("connected", listener);
+        }
+    };
+    dataSourceRegistry.once("connected", listener);
+}
+/**
+ * Execute a callback once the driver is disconnected.
+ *
+ * If the driver is already disconnected, the callback is executed immediately.
+ * Otherwise, it waits for the "disconnected" event.
+ *
+ * **Use Case:**
+ * Useful for cleanup operations, graceful shutdown, or reconnection logic.
+ *
+ * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+ * @param callback - Function to execute once disconnected (optional if first param is callback)
+ *
+ * @example
+ * ```typescript
+ * // With default data source (just callback)
+ * await connectToDatabase({ database: "myapp" });
+ *
+ * onceDisconnected((ds) => {
+ *   console.log("Database disconnected!");
+ *   console.log("Attempting reconnection...");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source name
+ * onceDisconnected("primary", (ds) => {
+ *   console.log("Primary database disconnected!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With data source instance
+ * const dataSource = await connectToDatabase({ database: "myapp" });
+ *
+ * onceDisconnected(dataSource, (ds) => {
+ *   console.log("Database disconnected!");
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Graceful shutdown with default data source
+ * process.on("SIGTERM", async () => {
+ *   console.log("Shutting down...");
+ *
+ *   onceDisconnected(() => {
+ *     console.log("Database closed, exiting process");
+ *     process.exit(0);
+ *   });
+ *
+ *   const dataSource = DataSourceRegistry.getDefault();
+ *   await dataSource?.driver.disconnect();
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cleanup resources on disconnect
+ * onceDisconnected(async (ds) => {
+ *   // Close file handles
+ *   await closeFileHandles();
+ *
+ *   // Clear caches
+ *   clearCaches();
+ *
+ *   console.log("Cleanup complete");
+ * });
+ * ```
+ */
+function onceDisconnected(dataSourceOrNameOrCallback, callback) {
+    // Determine if first parameter is a callback
+    let targetDataSource;
+    let actualCallback;
+    if (typeof dataSourceOrNameOrCallback === "function") {
+        // First param is callback, use default data source
+        actualCallback = dataSourceOrNameOrCallback;
+        targetDataSource = "default";
+    }
+    else {
+        // First param is data source name or instance
+        if (!callback) {
+            throw new Error("Callback is required when providing a data source name or instance.");
+        }
+        actualCallback = callback;
+        targetDataSource = dataSourceOrNameOrCallback;
+    }
+    // Try to get the data source if it's a string
+    let resolvedDataSource;
+    if (typeof targetDataSource === "string") {
+        try {
+            resolvedDataSource =
+                targetDataSource === "default"
+                    ? dataSourceRegistry.get()
+                    : dataSourceRegistry.get(targetDataSource);
+        }
+        catch {
+            // Data source not registered yet, will wait for event
+        }
+    }
+    else {
+        resolvedDataSource = targetDataSource;
+    }
+    // If data source is resolved and already disconnected, fire immediately
+    if (resolvedDataSource && !resolvedDataSource.driver.isConnected) {
+        actualCallback(resolvedDataSource);
+        return;
+    }
+    // Otherwise, wait for the disconnected event
+    const listener = (ds) => {
+        const matches = typeof targetDataSource === "string"
+            ? targetDataSource === "default"
+                ? ds.isDefault
+                : ds.name === targetDataSource
+            : ds === targetDataSource;
+        if (matches) {
+            actualCallback(ds);
+        }
+        else {
+            // Not the one we're looking for, keep listening
+            dataSourceRegistry.once("disconnected", listener);
+        }
+    };
+    dataSourceRegistry.once("disconnected", listener);
+}export{onceConnected,onceDisconnected};//# sourceMappingURL=once-connected.js.map

package/esm/utils/once-connected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"once-connected.js","sources":["../../src/utils/once-connected.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/esm/validation/database-seal-plugins.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=database-seal-plugins.d.ts.map

package/esm/validation/database-seal-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-seal-plugins.d.ts","sourceRoot":"","sources":["../../src/validation/database-seal-plugins.ts"],"names":[],"mappings":""}

package/esm/validation/database-seal-plugins.js

@@ -0,0 +1,4 @@
+import {registerPlugin}from'@warlock.js/seal';import {embedValidator}from'./plugins/embed-validator-plugin.js';// We need to introduce new validators
+// 1. v.embed(model: typeof Model, options: EmbedOptions)
+// 2. v.embedMany(model: typeof Model, options: EmbedManyOptions)
+registerPlugin(embedValidator);//# sourceMappingURL=database-seal-plugins.js.map

package/esm/validation/database-seal-plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-seal-plugins.js","sources":["../../src/validation/database-seal-plugins.ts"],"sourcesContent":[null],"names":[],"mappings":"+GAGA;AACA;AACA;AAEA,cAAc,CAAC,cAAc,CAAC"}