@warlock.js/cascade 4.0.162 → 4.0.164

package/cjs/contracts/database-id-generator.contract.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Options for generating the next ID.
+ */
+export type GenerateIdOptions = {
+    /** The table/collection name */
+    table: string;
+    /** Initial ID value for the first record (default: 1) */
+    initialId?: number;
+    /** Amount to increment by for each new record (default: 1) */
+    incrementIdBy?: number;
+};
+/**
+ * ID generator contract for auto-incrementing IDs in NoSQL databases.
+ *
+ * This service generates sequential integer IDs for NoSQL databases (like MongoDB)
+ * that don't have native auto-increment support. It maintains a separate collection
+ * that tracks the last generated ID for each table.
+ *
+ * **Note:** SQL databases (PostgreSQL, MySQL) use native AUTO_INCREMENT/SERIAL
+ * and don't need this service.
+ *
+ * @example
+ * ```typescript
+ * // For MongoDB
+ * const mongoDriver = new MongoDbDriver({ ...config, autoGenerateId: true });
+ * const idGenerator = mongoDriver.getIdGenerator();
+ *
+ * // Generate next ID
+ * const id = await idGenerator.generateNextId({
+ *   table: "users",
+ *   initialId: 1000,
+ *   incrementIdBy: 1
+ * });
+ * console.log(id); // 1000 (first time), 1001 (second time), etc.
+ *
+ * // Get last ID for a table
+ * const lastId = await idGenerator.getLastId("users"); // Returns 1001
+ *
+ * // Manually set last ID (useful for migrations)
+ * await idGenerator.setLastId("users", 5000);
+ * ```
+ */
+export interface IdGeneratorContract {
+    /**
+     * Generate the next ID for a table.
+     *
+     * This method:
+     * 1. Atomically increments the counter in the tracking collection
+     * 2. Returns the new ID
+     * 3. Creates the counter document if it doesn't exist (using initialId)
+     *
+     * The operation is atomic to ensure uniqueness even in concurrent scenarios.
+     *
+     * @param options - Configuration for ID generation
+     * @returns The generated ID
+     *
+     * @example
+     * ```typescript
+     * const id = await idGenerator.generateNextId({
+     *   table: "users",
+     *   initialId: 1000,
+     *   incrementIdBy: 5
+     * });
+     * console.log(id); // 1000, 1005, 1010, etc.
+     * ```
+     */
+    generateNextId(options: GenerateIdOptions): Promise<number>;
+    /**
+     * Get the last generated ID for a table.
+     *
+     * Returns 0 if no IDs have been generated yet for this table.
+     *
+     * @param table - The table/collection name
+     * @returns The last generated ID, or 0 if none exists
+     *
+     * @example
+     * ```typescript
+     * const lastId = await idGenerator.getLastId("users");
+     * console.log(lastId); // 42
+     * ```
+     */
+    getLastId(table: string): Promise<number>;
+    /**
+     * Set the last ID for a table.
+     *
+     * Useful for:
+     * - Migrations: Setting a starting point for IDs
+     * - Manual ID management: Adjusting counters after bulk operations
+     * - Testing: Resetting ID sequences
+     *
+     * @param table - The table/collection name
+     * @param id - The ID to set as the last generated ID
+     *
+     * @example
+     * ```typescript
+     * // Start IDs from 1000
+     * await idGenerator.setLastId("users", 1000);
+     *
+     * // Next generated ID will be 1001
+     * const nextId = await idGenerator.generateNextId({
+     *   table: "users",
+     *   incrementIdBy: 1
+     * });
+     * console.log(nextId); // 1001
+     * ```
+     */
+    setLastId(table: string, id: number): Promise<void>;
+}
+//# sourceMappingURL=database-id-generator.contract.d.ts.map

package/cjs/contracts/database-id-generator.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-id-generator.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/database-id-generator.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAAc,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5D;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrD"}

package/cjs/contracts/database-remover.contract.d.ts

