@kysera/soft-delete 0.4.1 → 0.6.0

package/README.md

@@ -10,11 +10,11 @@
 
 | Metric | Value |
 |--------|-------|
-| **Version** | 0.3.0 |
-| **Bundle Size** | 477 B (minified) |
-| **Test Coverage** | 39 tests passing |
-| **Dependencies** | @kysera/repository (workspace) |
-| **Peer Dependencies** | kysely >=0.28.0 |
+| **Version** | 0.5.1 |
+| **Bundle Size** | ~4 KB (minified) |
+| **Test Coverage** | 39+ tests passing |
+| **Dependencies** | @kysera/core (workspace) |
+| **Peer Dependencies** | kysely >=0.28.8, @kysera/repository, zod ^4.1.13 (optional) |
 | **Target Runtimes** | Node.js 20+, Bun 1.0+, Deno |
 | **Module System** | ESM only |
 | **Database Support** | PostgreSQL, MySQL, SQLite |
@@ -261,7 +261,8 @@ const plugin = softDeletePlugin()
 const plugin = softDeletePlugin({
   deletedAtColumn: 'deleted_at',
   includeDeleted: false,
-  tables: undefined  // All tables
+  tables: undefined,  // All tables
+  primaryKeyColumn: 'id'  // Default primary key
 })
 ```
 
@@ -290,6 +291,43 @@ const plugin = softDeletePlugin({
 })
 ```
 
+### Custom Primary Key Column
+
+Configure tables with different primary key column names:
+
+```typescript
+// Example: Use "uuid" as primary key
+const plugin = softDeletePlugin({
+  primaryKeyColumn: 'uuid'
+})
+
+// Database schema
+interface Database {
+  users: {
+    uuid: Generated<string>  // ✅ Custom primary key
+    email: string
+    name: string
+    deleted_at: Date | null
+  }
+}
+
+// Example: Use "user_id"
+const plugin = softDeletePlugin({
+  primaryKeyColumn: 'user_id'
+})
+
+// Usage remains the same
+await userRepo.softDelete(userId)
+await userRepo.restore(userId)
+await userRepo.hardDelete(userId)
+```
+
+**When to use:**
+- Tables with UUID primary keys (`uuid`, `guid`)
+- Tables with composite naming (`user_id`, `post_id`)
+- Legacy databases with custom key columns
+- Multi-tenant systems with custom identifiers
+
 ### Table Filtering
 
 Apply soft delete only to specific tables:
@@ -343,7 +381,7 @@ The plugin extends repositories with these methods:
 Mark a record as deleted by setting `deleted_at` timestamp.
 
 ```typescript
-async softDelete(id: number): Promise<T>
+async softDelete(id: number | string): Promise<T>
 ```
 
 **Example:**
@@ -375,7 +413,7 @@ console.log(directQuery)  // Record exists with deleted_at set
 Restore a soft-deleted record by setting `deleted_at` to `null`.
 
 ```typescript
-async restore(id: number): Promise<T>
+async restore(id: number | string): Promise<T>
 ```
 
 **Example:**
@@ -405,7 +443,7 @@ const users = await userRepo.findAll()
 Permanently delete a record from the database (bypasses soft delete).
 
 ```typescript
-async hardDelete(id: number): Promise<void>
+async hardDelete(id: number | string): Promise<void>
 ```
 
 **Example:**
@@ -491,7 +529,7 @@ console.log(deleted[0].deleted_at)  // Not null
 Find a specific record including if soft-deleted.
 
 ```typescript
-async findWithDeleted(id: number): Promise<T | null>
+async findWithDeleted(id: number | string): Promise<T | null>
 ```
 
 **Example:**
@@ -634,24 +672,38 @@ await db.transaction().execute(async (trx) => {
 })
 ```
 
-### Bulk Operations
+### Batch Operations
+
+The plugin provides efficient batch operations for handling multiple records:
 
 ```typescript
-// Soft delete multiple records
+// ✅ Efficient: Single query batch operations
 const userIds = [1, 2, 3, 4, 5]
 
+// Soft delete multiple records (single UPDATE query)
+const deletedUsers = await userRepo.softDeleteMany(userIds)
+console.log(deletedUsers.length)  // 5
+
+// Restore multiple records (single UPDATE query)
+const restoredUsers = await userRepo.restoreMany(userIds)
+console.log(restoredUsers.length)  // 5
+
+// Hard delete multiple records (single DELETE query)
+await userRepo.hardDeleteMany(userIds)
+
+// ❌ Inefficient: Loop approach (N queries)
 for (const id of userIds) {
-  await userRepo.softDelete(id)
+  await userRepo.softDelete(id)  // 5 separate UPDATE queries
 }
-
-// Or use direct query for bulk
-await db
-  .updateTable('users')
-  .set({ deleted_at: sql`CURRENT_TIMESTAMP` })
-  .where('id', 'in', userIds)
-  .execute()
 ```
 
+**Performance Comparison:**
+- Loop: 100 records = 100 queries (~2000ms)
+- Batch: 100 records = 1 query (~20ms)
+- **100x faster! 🚀**
+
+**See [BATCH_OPERATIONS.md](./BATCH_OPERATIONS.md) for detailed documentation.**
+
 ### Conditional Soft Delete
 
 ```typescript
@@ -788,12 +840,12 @@ The plugin is fully type-safe with TypeScript.
 
 ```typescript
 interface SoftDeleteRepository<T> extends Repository<T> {
-  softDelete(id: number): Promise<T>
-  restore(id: number): Promise<T>
-  hardDelete(id: number): Promise<void>
+  softDelete(id: number | string): Promise<T>
+  restore(id: number | string): Promise<T>
+  hardDelete(id: number | string): Promise<void>
   findAllWithDeleted(): Promise<T[]>
   findDeleted(): Promise<T[]>
-  findWithDeleted(id: number): Promise<T | null>
+  findWithDeleted(id: number | string): Promise<T | null>
 }
 
 // Type-safe usage
@@ -843,6 +895,8 @@ interface SoftDeleteOptions {
   deletedAtColumn?: string    // Default: 'deleted_at'
   includeDeleted?: boolean    // Default: false
   tables?: string[]           // Default: undefined (all tables)
+  primaryKeyColumn?: string   // Default: 'id'
+  logger?: KyseraLogger       // Default: silentLogger (no output)
 }
 ```
 
