@plyaz/db 0.0.1 → 0.1.1

package/dist/migrations/MigrationManager.d.ts

@@ -0,0 +1,106 @@
+/**
+ * MigrationManager - Database schema migrations with version control
+ *
+ * Manages database schema migrations with support for versioning,
+ * rollback, and migration history tracking. Automatically discovers
+ * migration files from a specified directory and applies them in order.
+ *
+ * @example
+ * ```typescript
+ * const migrationManager = new MigrationManager({
+ *   adapter: sqlAdapter,
+ *   migrationsPath: './migrations', // default
+ *   tableName: 'schema_migrations' // default
+ * });
+ *
+ * // Run all pending migrations
+ * await migrationManager.up();
+ *
+ * // Rollback last migration
+ * await migrationManager.down();
+ *
+ * // Get migration status
+ * const status = await migrationManager.status();
+ * ```
+ */
+import type { DatabaseResult, MigrationManagerConfig, MigrationStatus } from "@plyaz/types/db";
+/**
+ * MigrationManager - Handles database schema migrations
+ *
+ * Discovers migration files, tracks migration history, and applies
+ * migrations in order with support for rollback.
+ */
+export declare class MigrationManager {
+    private adapter;
+    private migrationsPath;
+    private tableName;
+    private schema;
+    constructor(config: MigrationManagerConfig);
+    /**
+     * Initialize migrations table if it doesn't exist
+     */
+    initialize(): Promise<DatabaseResult<void>>;
+    /**
+     * Discover migration files from migrations directory (including subdirectories)
+     */
+    private discoverMigrations;
+    /**
+     * Parse SQL content to extract UP and DOWN sections
+     */
+    private parseSqlSections;
+    /**
+     * Load SQL migration from file
+     */
+    private loadSqlMigration;
+    /**
+     * Load TypeScript/JavaScript migration from file
+     */
+    private loadJsMigration;
+    /**
+     * Load migration from file
+     */
+    private loadMigration;
+    /**
+     * Get applied migrations from database
+     */
+    private getAppliedMigrations;
+    /**
+     * Record migration as applied
+     */
+    private recordMigration;
+    /**
+     * Remove migration record (for rollback)
+     */
+    private unrecordMigration;
+    /**
+     * Get migration status (applied and pending)
+     */
+    status(): Promise<DatabaseResult<MigrationStatus>>;
+    /**
+     * Run all pending migrations
+     */
+    up(targetVersion?: string): Promise<DatabaseResult<number>>;
+    /**
+     * Rollback last migration or rollback to specific version
+     */
+    down(steps?: number): Promise<DatabaseResult<number>>;
+    /**
+     * Reset database (rollback all migrations)
+     */
+    reset(): Promise<DatabaseResult<number>>;
+    /**
+     * Clear migration history (delete all records from tracking table)
+     *
+     * Use this to force fresh migrations in test/development environments
+     * without rolling back actual database changes.
+     *
+     * @example
+     * ```typescript
+     * // Clear history and re-run all migrations
+     * await migrationManager.clearHistory();
+     * await migrationManager.up();
+     * ```
+     */
+    clearHistory(): Promise<DatabaseResult<void>>;
+}
+//# sourceMappingURL=MigrationManager.d.ts.map

package/dist/migrations/MigrationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrationManager.d.ts","sourceRoot":"","sources":["../../src/migrations/MigrationManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAEV,cAAc,EAId,sBAAsB,EACtB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAOzB;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,sBAAsB;IAW1C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAkDjD;;OAEG;YACW,kBAAkB;IAsChC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;YACW,eAAe;IAgB7B;;OAEG;YACW,aAAa;IAoB3B;;OAEG;YACW,oBAAoB;IAkBlC;;OAEG;YACW,eAAe;IAmB7B;;OAEG;YACW,iBAAiB;IAS/B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;IA2BxD;;OAEG;IACG,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAiEjE;;OAEG;IACG,IAAI,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAiE9D;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAK9C;;;;;;;;;;;;OAYG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;CAgBpD"}