@@ -0,0 +1,104 @@
+import type { DeleteStrategy } from "../types";
+/**
+ * Remover service contract for deleting models from the database.
+ *
+ * The remover orchestrates the complete deletion pipeline:
+ * 1. Strategy resolution (options → model static → data source default)
+ * 2. Validation (check if model is new, has primary key)
+ * 3. Event emission (deleting, deleted)
+ * 4. Driver execution (based on strategy: trash, permanent, or soft)
+ * 5. Post-deletion cleanup (mark as new, reset state)
+ *
+ * @example
+ * ```typescript
+ * const user = await User.find(1);
+ * const remover = new DatabaseRemover(user);
+ * const result = await remover.destroy();
+ *
+ * console.log(result.success); // true
+ * console.log(result.strategy); // "trash" | "permanent" | "soft"
+ * console.log(result.deletedCount); // 1
+ * ```
+ */
+export interface RemoverContract {
+    /**
+     * Destroy (delete) the model instance from the database.
+     *
+     * Performs deletion based on the resolved strategy:
+     * - `trash`: Moves to trash collection, then deletes
+     * - `permanent`: Direct deletion
+     * - `soft`: Sets deletedAt timestamp
+     *
+     * Automatically emits lifecycle events and handles cleanup.
+     *
+     * @param options - Remover options
+     * @returns Result containing success status, strategy used, and metadata
+     *
+     * @throws {Error} If model is new (not saved) or if deletion fails
+     *
+     * @example
+     * ```typescript
+     * // Use default strategy
+     * const result = await remover.destroy();
+     *
+     * // Override strategy
+     * await remover.destroy({ strategy: "permanent" });
+     *
+     * // Skip events (silent delete)
+     * await remover.destroy({ skipEvents: true });
+     * ```
+     */
+    destroy(options?: RemoverOptions): Promise<RemoverResult>;
+}
+/**
+ * Options for controlling the destroy operation.
+ */
+export type RemoverOptions = {
+    /**
+     * Override the delete strategy for this operation.
+     * Takes precedence over model static property and data source default.
+     *
+     * @default undefined (uses model static or data source default)
+     */
+    strategy?: DeleteStrategy;
+    /**
+     * Skip lifecycle event emission.
+     * Equivalent to "silent delete" in legacy Cascade.
+     *
+     * @default false
+     */
+    skipEvents?: boolean;
+    /**
+     * Skip sync operations after delete.
+     * Useful when you want to delete without triggering sync updates.
+     *
+     * @default false
+     */
+    skipSync?: boolean;
+};
+/**
+ * Result returned after a successful destroy operation.
+ */
+export type RemoverResult = {
+    /**
+     * Whether the destroy operation succeeded.
+     */
+    success: boolean;
+    /**
+     * Number of records deleted.
+     * - `1` for permanent and trash strategies
+     * - `1` for soft delete (one record updated)
+     * - `0` if deletion failed
+     */
+    deletedCount: number;
+    /**
+     * The delete strategy that was used.
+     */
+    strategy: DeleteStrategy;
+    /**
+     * The trash record (if strategy was "trash").
+     * Contains the original record data that was moved to trash.
+     */
+    trashRecord?: Record<string, unknown>;
+};
+//# sourceMappingURL=database-remover.contract.d.ts.map

package/cjs/contracts/database-remover.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-remover.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/database-remover.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC3D;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC,CAAC"}

package/cjs/contracts/database-restorer.contract.d.ts