@@ -866,7 +920,7 @@ const plugin = softDeletePlugin({
 Soft delete a record by ID.
 
 **Parameters:**
-- `id: number` - Record ID
+- `id: number | string` - Record ID
 
 **Returns:** `Promise<T>` - The soft-deleted record
 
@@ -879,7 +933,7 @@ Soft delete a record by ID.
 Restore a soft-deleted record.
 
 **Parameters:**
-- `id: number` - Record ID
+- `id: number | string` - Record ID
 
 **Returns:** `Promise<T>` - The restored record
 
@@ -890,7 +944,7 @@ Restore a soft-deleted record.
 Permanently delete a record.
 
 **Parameters:**
-- `id: number` - Record ID
+- `id: number | string` - Record ID
 
 **Returns:** `Promise<void>`
 
@@ -917,12 +971,65 @@ Find only soft-deleted records.
 Find a record by ID including if soft-deleted.
 
 **Parameters:**
-- `id: number` - Record ID
+- `id: number | string` - Record ID
 
 **Returns:** `Promise<T | null>`
 
 ---
 
+#### softDeleteMany(ids)
+
+Soft delete multiple records in a single query.
+
+**Parameters:**
+- `ids: (number | string)[]` - Array of record IDs
+
+**Returns:** `Promise<T[]>` - Array of soft-deleted records
+
+**Throws:** Error if any record not found
+
+**Example:**
+```typescript
+const deletedUsers = await userRepo.softDeleteMany([1, 2, 3, 4, 5])
+console.log(deletedUsers.length)  // 5
+```
+
+---
+
+#### restoreMany(ids)
+
+Restore multiple soft-deleted records in a single query.
+
+**Parameters:**
+- `ids: (number | string)[]` - Array of record IDs
+
+**Returns:** `Promise<T[]>` - Array of restored records
+
+**Example:**
+```typescript
+const restoredUsers = await userRepo.restoreMany([1, 2, 3])
+console.log(restoredUsers.every(u => u.deleted_at === null))  // true
+```
+
+---
+
+#### hardDeleteMany(ids)
+
+Permanently delete multiple records in a single query.
+
+**Parameters:**
+- `ids: (number | string)[]` - Array of record IDs
+
+**Returns:** `Promise<void>`
+
+**Example:**
+```typescript
+await userRepo.hardDeleteMany([1, 2, 3])
+// Records permanently removed from database
+```
+
+---
+
 ## ✨ Best Practices
 
 ### 1. Always Use Nullable deleted_at
@@ -1231,11 +1338,11 @@ MIT © Kysera
 
 ## 🔗 Links
 
-- [GitHub Repository](https://github.com/omnitron/kysera)
+- [GitHub Repository](https://github.com/kysera-dev/kysera)
 - [@kysera/repository Documentation](../repository/README.md)
 - [@kysera/core Documentation](../core/README.md)
 - [Kysely Documentation](https://kysely.dev)
-- [Issue Tracker](https://github.com/omnitron/kysera/issues)
+- [Issue Tracker](https://github.com/kysera-dev/kysera/issues)
 
 ---
 

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { Plugin } from '@kysera/repository';
+import { Repository, Plugin } from '@kysera/repository';
+import { KyseraLogger } from '@kysera/core';
+import { z } from 'zod';
 
 /**
  * Configuration options for the soft delete plugin.
@@ -8,7 +10,8 @@ import { Plugin } from '@kysera/repository';
  * const plugin = softDeletePlugin({
  *   deletedAtColumn: 'deleted_at',
  *   includeDeleted: false,
- *   tables: ['users', 'posts'] // Only these tables support soft delete
+ *   tables: ['users', 'posts'], // Only these tables support soft delete
+ *   primaryKeyColumn: 'id' // Default primary key column
  * })
  * ```
  */
@@ -33,7 +36,50 @@ interface SoftDeleteOptions {
      * @example ['users', 'posts', 'comments']
      */
     tables?: string[];
+    /**
+     * Primary key column name used for identifying records.
+     * Tables with different primary key names (uuid, user_id, etc.) can be configured.
+     *
+     * @default 'id'
+     * @example 'uuid', 'user_id', 'post_id'
+     */
+    primaryKeyColumn?: string;
+    /**
+     * Logger for plugin operations.
+     * Uses KyseraLogger interface from @kysera/core.
+     *
+     * @default silentLogger (no output)
+     */
+    logger?: KyseraLogger;
 }
+/**
+ * Zod schema for SoftDeleteOptions
+ * Used for validation and configuration in the kysera-cli
+ */
+declare const SoftDeleteOptionsSchema: z.ZodObject<{
+    deletedAtColumn: z.ZodOptional<z.ZodString>;
+    includeDeleted: z.ZodOptional<z.ZodBoolean>;
+    tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    primaryKeyColumn: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Methods added to repositories by the soft delete plugin
+ */
+interface SoftDeleteMethods<T> {
+    softDelete(id: number | string): Promise<T>;
+    restore(id: number | string): Promise<T>;
+    hardDelete(id: number | string): Promise<void>;
+    findWithDeleted(id: number | string): Promise<T | null>;
+    findAllWithDeleted(): Promise<T[]>;
+    findDeleted(): Promise<T[]>;
+    softDeleteMany(ids: (number | string)[]): Promise<T[]>;
+    restoreMany(ids: (number | string)[]): Promise<T[]>;
+    hardDeleteMany(ids: (number | string)[]): Promise<void>;
+}
+/**
+ * Repository extended with soft delete methods
+ */
+type SoftDeleteRepository<Entity, DB> = Repository<Entity, DB> & SoftDeleteMethods<Entity>;
 /**
  * Soft Delete Plugin for Kysera ORM
  *
@@ -82,9 +128,50 @@ interface SoftDeleteOptions {
  *
  * This design is intentional for simplicity and explicitness.
  *
+ * ## Transaction Behavior
+ *
+ * **IMPORTANT**: Soft delete operations respect ACID properties and work correctly with transactions:
+ *
+ * - ✅ **Commits with transaction**: softDelete/restore operations use the same executor
+ *   as other repository operations, so they commit together
+ * - ✅ **Rolls back with transaction**: If a transaction is rolled back, soft delete
+ *   operations are also rolled back
+ * - ✅ **Atomic operations**: All soft delete operations (including bulk) are atomic
+ *
+ * ### Correct Transaction Usage
+ *
+ * ```typescript
+ * // ✅ CORRECT: Soft delete is part of transaction
+ * await db.transaction().execute(async (trx) => {
+ *   const repos = createRepositories(trx)  // Use transaction executor
+ *   await repos.users.softDelete(1)
+ *   await repos.posts.softDeleteMany([1, 2, 3])
+ *   // If transaction rolls back, both operations roll back
+ * })
+ * ```
+ *
+ * ### Cascade Soft Delete Pattern
+ *
+ * For related entities, you need to manually implement cascade soft delete:
+ *
+ * ```typescript
+ * // Cascade soft delete pattern
+ * await db.transaction().execute(async (trx) => {
+ *   const repos = createRepositories(trx)
+ *   const userId = 123
+ *
+ *   // First, soft delete child records
+ *   const userPosts = await repos.posts.findBy({ user_id: userId })
+ *   await repos.posts.softDeleteMany(userPosts.map(p => p.id))
+ *
+ *   // Then, soft delete parent
+ *   await repos.users.softDelete(userId)
+ * })
+ * ```
+ *
  * @param options - Configuration options for soft delete behavior
  * @returns Plugin instance that can be used with createORM
  */
 declare const softDeletePlugin: (options?: SoftDeleteOptions) => Plugin;
 
-export { type SoftDeleteOptions, softDeletePlugin };
+export { type SoftDeleteMethods, type SoftDeleteOptions, SoftDeleteOptionsSchema, type SoftDeleteRepository, softDeletePlugin };

package/dist/index.js

@@ -1,2 +1,2 @@
-import {sql}from'kysely';var y=(u={})=>{let{deletedAtColumn:t="deleted_at",includeDeleted:o=false,tables:s}=u;return {name:"@kysera/soft-delete",version:"1.0.0",interceptQuery(r,e){return (!s||s.includes(e.table))&&e.operation==="select"&&!e.metadata.includeDeleted&&!o?r.where(`${e.table}.${t}`,"is",null):r},extendRepository(r){let e=r;if(!("tableName"in e)||!("executor"in e)||!(!s||s.includes(e.tableName)))return r;let a=e.findAll.bind(e),l=e.findById.bind(e);return {...e,async findAll(){return o?await a():await e.executor.selectFrom(e.tableName).selectAll().where(t,"is",null).execute()},async findById(n){return o?await l(n):await e.executor.selectFrom(e.tableName).selectAll().where("id","=",n).where(t,"is",null).executeTakeFirst()??null},async softDelete(n){await e.executor.updateTable(e.tableName).set({[t]:sql`CURRENT_TIMESTAMP`}).where("id","=",n).execute();let i=await l(n);if(!i)throw new Error(`Record with id ${n} not found`);return i},async restore(n){return await e.update(n,{[t]:null})},async hardDelete(n){await e.executor.deleteFrom(e.tableName).where("id","=",n).execute();},async findWithDeleted(n){return await l(n)},async findAllWithDeleted(){return await a()},async findDeleted(){return await e.executor.selectFrom(e.tableName).selectAll().where(t,"is not",null).execute()}}}}};export{y as softDeletePlugin};//# sourceMappingURL=index.js.map
+import {sql}from'kysely';import {silentLogger,NotFoundError}from'@kysera/core';import {z}from'zod';var N=z.object({deletedAtColumn:z.string().optional(),includeDeleted:z.boolean().optional(),tables:z.array(z.string()).optional(),primaryKeyColumn:z.string().optional()}),P=(y={})=>{let{deletedAtColumn:s="deleted_at",includeDeleted:d=false,tables:i,primaryKeyColumn:r="id",logger:o=silentLogger}=y;return {name:"@kysera/soft-delete",version:"0.5.1",interceptQuery(a,e){return (!i||i.includes(e.table))&&e.operation==="select"&&!e.metadata.includeDeleted&&!d?(o.debug(`Filtering soft-deleted records from ${e.table}`),a.where(`${e.table}.${s}`,"is",null)):a},extendRepository(a){let e=a;if(!("tableName"in e)||!("executor"in e))return a;if(!(!i||i.includes(e.tableName)))return o.debug(`Table ${e.tableName} does not support soft delete, skipping extension`),a;o.debug(`Extending repository for table ${e.tableName} with soft delete methods`);let f=e.findAll.bind(e),u=e.findById.bind(e);return {...e,async findAll(){return d?await f():await e.executor.selectFrom(e.tableName).selectAll().where(s,"is",null).execute()},async findById(t){return d?r!=="id"?await e.executor.selectFrom(e.tableName).selectAll().where(r,"=",t).executeTakeFirst()??null:await u(t):await e.executor.selectFrom(e.tableName).selectAll().where(r,"=",t).where(s,"is",null).executeTakeFirst()??null},async softDelete(t){o.info(`Soft deleting record ${t} from ${e.tableName}`),await e.executor.updateTable(e.tableName).set({[s]:sql`CURRENT_TIMESTAMP`}).where(r,"=",t).execute();let n;if(r!=="id"?n=await e.executor.selectFrom(e.tableName).selectAll().where(r,"=",t).executeTakeFirst():n=await u(t),!n)throw o.warn(`Record ${t} not found in ${e.tableName} for soft delete`),new NotFoundError("Record",{id:t});return n},async restore(t){o.info(`Restoring soft-deleted record ${t} from ${e.tableName}`),await e.executor.updateTable(e.tableName).set({[s]:null}).where(r,"=",t).execute();let n;if(r!=="id"?n=await e.executor.selectFrom(e.tableName).selectAll().where(r,"=",t).executeTakeFirst():n=await u(t),!n)throw o.warn(`Record ${t} not found in ${e.tableName} for restore`),new NotFoundError("Record",{id:t});return n},async hardDelete(t){o.info(`Hard deleting record ${t} from ${e.tableName}`),await e.executor.deleteFrom(e.tableName).where(r,"=",t).execute();},async findWithDeleted(t){return r!=="id"?await e.executor.selectFrom(e.tableName).selectAll().where(r,"=",t).executeTakeFirst()??null:await u(t)},async findAllWithDeleted(){return await f()},async findDeleted(){return await e.executor.selectFrom(e.tableName).selectAll().where(s,"is not",null).execute()},async softDeleteMany(t){if(t.length===0)return [];o.info(`Soft deleting ${t.length} records from ${e.tableName}`),await e.executor.updateTable(e.tableName).set({[s]:sql`CURRENT_TIMESTAMP`}).where(r,"in",t).execute();let n=await e.executor.selectFrom(e.tableName).selectAll().where(r,"in",t).execute();if(n.length!==t.length){let p=n.map(c=>c[r]),w=t.filter(c=>!p.includes(c));throw o.warn(`Some records not found for soft delete: ${w.join(", ")}`),new NotFoundError("Records",{ids:w})}return n},async restoreMany(t){return t.length===0?[]:(o.info(`Restoring ${t.length} soft-deleted records from ${e.tableName}`),await e.executor.updateTable(e.tableName).set({[s]:null}).where(r,"in",t).execute(),await e.executor.selectFrom(e.tableName).selectAll().where(r,"in",t).execute())},async hardDeleteMany(t){t.length!==0&&(o.info(`Hard deleting ${t.length} records from ${e.tableName}`),await e.executor.deleteFrom(e.tableName).where(r,"in",t).execute());}}}}};export{N as SoftDeleteOptionsSchema,P as softDeletePlugin};//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["softDeletePlugin","options","deletedAtColumn","includeDeleted","tables","qb","context","repo","baseRepo","originalFindAll","originalFindById","id","sql","record"],"mappings":"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","file":"index.js","sourcesContent":["import type { Plugin, AnyQueryBuilder } from '@kysera/repository'\nimport type { SelectQueryBuilder, Kysely } from 'kysely'\nimport { sql } from 'kysely'\n\n/**\n * Configuration options for the soft delete plugin.\n *\n * @example\n * ```typescript\n * const plugin = softDeletePlugin({\n *   deletedAtColumn: 'deleted_at',\n *   includeDeleted: false,\n *   tables: ['users', 'posts'] // Only these tables support soft delete\n * })\n * ```\n */\nexport interface SoftDeleteOptions {\n  /**\n   * Column name for soft delete timestamp.\n   *\n   * @default 'deleted_at'\n   */\n  deletedAtColumn?: string\n\n  /**\n   * Include deleted records by default in queries.\n   * When false, soft-deleted records are automatically filtered out.\n   *\n   * @default false\n   */\n  includeDeleted?: boolean\n\n  /**\n   * List of tables that support soft delete.\n   * If not provided, all tables are assumed to support it.\n   *\n   * @example ['users', 'posts', 'comments']\n   */\n  tables?: string[]\n}\n\ninterface BaseRepository {\n  tableName: string\n  executor: Kysely<Record<string, unknown>>\n  findAll: () => Promise<unknown[]>\n  findById: (id: number) => Promise<unknown>\n  update: (id: number, data: Record<string, unknown>) => Promise<unknown>\n}\n\n/**\n * Soft Delete Plugin for Kysera ORM\n *\n * This plugin implements soft delete functionality using the Method Override pattern:\n * - Automatically filters out soft-deleted records from SELECT queries\n * - Adds softDelete(), restore(), and hardDelete() methods to repositories\n * - Provides findWithDeleted() and findDeleted() utility methods\n *\n * ## Usage\n *\n * ```typescript\n * import { softDeletePlugin } from '@kysera/soft-delete'\n * import { createORM } from '@kysera/repository'\n *\n * const orm = await createORM(db, [\n *   softDeletePlugin({\n *     deletedAtColumn: 'deleted_at',\n *     tables: ['users', 'posts']\n *   })\n * ])\n *\n * const userRepo = orm.createRepository(createUserRepository)\n *\n * // Soft delete a user (sets deleted_at)\n * await userRepo.softDelete(1)\n *\n * // Find all users (excludes soft-deleted)\n * await userRepo.findAll()\n *\n * // Find including deleted\n * await userRepo.findAllWithDeleted()\n *\n * // Restore a soft-deleted user\n * await userRepo.restore(1)\n *\n * // Permanently delete (real DELETE)\n * await userRepo.hardDelete(1)\n * ```\n *\n * ## Architecture Note\n *\n * This plugin uses Method Override, not full query interception:\n * - ✅ SELECT queries are automatically filtered\n * - ❌ DELETE queries are NOT automatically converted to soft deletes\n * - Use softDelete() method explicitly instead of delete()\n *\n * This design is intentional for simplicity and explicitness.\n *\n * @param options - Configuration options for soft delete behavior\n * @returns Plugin instance that can be used with createORM\n */\nexport const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {\n  const {\n    deletedAtColumn = 'deleted_at',\n    includeDeleted = false,\n    tables\n  } = options\n\n  return {\n    name: '@kysera/soft-delete',\n    version: '1.0.0',\n\n    /**\n     * Intercept queries to automatically filter soft-deleted records.\n     *\n     * NOTE: This plugin uses the Method Override pattern, not full query interception.\n     * - SELECT queries are automatically filtered to exclude soft-deleted records\n     * - DELETE operations are NOT automatically converted to soft deletes\n     * - Use the softDelete() method instead of delete() to perform soft deletes\n     * - Use hardDelete() method to bypass soft delete and perform a real DELETE\n     *\n     * This approach is simpler and more explicit than full query interception.\n     */\n    interceptQuery<QB extends AnyQueryBuilder>(qb: QB, context: { operation: string; table: string; metadata: Record<string, unknown> }): QB {\n      // Check if table supports soft delete\n      const supportsSoftDelete = !tables || tables.includes(context.table)\n\n      // Only filter SELECT queries when not explicitly including deleted\n      if (\n        supportsSoftDelete &&\n        context.operation === 'select' &&\n        !context.metadata['includeDeleted'] &&\n        !includeDeleted\n      ) {\n        // Add WHERE deleted_at IS NULL to the query builder\n        type GenericSelectQueryBuilder = SelectQueryBuilder<\n          Record<string, unknown>,\n          string,\n          Record<string, unknown>\n        >\n        return (qb as unknown as GenericSelectQueryBuilder)\n          .where(`${context.table}.${deletedAtColumn}` as never, 'is', null) as QB\n      }\n\n      // Note: DELETE operations are NOT intercepted here\n      // Use softDelete() method instead of delete() to perform soft deletes\n      // This is by design - method override is simpler and more explicit\n\n      return qb\n    },\n\n    /**\n     * Extend repository with soft delete methods.\n     *\n     * Adds the following methods to repositories:\n     * - softDelete(id): Marks record as deleted by setting deleted_at timestamp\n     * - restore(id): Restores a soft-deleted record by setting deleted_at to null\n     * - hardDelete(id): Permanently deletes a record (bypasses soft delete)\n     * - findWithDeleted(id): Find a record including soft-deleted ones\n     * - findAllWithDeleted(): Find all records including soft-deleted ones\n     * - findDeleted(): Find only soft-deleted records\n     *\n     * Also overrides findAll() and findById() to automatically filter out\n     * soft-deleted records (unless includeDeleted option is set).\n     */\n    extendRepository<T extends object>(repo: T): T {\n      // Type assertion is safe here as we're checking for BaseRepository properties\n      const baseRepo = repo as unknown as BaseRepository\n\n      // Check if it's actually a repository (has required properties)\n      if (!('tableName' in baseRepo) || !('executor' in baseRepo)) {\n        return repo\n      }\n\n      // Check if table supports soft delete\n      const supportsSoftDelete = !tables || tables.includes(baseRepo.tableName)\n\n      // If table doesn't support soft delete, return unmodified repo\n      if (!supportsSoftDelete) {\n        return repo\n      }\n\n      // Wrap original methods to apply soft delete filtering\n      const originalFindAll = baseRepo.findAll.bind(baseRepo)\n      const originalFindById = baseRepo.findById.bind(baseRepo)\n\n      const extendedRepo = {\n        ...baseRepo,\n\n        // Override base methods to filter soft-deleted records\n        async findAll(): Promise<unknown[]> {\n          if (!includeDeleted) {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(deletedAtColumn as never, 'is', null)\n              .execute()\n            return result as unknown[]\n          }\n          return await originalFindAll()\n        },\n\n        async findById(id: number): Promise<unknown> {\n          if (!includeDeleted) {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where('id' as never, '=', id as never)\n              .where(deletedAtColumn as never, 'is', null)\n              .executeTakeFirst()\n            return result ?? null\n          }\n          return await originalFindById(id)\n        },\n\n        async softDelete(id: number): Promise<unknown> {\n          // Use CURRENT_TIMESTAMP directly in SQL to avoid datetime format issues\n          // This works across all databases (MySQL, PostgreSQL, SQLite)\n          // We bypass repository.update() to avoid Zod validation issues with RawBuilder\n          await baseRepo.executor\n            .updateTable(baseRepo.tableName)\n            .set({ [deletedAtColumn]: sql`CURRENT_TIMESTAMP` } as never)\n            .where('id' as never, '=', id as never)\n            .execute()\n\n          // Fetch the updated record to verify it exists\n          const record = await originalFindById(id)\n\n          // If record not found or deleted_at not set, throw error\n          if (!record) {\n            throw new Error(`Record with id ${id} not found`)\n          }\n\n          return record\n        },\n\n        async restore(id: number): Promise<unknown> {\n          return await baseRepo.update(id, { [deletedAtColumn]: null })\n        },\n\n        async hardDelete(id: number): Promise<void> {\n          // Direct hard delete - bypass soft delete\n          await baseRepo.executor\n            .deleteFrom(baseRepo.tableName)\n            .where('id' as never, '=', id as never)\n            .execute()\n        },\n\n        async findWithDeleted(id: number): Promise<unknown> {\n          // Use original method without filtering\n          return await originalFindById(id)\n        },\n\n        async findAllWithDeleted(): Promise<unknown[]> {\n          // Use original method without filtering\n          return await originalFindAll()\n        },\n\n        async findDeleted(): Promise<unknown[]> {\n          const result = await baseRepo.executor\n            .selectFrom(baseRepo.tableName)\n            .selectAll()\n            .where(deletedAtColumn as never, 'is not', null)\n            .execute()\n          return result as unknown[]\n        }\n      }\n\n      return extendedRepo as T\n    }\n  }\n}"]}
+{"version":3,"sources":["../src/index.ts"],"names":["SoftDeleteOptionsSchema","z","softDeletePlugin","options","deletedAtColumn","includeDeleted","tables","primaryKeyColumn","logger","silentLogger","qb","context","repo","baseRepo","originalFindAll","originalFindById","id","sql","record","NotFoundError","ids","records","foundIds","r","missingIds"],"mappings":"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","file":"index.js","sourcesContent":["import type { Plugin, AnyQueryBuilder, Repository } from '@kysera/repository';\nimport type { SelectQueryBuilder, Kysely } from 'kysely';\nimport { sql } from 'kysely';\nimport { NotFoundError, silentLogger } from '@kysera/core';\nimport type { KyseraLogger } from '@kysera/core';\nimport { z } from 'zod';\n\n/**\n * Configuration options for the soft delete plugin.\n *\n * @example\n * ```typescript\n * const plugin = softDeletePlugin({\n *   deletedAtColumn: 'deleted_at',\n *   includeDeleted: false,\n *   tables: ['users', 'posts'], // Only these tables support soft delete\n *   primaryKeyColumn: 'id' // Default primary key column\n * })\n * ```\n */\nexport interface SoftDeleteOptions {\n  /**\n   * Column name for soft delete timestamp.\n   *\n   * @default 'deleted_at'\n   */\n  deletedAtColumn?: string;\n\n  /**\n   * Include deleted records by default in queries.\n   * When false, soft-deleted records are automatically filtered out.\n   *\n   * @default false\n   */\n  includeDeleted?: boolean;\n\n  /**\n   * List of tables that support soft delete.\n   * If not provided, all tables are assumed to support it.\n   *\n   * @example ['users', 'posts', 'comments']\n   */\n  tables?: string[];\n\n  /**\n   * Primary key column name used for identifying records.\n   * Tables with different primary key names (uuid, user_id, etc.) can be configured.\n   *\n   * @default 'id'\n   * @example 'uuid', 'user_id', 'post_id'\n   */\n  primaryKeyColumn?: string;\n\n  /**\n   * Logger for plugin operations.\n   * Uses KyseraLogger interface from @kysera/core.\n   *\n   * @default silentLogger (no output)\n   */\n  logger?: KyseraLogger;\n}\n\n/**\n * Zod schema for SoftDeleteOptions\n * Used for validation and configuration in the kysera-cli\n */\nexport const SoftDeleteOptionsSchema = z.object({\n  deletedAtColumn: z.string().optional(),\n  includeDeleted: z.boolean().optional(),\n  tables: z.array(z.string()).optional(),\n  primaryKeyColumn: z.string().optional(),\n});\n\n/**\n * Methods added to repositories by the soft delete plugin\n */\nexport interface SoftDeleteMethods<T> {\n  softDelete(id: number | string): Promise<T>;\n  restore(id: number | string): Promise<T>;\n  hardDelete(id: number | string): Promise<void>;\n  findWithDeleted(id: number | string): Promise<T | null>;\n  findAllWithDeleted(): Promise<T[]>;\n  findDeleted(): Promise<T[]>;\n  softDeleteMany(ids: (number | string)[]): Promise<T[]>;\n  restoreMany(ids: (number | string)[]): Promise<T[]>;\n  hardDeleteMany(ids: (number | string)[]): Promise<void>;\n}\n\n/**\n * Repository extended with soft delete methods\n */\nexport type SoftDeleteRepository<Entity, DB> = Repository<Entity, DB> & SoftDeleteMethods<Entity>;\n\ninterface BaseRepository {\n  tableName: string;\n  executor: Kysely<Record<string, unknown>>;\n  findAll: () => Promise<unknown[]>;\n  findById: (id: number) => Promise<unknown>;\n  update: (id: number, data: Record<string, unknown>) => Promise<unknown>;\n}\n\n/**\n * Soft Delete Plugin for Kysera ORM\n *\n * This plugin implements soft delete functionality using the Method Override pattern:\n * - Automatically filters out soft-deleted records from SELECT queries\n * - Adds softDelete(), restore(), and hardDelete() methods to repositories\n * - Provides findWithDeleted() and findDeleted() utility methods\n *\n * ## Usage\n *\n * ```typescript\n * import { softDeletePlugin } from '@kysera/soft-delete'\n * import { createORM } from '@kysera/repository'\n *\n * const orm = await createORM(db, [\n *   softDeletePlugin({\n *     deletedAtColumn: 'deleted_at',\n *     tables: ['users', 'posts']\n *   })\n * ])\n *\n * const userRepo = orm.createRepository(createUserRepository)\n *\n * // Soft delete a user (sets deleted_at)\n * await userRepo.softDelete(1)\n *\n * // Find all users (excludes soft-deleted)\n * await userRepo.findAll()\n *\n * // Find including deleted\n * await userRepo.findAllWithDeleted()\n *\n * // Restore a soft-deleted user\n * await userRepo.restore(1)\n *\n * // Permanently delete (real DELETE)\n * await userRepo.hardDelete(1)\n * ```\n *\n * ## Architecture Note\n *\n * This plugin uses Method Override, not full query interception:\n * - ✅ SELECT queries are automatically filtered\n * - ❌ DELETE queries are NOT automatically converted to soft deletes\n * - Use softDelete() method explicitly instead of delete()\n *\n * This design is intentional for simplicity and explicitness.\n *\n * ## Transaction Behavior\n *\n * **IMPORTANT**: Soft delete operations respect ACID properties and work correctly with transactions:\n *\n * - ✅ **Commits with transaction**: softDelete/restore operations use the same executor\n *   as other repository operations, so they commit together\n * - ✅ **Rolls back with transaction**: If a transaction is rolled back, soft delete\n *   operations are also rolled back\n * - ✅ **Atomic operations**: All soft delete operations (including bulk) are atomic\n *\n * ### Correct Transaction Usage\n *\n * ```typescript\n * // ✅ CORRECT: Soft delete is part of transaction\n * await db.transaction().execute(async (trx) => {\n *   const repos = createRepositories(trx)  // Use transaction executor\n *   await repos.users.softDelete(1)\n *   await repos.posts.softDeleteMany([1, 2, 3])\n *   // If transaction rolls back, both operations roll back\n * })\n * ```\n *\n * ### Cascade Soft Delete Pattern\n *\n * For related entities, you need to manually implement cascade soft delete:\n *\n * ```typescript\n * // Cascade soft delete pattern\n * await db.transaction().execute(async (trx) => {\n *   const repos = createRepositories(trx)\n *   const userId = 123\n *\n *   // First, soft delete child records\n *   const userPosts = await repos.posts.findBy({ user_id: userId })\n *   await repos.posts.softDeleteMany(userPosts.map(p => p.id))\n *\n *   // Then, soft delete parent\n *   await repos.users.softDelete(userId)\n * })\n * ```\n *\n * @param options - Configuration options for soft delete behavior\n * @returns Plugin instance that can be used with createORM\n */\nexport const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {\n  const {\n    deletedAtColumn = 'deleted_at',\n    includeDeleted = false,\n    tables,\n    primaryKeyColumn = 'id',\n    logger = silentLogger,\n  } = options;\n\n  return {\n    name: '@kysera/soft-delete',\n    version: '0.5.1',\n\n    /**\n     * Intercept queries to automatically filter soft-deleted records.\n     *\n     * NOTE: This plugin uses the Method Override pattern, not full query interception.\n     * - SELECT queries are automatically filtered to exclude soft-deleted records\n     * - DELETE operations are NOT automatically converted to soft deletes\n     * - Use the softDelete() method instead of delete() to perform soft deletes\n     * - Use hardDelete() method to bypass soft delete and perform a real DELETE\n     *\n     * This approach is simpler and more explicit than full query interception.\n     */\n    interceptQuery<QB extends AnyQueryBuilder>(\n      qb: QB,\n      context: { operation: string; table: string; metadata: Record<string, unknown> }\n    ): QB {\n      // Check if table supports soft delete\n      const supportsSoftDelete = !tables || tables.includes(context.table);\n\n      // Only filter SELECT queries when not explicitly including deleted\n      if (\n        supportsSoftDelete &&\n        context.operation === 'select' &&\n        !context.metadata['includeDeleted'] &&\n        !includeDeleted\n      ) {\n        logger.debug(`Filtering soft-deleted records from ${context.table}`);\n        // Add WHERE deleted_at IS NULL to the query builder\n        type GenericSelectQueryBuilder = SelectQueryBuilder<Record<string, unknown>, string, Record<string, unknown>>;\n        return (qb as unknown as GenericSelectQueryBuilder).where(\n          `${context.table}.${deletedAtColumn}` as never,\n          'is',\n          null\n        ) as QB;\n      }\n\n      // Note: DELETE operations are NOT intercepted here\n      // Use softDelete() method instead of delete() to perform soft deletes\n      // This is by design - method override is simpler and more explicit\n\n      return qb;\n    },\n\n    /**\n     * Extend repository with soft delete methods.\n     *\n     * Adds the following methods to repositories:\n     * - softDelete(id): Marks record as deleted by setting deleted_at timestamp\n     * - restore(id): Restores a soft-deleted record by setting deleted_at to null\n     * - hardDelete(id): Permanently deletes a record (bypasses soft delete)\n     * - findWithDeleted(id): Find a record including soft-deleted ones\n     * - findAllWithDeleted(): Find all records including soft-deleted ones\n     * - findDeleted(): Find only soft-deleted records\n     * - softDeleteMany(ids): Soft delete multiple records (bulk operation)\n     * - restoreMany(ids): Restore multiple soft-deleted records (bulk operation)\n     * - hardDeleteMany(ids): Permanently delete multiple records (bulk operation)\n     *\n     * Also overrides findAll() and findById() to automatically filter out\n     * soft-deleted records (unless includeDeleted option is set).\n     */\n    extendRepository<T extends object>(repo: T): T {\n      // Type assertion is safe here as we're checking for BaseRepository properties\n      const baseRepo = repo as unknown as BaseRepository;\n\n      // Check if it's actually a repository (has required properties)\n      if (!('tableName' in baseRepo) || !('executor' in baseRepo)) {\n        return repo;\n      }\n\n      // Check if table supports soft delete\n      const supportsSoftDelete = !tables || tables.includes(baseRepo.tableName);\n\n      // If table doesn't support soft delete, return unmodified repo\n      if (!supportsSoftDelete) {\n        logger.debug(`Table ${baseRepo.tableName} does not support soft delete, skipping extension`);\n        return repo;\n      }\n\n      logger.debug(`Extending repository for table ${baseRepo.tableName} with soft delete methods`);\n\n      // Wrap original methods to apply soft delete filtering\n      const originalFindAll = baseRepo.findAll.bind(baseRepo);\n      const originalFindById = baseRepo.findById.bind(baseRepo);\n\n      const extendedRepo = {\n        ...baseRepo,\n\n        // Override base methods to filter soft-deleted records\n        async findAll(): Promise<unknown[]> {\n          if (!includeDeleted) {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(deletedAtColumn as never, 'is', null)\n              .execute();\n            return result as unknown[];\n          }\n          return await originalFindAll();\n        },\n\n        async findById(id: number): Promise<unknown> {\n          if (!includeDeleted) {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(primaryKeyColumn as never, '=', id as never)\n              .where(deletedAtColumn as never, 'is', null)\n              .executeTakeFirst();\n            return result ?? null;\n          }\n          // When includeDeleted is true, use custom PK column if configured\n          // Otherwise fall back to original method (which uses 'id')\n          if (primaryKeyColumn !== 'id') {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(primaryKeyColumn as never, '=', id as never)\n              .executeTakeFirst();\n            return result ?? null;\n          }\n          return await originalFindById(id);\n        },\n\n        async softDelete(id: number): Promise<unknown> {\n          logger.info(`Soft deleting record ${id} from ${baseRepo.tableName}`);\n          // Use CURRENT_TIMESTAMP directly in SQL to avoid datetime format issues\n          // This works across all databases (MySQL, PostgreSQL, SQLite)\n          // We bypass repository.update() to avoid Zod validation issues with RawBuilder\n          await baseRepo.executor\n            .updateTable(baseRepo.tableName)\n            .set({ [deletedAtColumn]: sql`CURRENT_TIMESTAMP` } as never)\n            .where(primaryKeyColumn as never, '=', id as never)\n            .execute();\n\n          // Fetch the updated record to verify it exists\n          // Use custom PK column if configured\n          let record;\n          if (primaryKeyColumn !== 'id') {\n            record = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(primaryKeyColumn as never, '=', id as never)\n              .executeTakeFirst();\n          } else {\n            record = await originalFindById(id);\n          }\n\n          // If record not found or deleted_at not set, throw error\n          if (!record) {\n            logger.warn(`Record ${id} not found in ${baseRepo.tableName} for soft delete`);\n            throw new NotFoundError('Record', { id });\n          }\n\n          return record;\n        },\n\n        async restore(id: number): Promise<unknown> {\n          logger.info(`Restoring soft-deleted record ${id} from ${baseRepo.tableName}`);\n          // Use direct executor to support custom primary key columns\n          await baseRepo.executor\n            .updateTable(baseRepo.tableName)\n            .set({ [deletedAtColumn]: null } as never)\n            .where(primaryKeyColumn as never, '=', id as never)\n            .execute();\n\n          // Fetch and return the restored record\n          let record;\n          if (primaryKeyColumn !== 'id') {\n            record = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(primaryKeyColumn as never, '=', id as never)\n              .executeTakeFirst();\n          } else {\n            record = await originalFindById(id);\n          }\n\n          if (!record) {\n            logger.warn(`Record ${id} not found in ${baseRepo.tableName} for restore`);\n            throw new NotFoundError('Record', { id });\n          }\n\n          return record;\n        },\n\n        async hardDelete(id: number): Promise<void> {\n          logger.info(`Hard deleting record ${id} from ${baseRepo.tableName}`);\n          // Direct hard delete - bypass soft delete\n          await baseRepo.executor\n            .deleteFrom(baseRepo.tableName)\n            .where(primaryKeyColumn as never, '=', id as never)\n            .execute();\n        },\n\n        async findWithDeleted(id: number): Promise<unknown> {\n          // Use custom PK column if configured, otherwise use original method\n          if (primaryKeyColumn !== 'id') {\n            const result = await baseRepo.executor\n              .selectFrom(baseRepo.tableName)\n              .selectAll()\n              .where(primaryKeyColumn as never, '=', id as never)\n              .executeTakeFirst();\n            return result ?? null;\n          }\n          return await originalFindById(id);\n        },\n\n        async findAllWithDeleted(): Promise<unknown[]> {\n          // Use original method without filtering\n          return await originalFindAll();\n        },\n\n        async findDeleted(): Promise<unknown[]> {\n          const result = await baseRepo.executor\n            .selectFrom(baseRepo.tableName)\n            .selectAll()\n            .where(deletedAtColumn as never, 'is not', null)\n            .execute();\n          return result as unknown[];\n        },\n\n        async softDeleteMany(ids: (number | string)[]): Promise<unknown[]> {\n          // Handle empty arrays gracefully\n          if (ids.length === 0) {\n            return [];\n          }\n\n          logger.info(`Soft deleting ${ids.length} records from ${baseRepo.tableName}`);\n\n          // Efficient bulk UPDATE query\n          await baseRepo.executor\n            .updateTable(baseRepo.tableName)\n            .set({ [deletedAtColumn]: sql`CURRENT_TIMESTAMP` } as never)\n            .where(primaryKeyColumn as never, 'in', ids as never)\n            .execute();\n\n          // Fetch all affected records to verify and return them\n          const records = await baseRepo.executor\n            .selectFrom(baseRepo.tableName)\n            .selectAll()\n            .where(primaryKeyColumn as never, 'in', ids as never)\n            .execute();\n\n          // Verify all records were found\n          if (records.length !== ids.length) {\n            const foundIds = records.map((r: any) => r[primaryKeyColumn]);\n            const missingIds = ids.filter((id) => !foundIds.includes(id));\n            logger.warn(`Some records not found for soft delete: ${missingIds.join(', ')}`);\n            throw new NotFoundError('Records', { ids: missingIds });\n          }\n\n          return records as unknown[];\n        },\n\n        async restoreMany(ids: (number | string)[]): Promise<unknown[]> {\n          // Handle empty arrays gracefully\n          if (ids.length === 0) {\n            return [];\n          }\n\n          logger.info(`Restoring ${ids.length} soft-deleted records from ${baseRepo.tableName}`);\n\n          // Efficient bulk UPDATE query to restore records\n          await baseRepo.executor\n            .updateTable(baseRepo.tableName)\n            .set({ [deletedAtColumn]: null } as never)\n            .where(primaryKeyColumn as never, 'in', ids as never)\n            .execute();\n\n          // Fetch all affected records to return them\n          const records = await baseRepo.executor\n            .selectFrom(baseRepo.tableName)\n            .selectAll()\n            .where(primaryKeyColumn as never, 'in', ids as never)\n            .execute();\n\n          return records as unknown[];\n        },\n\n        async hardDeleteMany(ids: (number | string)[]): Promise<void> {\n          // Handle empty arrays gracefully\n          if (ids.length === 0) {\n            return;\n          }\n\n          logger.info(`Hard deleting ${ids.length} records from ${baseRepo.tableName}`);\n\n          // Efficient bulk DELETE query\n          await baseRepo.executor\n            .deleteFrom(baseRepo.tableName)\n            .where(primaryKeyColumn as never, 'in', ids as never)\n            .execute();\n        },\n      };\n\n      return extendedRepo as T;\n    },\n  };\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kysera/soft-delete",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Soft delete plugin for Kysera ORM",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,22 +15,30 @@
     "dist",
     "src"
   ],
-  "peerDependencies": {
-    "kysely": ">=0.28.7"
-  },
   "dependencies": {
-    "@kysera/repository": "0.4.1"
+    "@kysera/core": "0.6.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^24.6.2",
-    "@vitest/coverage-v8": "^3.2.4",
-    "better-sqlite3": "^12.4.1",
-    "kysely": "^0.28.7",
-    "tsup": "^8.5.0",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
+    "better-sqlite3": "^12.5.0",
+    "kysely": "^0.28.8",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
-    "zod": "^4.1.11"
+    "vitest": "^4.0.15",
+    "zod": "^4.1.13",
+    "@kysera/repository": "0.6.0"
+  },
+  "peerDependencies": {
+    "kysely": ">=0.28.8",
+    "zod": "^4.1.13",
+    "@kysera/repository": "0.6.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
   },
   "keywords": [
     "kysely",
@@ -38,17 +46,17 @@
     "soft-delete",
     "plugin"
   ],
-  "author": "",
+  "author": "Kysera Team",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/omnitron/kysera.git",
+    "url": "git+https://github.com/kysera-dev/kysera.git",
     "directory": "packages/soft-delete"
   },
   "bugs": {
-    "url": "https://github.com/omnitron/kysera/issues"
+    "url": "https://github.com/kysera-dev/kysera/issues"
   },
-  "homepage": "https://github.com/omnitron/kysera#readme",
+  "homepage": "https://github.com/kysera-dev/kysera#readme",
   "publishConfig": {
     "access": "public"
   },

package/src/index.ts

@@ -1,6 +1,9 @@
-import type { Plugin, AnyQueryBuilder } from '@kysera/repository'
-import type { SelectQueryBuilder, Kysely } from 'kysely'
-import { sql } from 'kysely'
+import type { Plugin, AnyQueryBuilder, Repository } from '@kysera/repository';
+import type { SelectQueryBuilder, Kysely } from 'kysely';
+import { sql } from 'kysely';
+import { NotFoundError, silentLogger } from '@kysera/core';
+import type { KyseraLogger } from '@kysera/core';
+import { z } from 'zod';
 
 /**
  * Configuration options for the soft delete plugin.
@@ -10,7 +13,8 @@ import { sql } from 'kysely'
  * const plugin = softDeletePlugin({
  *   deletedAtColumn: 'deleted_at',
  *   includeDeleted: false,
- *   tables: ['users', 'posts'] // Only these tables support soft delete
+ *   tables: ['users', 'posts'], // Only these tables support soft delete
+ *   primaryKeyColumn: 'id' // Default primary key column
  * })
  * ```
  */
@@ -20,7 +24,7 @@ export interface SoftDeleteOptions {
    *
    * @default 'deleted_at'
    */
-  deletedAtColumn?: string
+  deletedAtColumn?: string;
 
   /**
    * Include deleted records by default in queries.
@@ -28,7 +32,7 @@ export interface SoftDeleteOptions {
    *
    * @default false
    */
-  includeDeleted?: boolean
+  includeDeleted?: boolean;
 
   /**
    * List of tables that support soft delete.
@@ -36,15 +40,63 @@ export interface SoftDeleteOptions {
    *
    * @example ['users', 'posts', 'comments']
    */
-  tables?: string[]
+  tables?: string[];
+
+  /**
+   * Primary key column name used for identifying records.
+   * Tables with different primary key names (uuid, user_id, etc.) can be configured.
+   *
+   * @default 'id'
+   * @example 'uuid', 'user_id', 'post_id'
+   */
+  primaryKeyColumn?: string;
+
+  /**
+   * Logger for plugin operations.
+   * Uses KyseraLogger interface from @kysera/core.
+   *
+   * @default silentLogger (no output)
+   */
+  logger?: KyseraLogger;
 }
 
+/**
+ * Zod schema for SoftDeleteOptions
+ * Used for validation and configuration in the kysera-cli
+ */
+export const SoftDeleteOptionsSchema = z.object({
+  deletedAtColumn: z.string().optional(),
+  includeDeleted: z.boolean().optional(),
+  tables: z.array(z.string()).optional(),
+  primaryKeyColumn: z.string().optional(),
+});
+
+/**
+ * Methods added to repositories by the soft delete plugin
+ */
+export interface SoftDeleteMethods<T> {
+  softDelete(id: number | string): Promise<T>;
+  restore(id: number | string): Promise<T>;
+  hardDelete(id: number | string): Promise<void>;
+  findWithDeleted(id: number | string): Promise<T | null>;
+  findAllWithDeleted(): Promise<T[]>;
+  findDeleted(): Promise<T[]>;
+  softDeleteMany(ids: (number | string)[]): Promise<T[]>;
+  restoreMany(ids: (number | string)[]): Promise<T[]>;
+  hardDeleteMany(ids: (number | string)[]): Promise<void>;
+}
+
+/**
+ * Repository extended with soft delete methods
+ */
+export type SoftDeleteRepository<Entity, DB> = Repository<Entity, DB> & SoftDeleteMethods<Entity>;
+
 interface BaseRepository {
-  tableName: string
-  executor: Kysely<Record<string, unknown>>
-  findAll: () => Promise<unknown[]>
-  findById: (id: number) => Promise<unknown>
-  update: (id: number, data: Record<string, unknown>) => Promise<unknown>
+  tableName: string;
+  executor: Kysely<Record<string, unknown>>;
+  findAll: () => Promise<unknown[]>;
+  findById: (id: number) => Promise<unknown>;
+  update: (id: number, data: Record<string, unknown>) => Promise<unknown>;
 }
 
 /**
@@ -95,6 +147,47 @@ interface BaseRepository {
  *
  * This design is intentional for simplicity and explicitness.
  *
+ * ## Transaction Behavior
+ *
+ * **IMPORTANT**: Soft delete operations respect ACID properties and work correctly with transactions:
+ *
+ * - ✅ **Commits with transaction**: softDelete/restore operations use the same executor
+ *   as other repository operations, so they commit together
+ * - ✅ **Rolls back with transaction**: If a transaction is rolled back, soft delete
+ *   operations are also rolled back
+ * - ✅ **Atomic operations**: All soft delete operations (including bulk) are atomic
+ *
+ * ### Correct Transaction Usage
+ *
+ * ```typescript
+ * // ✅ CORRECT: Soft delete is part of transaction
+ * await db.transaction().execute(async (trx) => {
+ *   const repos = createRepositories(trx)  // Use transaction executor
+ *   await repos.users.softDelete(1)
+ *   await repos.posts.softDeleteMany([1, 2, 3])
+ *   // If transaction rolls back, both operations roll back
+ * })
+ * ```
+ *
+ * ### Cascade Soft Delete Pattern
+ *
+ * For related entities, you need to manually implement cascade soft delete:
+ *
+ * ```typescript
+ * // Cascade soft delete pattern
+ * await db.transaction().execute(async (trx) => {
+ *   const repos = createRepositories(trx)
+ *   const userId = 123
+ *
+ *   // First, soft delete child records
+ *   const userPosts = await repos.posts.findBy({ user_id: userId })
+ *   await repos.posts.softDeleteMany(userPosts.map(p => p.id))
+ *
+ *   // Then, soft delete parent
+ *   await repos.users.softDelete(userId)
+ * })
+ * ```
+ *
  * @param options - Configuration options for soft delete behavior
  * @returns Plugin instance that can be used with createORM
  */
@@ -102,12 +195,14 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
   const {
     deletedAtColumn = 'deleted_at',
     includeDeleted = false,
-    tables
-  } = options
+    tables,
+    primaryKeyColumn = 'id',
+    logger = silentLogger,
+  } = options;
 
   return {
     name: '@kysera/soft-delete',
-    version: '1.0.0',
+    version: '0.5.1',
 
     /**
      * Intercept queries to automatically filter soft-deleted records.
@@ -120,9 +215,12 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
      *
      * This approach is simpler and more explicit than full query interception.
      */
-    interceptQuery<QB extends AnyQueryBuilder>(qb: QB, context: { operation: string; table: string; metadata: Record<string, unknown> }): QB {
+    interceptQuery<QB extends AnyQueryBuilder>(
+      qb: QB,
+      context: { operation: string; table: string; metadata: Record<string, unknown> }
+    ): QB {
       // Check if table supports soft delete
-      const supportsSoftDelete = !tables || tables.includes(context.table)
+      const supportsSoftDelete = !tables || tables.includes(context.table);
 
       // Only filter SELECT queries when not explicitly including deleted
       if (
@@ -131,21 +229,21 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
         !context.metadata['includeDeleted'] &&
         !includeDeleted
       ) {
+        logger.debug(`Filtering soft-deleted records from ${context.table}`);
         // Add WHERE deleted_at IS NULL to the query builder
-        type GenericSelectQueryBuilder = SelectQueryBuilder<
-          Record<string, unknown>,
-          string,
-          Record<string, unknown>
-        >
-        return (qb as unknown as GenericSelectQueryBuilder)
-          .where(`${context.table}.${deletedAtColumn}` as never, 'is', null) as QB
+        type GenericSelectQueryBuilder = SelectQueryBuilder<Record<string, unknown>, string, Record<string, unknown>>;
+        return (qb as unknown as GenericSelectQueryBuilder).where(
+          `${context.table}.${deletedAtColumn}` as never,
+          'is',
+          null
+        ) as QB;
       }
 
       // Note: DELETE operations are NOT intercepted here
       // Use softDelete() method instead of delete() to perform soft deletes
       // This is by design - method override is simpler and more explicit
 
-      return qb
+      return qb;
     },
 
     /**
@@ -158,30 +256,36 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
      * - findWithDeleted(id): Find a record including soft-deleted ones
      * - findAllWithDeleted(): Find all records including soft-deleted ones
      * - findDeleted(): Find only soft-deleted records
+     * - softDeleteMany(ids): Soft delete multiple records (bulk operation)
+     * - restoreMany(ids): Restore multiple soft-deleted records (bulk operation)
+     * - hardDeleteMany(ids): Permanently delete multiple records (bulk operation)
      *
      * Also overrides findAll() and findById() to automatically filter out
      * soft-deleted records (unless includeDeleted option is set).
      */
     extendRepository<T extends object>(repo: T): T {
       // Type assertion is safe here as we're checking for BaseRepository properties
-      const baseRepo = repo as unknown as BaseRepository
+      const baseRepo = repo as unknown as BaseRepository;
 
       // Check if it's actually a repository (has required properties)
       if (!('tableName' in baseRepo) || !('executor' in baseRepo)) {
-        return repo
+        return repo;
       }
 
       // Check if table supports soft delete
-      const supportsSoftDelete = !tables || tables.includes(baseRepo.tableName)
+      const supportsSoftDelete = !tables || tables.includes(baseRepo.tableName);
 
       // If table doesn't support soft delete, return unmodified repo
       if (!supportsSoftDelete) {
-        return repo
+        logger.debug(`Table ${baseRepo.tableName} does not support soft delete, skipping extension`);
+        return repo;
       }
 
+      logger.debug(`Extending repository for table ${baseRepo.tableName} with soft delete methods`);
+
       // Wrap original methods to apply soft delete filtering
-      const originalFindAll = baseRepo.findAll.bind(baseRepo)
-      const originalFindById = baseRepo.findById.bind(baseRepo)
+      const originalFindAll = baseRepo.findAll.bind(baseRepo);
+      const originalFindById = baseRepo.findById.bind(baseRepo);
 
       const extendedRepo = {
         ...baseRepo,
@@ -193,10 +297,10 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
               .selectFrom(baseRepo.tableName)
               .selectAll()
               .where(deletedAtColumn as never, 'is', null)
-              .execute()
-            return result as unknown[]
+              .execute();
+            return result as unknown[];
           }
-          return await originalFindAll()
+          return await originalFindAll();
         },
 
         async findById(id: number): Promise<unknown> {
@@ -204,55 +308,111 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
             const result = await baseRepo.executor
               .selectFrom(baseRepo.tableName)
               .selectAll()
-              .where('id' as never, '=', id as never)
+              .where(primaryKeyColumn as never, '=', id as never)
               .where(deletedAtColumn as never, 'is', null)
-              .executeTakeFirst()
-            return result ?? null
+              .executeTakeFirst();
+            return result ?? null;
           }
-          return await originalFindById(id)
+          // When includeDeleted is true, use custom PK column if configured
+          // Otherwise fall back to original method (which uses 'id')
+          if (primaryKeyColumn !== 'id') {
+            const result = await baseRepo.executor
+              .selectFrom(baseRepo.tableName)
+              .selectAll()
+              .where(primaryKeyColumn as never, '=', id as never)
+              .executeTakeFirst();
+            return result ?? null;
+          }
+          return await originalFindById(id);
         },
 
         async softDelete(id: number): Promise<unknown> {
+          logger.info(`Soft deleting record ${id} from ${baseRepo.tableName}`);
           // Use CURRENT_TIMESTAMP directly in SQL to avoid datetime format issues
           // This works across all databases (MySQL, PostgreSQL, SQLite)
           // We bypass repository.update() to avoid Zod validation issues with RawBuilder
           await baseRepo.executor
             .updateTable(baseRepo.tableName)
             .set({ [deletedAtColumn]: sql`CURRENT_TIMESTAMP` } as never)
-            .where('id' as never, '=', id as never)
-            .execute()
+            .where(primaryKeyColumn as never, '=', id as never)
+            .execute();
 
           // Fetch the updated record to verify it exists
-          const record = await originalFindById(id)
+          // Use custom PK column if configured
+          let record;
+          if (primaryKeyColumn !== 'id') {
+            record = await baseRepo.executor
+              .selectFrom(baseRepo.tableName)
+              .selectAll()
+              .where(primaryKeyColumn as never, '=', id as never)
+              .executeTakeFirst();
+          } else {
+            record = await originalFindById(id);
+          }
 
           // If record not found or deleted_at not set, throw error
           if (!record) {
-            throw new Error(`Record with id ${id} not found`)
+            logger.warn(`Record ${id} not found in ${baseRepo.tableName} for soft delete`);
+            throw new NotFoundError('Record', { id });
           }
 
-          return record
+          return record;
         },
 
         async restore(id: number): Promise<unknown> {
-          return await baseRepo.update(id, { [deletedAtColumn]: null })
+          logger.info(`Restoring soft-deleted record ${id} from ${baseRepo.tableName}`);
+          // Use direct executor to support custom primary key columns
+          await baseRepo.executor
+            .updateTable(baseRepo.tableName)
+            .set({ [deletedAtColumn]: null } as never)
+            .where(primaryKeyColumn as never, '=', id as never)
+            .execute();
+
+          // Fetch and return the restored record
+          let record;
+          if (primaryKeyColumn !== 'id') {
+            record = await baseRepo.executor
+              .selectFrom(baseRepo.tableName)
+              .selectAll()
+              .where(primaryKeyColumn as never, '=', id as never)
+              .executeTakeFirst();
+          } else {
+            record = await originalFindById(id);
+          }
+
+          if (!record) {
+            logger.warn(`Record ${id} not found in ${baseRepo.tableName} for restore`);
+            throw new NotFoundError('Record', { id });
+          }
+
+          return record;
         },
 
         async hardDelete(id: number): Promise<void> {
+          logger.info(`Hard deleting record ${id} from ${baseRepo.tableName}`);
           // Direct hard delete - bypass soft delete
           await baseRepo.executor
             .deleteFrom(baseRepo.tableName)
-            .where('id' as never, '=', id as never)
-            .execute()
+            .where(primaryKeyColumn as never, '=', id as never)
+            .execute();
         },
 
         async findWithDeleted(id: number): Promise<unknown> {
-          // Use original method without filtering
-          return await originalFindById(id)
+          // Use custom PK column if configured, otherwise use original method
+          if (primaryKeyColumn !== 'id') {
+            const result = await baseRepo.executor
+              .selectFrom(baseRepo.tableName)
+              .selectAll()
+              .where(primaryKeyColumn as never, '=', id as never)
+              .executeTakeFirst();
+            return result ?? null;
+          }
+          return await originalFindById(id);
         },
 
         async findAllWithDeleted(): Promise<unknown[]> {
           // Use original method without filtering
-          return await originalFindAll()
+          return await originalFindAll();
         },
 
         async findDeleted(): Promise<unknown[]> {
@@ -260,12 +420,85 @@ export const softDeletePlugin = (options: SoftDeleteOptions = {}): Plugin => {
             .selectFrom(baseRepo.tableName)
             .selectAll()
             .where(deletedAtColumn as never, 'is not', null)
-            .execute()
-          return result as unknown[]
-        }
-      }
+            .execute();
+          return result as unknown[];
+        },
+
+        async softDeleteMany(ids: (number | string)[]): Promise<unknown[]> {
+          // Handle empty arrays gracefully
+          if (ids.length === 0) {
+            return [];
+          }
+
+          logger.info(`Soft deleting ${ids.length} records from ${baseRepo.tableName}`);
+
+          // Efficient bulk UPDATE query
+          await baseRepo.executor
+            .updateTable(baseRepo.tableName)
+            .set({ [deletedAtColumn]: sql`CURRENT_TIMESTAMP` } as never)
+            .where(primaryKeyColumn as never, 'in', ids as never)
+            .execute();
+
+          // Fetch all affected records to verify and return them
+          const records = await baseRepo.executor
+            .selectFrom(baseRepo.tableName)
+            .selectAll()
+            .where(primaryKeyColumn as never, 'in', ids as never)
+            .execute();
 
-      return extendedRepo as T
-    }
-  }
-}
+          // Verify all records were found
+          if (records.length !== ids.length) {
+            const foundIds = records.map((r: any) => r[primaryKeyColumn]);
+            const missingIds = ids.filter((id) => !foundIds.includes(id));
+            logger.warn(`Some records not found for soft delete: ${missingIds.join(', ')}`);
+            throw new NotFoundError('Records', { ids: missingIds });
+          }
+
+          return records as unknown[];
+        },
+
+        async restoreMany(ids: (number | string)[]): Promise<unknown[]> {
+          // Handle empty arrays gracefully
+          if (ids.length === 0) {
+            return [];
+          }
+
+          logger.info(`Restoring ${ids.length} soft-deleted records from ${baseRepo.tableName}`);
+
+          // Efficient bulk UPDATE query to restore records
+          await baseRepo.executor
+            .updateTable(baseRepo.tableName)
+            .set({ [deletedAtColumn]: null } as never)
+            .where(primaryKeyColumn as never, 'in', ids as never)
+            .execute();
+
+          // Fetch all affected records to return them
+          const records = await baseRepo.executor
+            .selectFrom(baseRepo.tableName)
+            .selectAll()
+            .where(primaryKeyColumn as never, 'in', ids as never)
+            .execute();
+
+          return records as unknown[];
+        },
+
+        async hardDeleteMany(ids: (number | string)[]): Promise<void> {
+          // Handle empty arrays gracefully
+          if (ids.length === 0) {
+            return;
+          }
+
+          logger.info(`Hard deleting ${ids.length} records from ${baseRepo.tableName}`);
+
+          // Efficient bulk DELETE query
+          await baseRepo.executor
+            .deleteFrom(baseRepo.tableName)
+            .where(primaryKeyColumn as never, 'in', ids as never)
+            .execute();
+        },
+      };
+
+      return extendedRepo as T;
+    },
+  };
+};