package/dist/migrations/generateDownMigration.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Utility to help generate DOWN migrations from SQL files
+ *
+ * This is a helper script to analyze SQL migrations and suggest
+ * appropriate DOWN statements for rollback support.
+ */
+interface DownSuggestion {
+    file: string;
+    upStatements: string[];
+    downSuggestions: string[];
+}
+/**
+ * Parse SQL migration and suggest DOWN statements
+ */
+export declare function suggestDownMigration(sqlContent: string, filename: string): DownSuggestion;
+/**
+ * Add DOWN section to a migration file
+ */
+export declare function addDownSection(filePath: string): string;
+/**
+ * Process all migrations in a directory and add DOWN sections
+ */
+export declare function processDirectory(migrationsPath: string, dryRun?: boolean): void;
+export {};
+//# sourceMappingURL=generateDownMigration.d.ts.map

package/dist/migrations/generateDownMigration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDownMigration.d.ts","sourceRoot":"","sources":["../../src/migrations/generateDownMigration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AA4FD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,cAAc,CAuBhB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAevD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,UAAO,GAAG,IAAI,CAwC5E"}

package/dist/migrations/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Database Migrations Module
+ *
+ * Provides migration management for database schema versioning,
+ * rollback support, and migration history tracking.
+ *
+ * @module migrations
+ */
+export { MigrationManager } from "./MigrationManager";
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/repository/BaseRepository.d.ts

@@ -6,7 +6,7 @@
  * CRUD operations and consistent interface patterns.
  *
  */
-import type { DatabaseResult, PaginatedResult, QueryOptions, Filter, DatabaseServiceType } from "@plyaz/types/db";
+import type { DatabaseResult, PaginatedResult, QueryOptions, Filter, DatabaseServiceInterface, CreateInput, OperationConfig } from "@plyaz/types/db";
 /**
  * BASE REPOSITORY - Repository Layer Foundation
  *
@@ -14,13 +14,14 @@ import type { DatabaseResult, PaginatedResult, QueryOptions, Filter, DatabaseSer
  * All domain-specific repositories extend this class for type-safe database operations.
  *
  * **Application Flow Position:**
- * Service Layer � **Repository Layer** � DatabaseService � Adapter Chain
+ * Service Layer → **Repository Layer** → DatabaseService → Adapter Chain
  *
  * **What this class provides:**
  * - Type-safe CRUD operations for domain entities
  * - Consistent interface across all repositories
  * - Delegation to DatabaseService with proper table mapping
  * - Foundation for domain-specific repository methods
+ * - Default operation config (adapter, schema, etc.) that can be overridden per-query
  *
  * **Called by:** Service layer (UserService, OrderService, etc.)
  * **Calls:** DatabaseService methods (get, create, update, delete, etc.)
@@ -39,40 +40,62 @@ import type { DatabaseResult, PaginatedResult, QueryOptions, Filter, DatabaseSer
  * }
  *
  * class UserRepository extends BaseRepository<User> {
- *   constructor(db: IDatabaseService) {
+ *   constructor(db: DatabaseServiceInterface) {
  *     super(db, Tables.USERS);
  *   }
  *
  *   // Domain-specific methods
  *   async findByEmail(email: string) {
- *     return this.db.query(this.tableName, {
- *       filter: { field: 'email', operator: 'eq', value: email }
- *     });
+ *     return this.findOne({ field: 'email', operator: 'eq', value: email });
  *   }
  * }
  * ```
  *
  * @example
+ * ### Repository with Default Adapter
+ * ```typescript
+ * // Analytics repository that always uses the 'analytics' adapter by default
+ * class AnalyticsRepository extends BaseRepository<Event> {
+ *   constructor(db: DatabaseServiceInterface) {
+ *     super(db, 'events', { adapter: 'analytics', schema: 'analytics' });
+ *   }
+ * }
+ *
+ * // All queries use analytics adapter by default
+ * await analyticsRepo.findById('event-123'); // Uses 'analytics' adapter
+ *
+ * // But can still override per-query
+ * await analyticsRepo.findById('event-123', { adapter: 'primary' });
+ * ```
+ *
+ * @example
  * ### Usage in Service Layer
  * ```typescript
  * class UserService {
  *   constructor(private userRepo: UserRepository) {}
  *
  *   async getUserById(id: string) {
- *     // Calls BaseRepository.findById() � DatabaseService.get()
+ *     // Calls BaseRepository.findById() → DatabaseService.get()
  *     return this.userRepo.findById(id);
  *   }
  * }
  * ```
  */