@@ -0,0 +1,143 @@
+import type { Model } from "../model/model";
+/**
+ * Restorer service contract for restoring deleted models from the database.
+ *
+ * The restorer orchestrates the complete restoration pipeline:
+ * 1. Strategy detection (trash vs soft delete)
+ * 2. Record retrieval from trash table or soft-deleted records
+ * 3. ID conflict resolution
+ * 4. Event emission (restoring, restored)
+ * 5. Driver execution (insert back to original table, remove from trash/clear deletedAt)
+ *
+ * @example
+ * ```typescript
+ * const restorer = new DatabaseRestorer(User);
+ * const result = await restorer.restore(123);
+ *
+ * console.log(result.success); // true
+ * console.log(result.strategy); // "trash" | "soft"
+ * console.log(result.restoredCount); // 1
+ * ```
+ */
+export interface RestorerContract {
+    /**
+     * Restore a single deleted record by its ID.
+     *
+     * Resolves the delete strategy from options → model static → data source default.
+     * Handles ID conflicts based on options.
+     *
+     * @param id - The primary key value of the record to restore
+     * @param options - Restorer options
+     * @returns Result containing success status, strategy used, and restored record
+     *
+     * @throws {Error} If strategy is "permanent" (cannot restore permanently deleted records)
+     * @throws {Error} If record not found in trash or soft-deleted records
+     * @throws {Error} If ID conflict and onIdConflict is "fail"
+     *
+     * @example
+     * ```typescript
+     * // Restore with default options (assign new ID if conflict)
+     * const result = await restorer.restore(123);
+     *
+     * // Restore with explicit strategy
+     * await restorer.restore(123, { strategy: "trash" });
+     *
+     * // Restore and fail if ID conflict
+     * await restorer.restore(123, { onIdConflict: "fail" });
+     *
+     * // Silent restore (skip events)
+     * await restorer.restore(123, { skipEvents: true });
+     * ```
+     */
+    restore(id: string | number, options?: RestorerOptions): Promise<RestorerResult>;
+    /**
+     * Restore all deleted records for the model's table.
+     *
+     * Restores all records from the trash table (if using trash strategy)
+     * or all soft-deleted records (if using soft strategy).
+     *
+     * @param options - Restorer options
+     * @returns Result containing success status, strategy used, and aggregate counts
+     *
+     * @example
+     * ```typescript
+     * // Restore all with default options
+     * const result = await restorer.restoreAll();
+     *
+     * // Restore all and fail on any ID conflict
+     * await restorer.restoreAll({ onIdConflict: "fail" });
+     * ```
+     */
+    restoreAll(options?: RestorerOptions): Promise<RestorerResult>;
+}
+/**
+ * Options for controlling the restore operation.
+ */
+export type RestorerOptions = {
+    /**
+     * Override the delete strategy for this operation.
+     * Takes precedence over model static property and data source default.
+     *
+     * Must be "trash" or "soft" (cannot restore permanently deleted records).
+     *
+     * @default undefined (uses model static or data source default)
+     */
+    strategy?: "trash" | "soft";
+    /**
+     * Behavior when the original ID already exists in the target table.
+     *
+     * - `"assignNew"`: Automatically assign a new ID (default)
+     * - `"fail"`: Throw an error if ID conflict occurs
+     *
+     * @default "assignNew"
+     */
+    onIdConflict?: "fail" | "assignNew";
+    /**
+     * Skip lifecycle event emission.
+     * Equivalent to "silent restore".
+     *
+     * @default false
+     */
+    skipEvents?: boolean;
+};
+/**
+ * Result returned after a successful restore operation.
+ */
+export type RestorerResult = {
+    /**
+     * Whether the restore operation succeeded.
+     */
+    success: boolean;
+    /**
+     * Number of records restored.
+     * - `1` for single restore
+     * - `N` for restoreAll (number of records restored)
+     */
+    restoredCount: number;
+    /**
+     * The delete strategy that was used for restoration.
+     * - `"trash"`: Record was restored from trash table
+     * - `"soft"`: Record was restored by clearing deletedAt timestamp
+     */
+    strategy: "trash" | "soft";
+    /**
+     * The restored record data (for single restore only).
+     * Contains the record that was restored, with potentially new ID if conflict occurred.
+     */
+    restoredRecord?: Model;
+    /**
+     * The restored records list
+     */
+    restoredRecords?: Model[];
+    /**
+     * List of ID conflicts that occurred during restoreAll.
+     * Only populated if onIdConflict is "assignNew" and conflicts occurred.
+     */
+    conflicts?: Array<{
+        /** The original ID that conflicted */
+        id: string | number;
+        /** Reason for the conflict */
+        reason: string;
+    }>;
+};
+//# sourceMappingURL=database-restorer.contract.d.ts.map

package/cjs/contracts/database-restorer.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-restorer.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/database-restorer.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,OAAO,CACL,EAAE,EAAE,MAAM,GAAG,MAAM,EACnB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAAC;IAE3B;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAChE;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAE5B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IAEpC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC;IAE3B;;;OAGG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC;IAEvB;;OAEG;IACH,eAAe,CAAC,EAAE,KAAK,EAAE,CAAC;IAE1B;;;OAGG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC;QAChB,sCAAsC;QACtC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QACpB,8BAA8B;QAC9B,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ,CAAC"}

package/cjs/contracts/database-writer.contract.d.ts

@@ -0,0 +1,119 @@
+import type { UpdateOperations } from "./database-driver.contract";
+/**
+ * Writer service contract for persisting models to the database.
+ *
+ * The writer orchestrates the complete save pipeline:
+ * 1. Validation (via @warlock.js/seal)
+ * 2. ID generation (for new records in NoSQL)
+ * 3. Event emission (validating, saving, created/updated, saved)
+ * 4. Driver execution (insert or update)
+ * 5. Post-save cleanup (reset dirty tracker, update isNew flag)
+ *
+ * @example
+ * ```typescript
+ * const user = new User({ name: "Alice" });
+ * const writer = new DatabaseWriter(user);
+ * const result = await writer.save();
+ *
+ * console.log(result.success); // true
+ * console.log(result.isNew); // true (was an insert)
+ * console.log(result.document); // { _id: ..., id: 1, name: "Alice" }
+ * ```
+ */
+export interface WriterContract {
+    /**
+     * Save the model instance to the database.
+     *
+     * Performs insert if `model.isNew === true`, otherwise performs update.
+     * Automatically validates, casts, generates IDs, and emits lifecycle events.
+     *
+     * @param options - Save options
+     * @returns Result containing success status, document, and metadata
+     *
+     * @throws {ValidationError} If validation fails
+     * @throws {Error} If database operation fails
+     *
+     * @example
+     * ```typescript
+     * // Insert
+     * const user = new User({ name: "Alice" });
+     * const writer = new DatabaseWriter(user);
+     * await writer.save();
+     *
+     * // Update
+     * user.set("name", "Bob");
+     * await writer.save();
+     *
+     * // Skip validation
+     * await writer.save({ skipValidation: true });
+     *
+     * // Skip events (silent save)
+     * await writer.save({ skipEvents: true });
+     * ```
+     */
+    save(options?: WriterOptions): Promise<WriterResult>;
+}
+/**
+ * Options for controlling the save operation.
+ */
+export type WriterOptions = {
+    /**
+     * Skip validation and casting.
+     * Useful when data is already validated or for performance-critical operations.
+     *
+     * @default false
+     */
+    skipValidation?: boolean;
+    /**
+     * Skip lifecycle event emission.
+     * Equivalent to "silent save" in legacy Cascade.
+     *
+     * @default false
+     */
+    skipEvents?: boolean;
+    /**
+     * Skip sync operations after save.
+     * Useful when you want to save without triggering sync updates.
+     *
+     * @default false
+     */
+    skipSync?: boolean;
+    /**
+     * Replace entire document with the new data.
+     * By default, Model will only update or unset the dirty changes.
+     * @default false
+     */
+    replace?: boolean;
+};
+/**
+ * Result returned after a successful save operation.
+ */
+export type WriterResult = {
+    /**
+     * Whether the save operation succeeded.
+     */
+    success: boolean;
+    /**
+     * The saved document with all database-generated fields.
+     * Includes _id, id, timestamps, etc.
+     */
+    document: Record<string, unknown>;
+    /**
+     * Whether this was an insert operation.
+     * - `true`: New record was created
+     * - `false`: Existing record was updated
+     */
+    isNew: boolean;
+    /**
+     * Number of records modified (for updates only).
+     * Undefined for insert operations.
+     */
+    modifiedCount?: number;
+};
+/**
+ * Internal type for building update operations from dirty tracker.
+ *
+ * @internal
+ */
+export type BuildUpdateOperationsResult = UpdateOperations;
+//# sourceMappingURL=database-writer.contract.d.ts.map

package/cjs/contracts/database-writer.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/database-writer.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElC;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,CAAC"}

package/cjs/contracts/driver-blueprint.contract.d.ts

@@ -0,0 +1,49 @@
+export interface DriverBlueprintContract {
+    /**
+     * Get tables list
+     */
+    listTables(): Promise<string[]>;
+    /**
+     * Get all indexes of the given table
+     */
+    listIndexes(table: string): Promise<TableIndexInformation[]>;
+    /**
+     * Get all tables of the database
+     */
+    listTables(): Promise<string[]>;
+    /**
+     * Get all columns of the given table
+     */
+    listColumns(table: string): Promise<string[]>;
+    /**
+     * Check if the given table exists
+     */
+    tableExists(table: string): Promise<boolean>;
+}
+export type TableIndexInformation = {
+    /**
+     * Index name
+     */
+    name: string;
+    /**
+     * Index columns
+     */
+    columns?: string[];
+    /**
+     * Index type
+     */
+    type?: string;
+    /**
+     * Index unique
+     */
+    unique: boolean;
+    /**
+     * Index partial
+     */
+    partial: boolean;
+    /**
+     * Index options
+     */
+    options: Record<string, any>;
+};
+//# sourceMappingURL=driver-blueprint.contract.d.ts.map

package/cjs/contracts/driver-blueprint.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-blueprint.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/driver-blueprint.contract.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChC;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAE7D;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEhC;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE9C;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9C;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B,CAAC"}

package/cjs/contracts/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./database-driver.contract";
+export * from "./database-id-generator.contract";
+export * from "./database-remover.contract";
+export * from "./database-restorer.contract";
+export * from "./database-writer.contract";
+export * from "./driver-blueprint.contract";
+export * from "./migration-driver.contract";
+export * from "./query-builder.contract";
+export * from "./sync-adapter.contract";
+//# sourceMappingURL=index.d.ts.map

package/cjs/contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}