-export declare abstract class BaseRepository<T> {
-    protected readonly db: DatabaseServiceType;
+export declare abstract class BaseRepository<T extends Record<string, unknown>> {
+    protected readonly db: DatabaseServiceInterface;
     protected readonly tableName: string;
-    constructor(db: DatabaseServiceType, tableName: string);
+    protected readonly defaultConfig?: OperationConfig;
+    constructor(db: DatabaseServiceInterface, tableName: string, defaultConfig?: OperationConfig);
+    /**
+     * Merges default repository config with per-operation config
+     * Per-operation config takes precedence over default config
+     */
+    private mergeConfig;
     /**
      * Find a single entity by its primary key ID
      *
      * @param {string} id - The primary key ID of the entity to retrieve
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<T | null>>} Promise resolving to the entity or null if not found
      *
      * @example
@@ -81,13 +104,19 @@ export declare abstract class BaseRepository<T> {
      * if (result.success && result.value) {
      *   console.log('Found user:', result.value.name);
      * }
+     *
+     * // Use specific adapter for this query
+     * const analyticsResult = await userRepository.findById('user-123', {
+     *   adapter: 'analytics'
+     * });
      * ```
      */
-    findById(id: string): Promise<DatabaseResult<T | null>>;
+    findById(id: string, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
     /**
      * Find multiple entities with optional filtering, sorting, and pagination
      *
-     * @param {QueryOptions} [options] - Optional query configuration
+     * @param {QueryOptions<T>} [options] - Optional query configuration with type-safe fields
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<PaginatedResult<T>>>} Promise resolving to paginated results
      *
      * @example
@@ -97,13 +126,19 @@ export declare abstract class BaseRepository<T> {
      *   sort: [{ field: 'createdAt', direction: 'desc' }],
      *   pagination: { limit: 20, offset: 0 }
      * });
+     *
+     * // Query from analytics database
+     * const analyticsResult = await userRepository.findMany({}, {
+     *   adapter: 'analytics'
+     * });
      * ```
      */
-    findMany(options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    findMany(options?: QueryOptions<T>, config?: OperationConfig): Promise<DatabaseResult<PaginatedResult<T>>>;
     /**
      * Create a new entity in the database
      *
-     * @param {T} data - The entity data to create
+     * @param {CreateInput<T>} data - The entity data to create (id is auto-generated)
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<T>>} Promise resolving to the created entity
      *
      * @example
@@ -112,14 +147,23 @@ export declare abstract class BaseRepository<T> {
      *   name: 'John Doe',
      *   email: 'john@example.com'
      * });
+     *
+     * // Create in specific database/schema
+     * const result = await userRepository.create({
+     *   name: 'Jane Doe'
+     * }, {
+     *   adapter: 'secondary',
+     *   schema: 'backoffice'
+     * });
      * ```
      */
-    create(data: T): Promise<DatabaseResult<T>>;
+    create(data: CreateInput<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
     /**
      * Update an existing entity by ID
      *
      * @param {string} id - The primary key ID of the entity to update
      * @param {Partial<T>} data - Partial entity data containing fields to update
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<T>>} Promise resolving to the updated entity
      *
      * @example
@@ -128,13 +172,22 @@ export declare abstract class BaseRepository<T> {
      *   email: 'newemail@example.com',
      *   updatedAt: new Date()
      * });
+     *
+     * // Update in specific adapter with custom ID column
+     * const result = await userRepository.update('flag-key', {
+     *   value: true
+     * }, {
+     *   adapter: 'config',
+     *   idColumn: 'key'
+     * });
      * ```
      */
-    update(id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    update(id: string, data: Partial<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
     /**
      * Delete an entity by ID (hard delete)
      *
      * @param {string} id - The primary key ID of the entity to delete
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<void>>} Promise resolving when deletion is complete
      *
      * @warning This is a permanent operation that cannot be undone
@@ -143,13 +196,19 @@ export declare abstract class BaseRepository<T> {
      * @example
      * ```typescript
      * const result = await userRepository.delete('user-123');
+     *
+     * // Delete from specific adapter
+     * const result = await userRepository.delete('user-123', {
+     *   adapter: 'archive'
+     * });
      * ```
      */
-    delete(id: string): Promise<DatabaseResult<void>>;
+    delete(id: string, config?: OperationConfig): Promise<DatabaseResult<void>>;
     /**
      * Count entities matching optional filter criteria
      *
-     * @param {Filter} [filter] - Optional filter conditions
+     * @param {Filter<T>} [filter] - Optional filter conditions with type-safe fields
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<number>>} Promise resolving to the count
      *
      * @example
@@ -158,13 +217,19 @@ export declare abstract class BaseRepository<T> {
      * const activeResult = await userRepository.count({
      *   field: 'status', operator: 'eq', value: 'active'
      * });
+     *
+     * // Count in specific adapter
+     * const archiveCount = await userRepository.count(undefined, {
+     *   adapter: 'archive'
+     * });
      * ```
      */
-    count(filter?: Filter): Promise<DatabaseResult<number>>;
+    count(filter?: Filter<T>, config?: OperationConfig): Promise<DatabaseResult<number>>;
     /**
      * Check if an entity exists by ID
      *
      * @param {string} id - The primary key ID to check
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<boolean>>} Promise resolving to existence status
      *
      * @example
@@ -173,13 +238,19 @@ export declare abstract class BaseRepository<T> {
      * if (existsResult.success && existsResult.value) {
      *   console.log('User exists');
      * }
+     *
+     * // Check existence in specific adapter
+     * const existsInArchive = await userRepository.exists('user-123', {
+     *   adapter: 'archive'
+     * });
      * ```
      */
-    exists(id: string): Promise<DatabaseResult<boolean>>;
+    exists(id: string, config?: OperationConfig): Promise<DatabaseResult<boolean>>;
     /**
      * Find the first entity matching filter criteria
      *
-     * @param {Filter} filter - Filter conditions to match
+     * @param {Filter<T>} filter - Filter conditions with type-safe fields
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<T | null>>} Promise resolving to first match or null
      *
      * @example
@@ -187,13 +258,22 @@ export declare abstract class BaseRepository<T> {
      * const result = await userRepository.findOne({
      *   field: 'email', operator: 'eq', value: 'john@example.com'
      * });
+     *
+     * // Find in specific adapter
+     * const archivedUser = await userRepository.findOne({
+     *   field: 'email', operator: 'eq', value: 'john@example.com'
+     * }, {
+     *   adapter: 'archive',
+     *   includeSoftDeleted: true
+     * });
      * ```
      */
-    findOne(filter: Filter): Promise<DatabaseResult<T | null>>;
+    findOne(filter: Filter<T>, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
     /**
      * Soft delete an entity by ID (recoverable deletion)
      *
      * @param {string} id - The primary key ID of the entity to soft delete
+     * @param {OperationConfig} [config] - Optional per-operation configuration (adapter selection, schema override, etc.)
      * @returns {Promise<DatabaseResult<void>>} Promise resolving when soft deletion is complete
      *
      * @see {@link delete} For permanent deletion
@@ -202,8 +282,14 @@ export declare abstract class BaseRepository<T> {
      * ```typescript
      * const result = await userRepository.softDelete('user-123');
      * // User is hidden but can be recovered
+     *
+     * // Soft delete in specific adapter
+     * const result = await userRepository.softDelete('user-123', {
+     *   adapter: 'primary',
+     *   skipAudit: false
+     * });
      * ```
      */
-    softDelete(id: string): Promise<DatabaseResult<void>>;
+    softDelete(id: string, config?: OperationConfig): Promise<DatabaseResult<void>>;
 }
 //# sourceMappingURL=BaseRepository.d.ts.map

package/dist/repository/BaseRepository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseRepository.d.ts","sourceRoot":"","sources":["../../src/repository/BaseRepository.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,MAAM,EACN,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,8BAAsB,cAAc,CAAC,CAAC;IAIlC,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,mBAAmB;IAC1C,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;gBADjB,EAAE,EAAE,mBAAmB,EACvB,SAAS,EAAE,MAAM;IAGtC;;;;;;;;;;;;;OAaG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAI7D;;;;;;;;;;;;;;OAcG;IACG,QAAQ,CACZ,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAI9C;;;;;;;;;;;;;OAaG;IACG,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAIjD;;;;;;;;;;;;;;OAcG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAItE;;;;;;;;;;;;;OAaG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAIvD;;;;;;;;;;;;;OAaG;IACG,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAI7D;;;;;;;;;;;;;OAaG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAI1D;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAIhE;;;;;;;;;;;;;OAaG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;CAG5D"}
+{"version":3,"file":"BaseRepository.d.ts","sourceRoot":"","sources":["../../src/repository/BaseRepository.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,MAAM,EACN,wBAAwB,EACxB,WAAW,EACX,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,8BAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIlE,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,wBAAwB;IAC/C,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM;IAJtC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,eAAe,CAAC;gBAG9B,EAAE,EAAE,wBAAwB,EAC5B,SAAS,EAAE,MAAM,EACpC,aAAa,CAAC,EAAE,eAAe;IAKjC;;;OAGG;IACH,OAAO,CAAC,WAAW;IAYnB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,QAAQ,CACZ,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,QAAQ,CACZ,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAI9C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,MAAM,CACV,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EACpB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAI7B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAS7B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAIhC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,KAAK,CACT,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAClB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAIlC;;;;;;;;;;;;;;;;;;;OAmBG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAanC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,OAAO,CACX,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,UAAU,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;CAGjC"}

package/dist/seeds/SeedManager.d.ts

@@ -0,0 +1,96 @@
+/**
+ * SeedManager - Database seeding for development and testing
+ *
+ * Manages database seeding with support for ordered execution,
+ * seed history tracking, and idempotent seed operations.
+ * Automatically discovers seed files from a specified directory.
+ *
+ * @example
+ * ```typescript
+ * const seedManager = new SeedManager({
+ *   adapter: sqlAdapter,
+ *   seedsPath: './seeds', // default
+ *   tableName: 'seed_history' // default
+ * });
+ *
+ * // Run all seeds
+ * await seedManager.run();
+ *
+ * // Run specific seed
+ * await seedManager.run('users');
+ *
+ * // Clear all data (for testing)
+ * await seedManager.reset();
+ * ```
+ */
+import type { DatabaseResult, SeedRecord, SeedManagerConfig } from "@plyaz/types/db";
+/**
+ * SeedManager - Handles database seeding operations
+ *
+ * Discovers seed files, tracks seed history, and executes
+ * seeds in order with support for cleanup and reset.
+ */
+export declare class SeedManager {
+    private adapter;
+    private seedsPath;
+    private tableName;
+    private schema;
+    private skipExisting;
+    constructor(config: SeedManagerConfig);
+    /**
+     * Initialize seeds tracking table if it doesn't exist
+     */
+    initialize(): Promise<DatabaseResult<void>>;
+    /**
+     * Discover seed files from seeds directory
+     */
+    private discoverSeeds;
+    /**
+     * Load seed from file
+     */
+    private loadSeed;
+    /**
+     * Get executed seeds from database
+     */
+    private getExecutedSeeds;
+    /**
+     * Record seed as executed
+     */
+    private recordSeed;
+    /**
+     * Remove seed record (for reset)
+     */
+    private unrecordSeed;
+    /**
+     * Execute a seed function with optional transaction support
+     */
+    private executeSeed;
+    /**
+     * Check if a seed should be skipped and log if applicable
+     */
+    private shouldSkipSeed;
+    /**
+     * Run all seeds or a specific seed
+     */
+    run(seedName?: string): Promise<DatabaseResult<number>>;
+    /**
+     * Execute cleanup function with optional transaction support
+     */
+    private executeCleanup;
+    /**
+     * Reset all seeds (run cleanup functions)
+     */
+    reset(): Promise<DatabaseResult<number>>;
+    /**
+     * Get seed execution status
+     */
+    status(): Promise<DatabaseResult<{
+        executed: SeedRecord[];
+        pending: string[];
+    }>>;
+    /**
+     * Clear seed history (doesn't clean data, just removes tracking records)
+     */
+    clearHistory(): Promise<DatabaseResult<void>>;
+}
+//# sourceMappingURL=SeedManager.d.ts.map

package/dist/seeds/SeedManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeedManager.d.ts","sourceRoot":"","sources":["../../src/seeds/SeedManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAEV,cAAc,EAGd,UAAU,EACV,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAOzB;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAU;gBAElB,MAAM,EAAE,iBAAiB;IAYrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAiDjD;;OAEG;YACW,aAAa;IA0B3B;;OAEG;YACW,QAAQ;IAkBtB;;OAEG;YACW,gBAAgB;IAkB9B;;OAEG;YACW,UAAU;IAmBxB;;OAEG;YACW,YAAY;IAS1B;;OAEG;YACW,WAAW;IAUzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACG,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IA2C7D;;OAEG;YACW,cAAc;IAY5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAsC9C;;OAEG;IACG,MAAM,IAAI,OAAO,CACrB,cAAc,CAAC;QAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAC9D;IA2BD;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;CAgBpD"}

package/dist/seeds/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Database Seeds Module
+ *
+ * Provides seeding management for populating database with
+ * initial or test data, with history tracking and cleanup support.
+ *
+ * @module seeds
+ */
+export { SeedManager } from "./SeedManager";
+//# sourceMappingURL=index.d.ts.map

package/dist/seeds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/seeds/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}