@geekmidas/db 0.0.4 → 0.1.0

package/README.md

@@ -0,0 +1,495 @@
+# @geekmidas/db
+
+Database utilities for Kysely with flexible transaction management. Provides helpers for working with database connections and transactions in a type-safe way.
+
+## Features
+
+- ✅ **Flexible Transaction Handling**: Works with Kysely, Transaction, and ControlledTransaction
+- ✅ **Automatic Transaction Detection**: Reuses existing transactions when nested
+- ✅ **Type-Safe**: Full TypeScript support with generic database schemas
+- ✅ **Connection Abstraction**: Single helper for all database connection types
+- ✅ **Zero Dependencies**: Only peer dependency on Kysely
+
+## Installation
+
+```bash
+pnpm add @geekmidas/db
+```
+
+### Peer Dependencies
+
+```bash
+pnpm add kysely pg
+```
+
+## Quick Start
+
+```typescript
+import { withTransaction } from '@geekmidas/db/kysely';
+import type { DatabaseConnection } from '@geekmidas/db/kysely';
+import { Kysely } from 'kysely';
+
+interface Database {
+  users: {
+    id: string;
+    email: string;
+    name: string;
+  };
+  posts: {
+    id: string;
+    userId: string;
+    title: string;
+  };
+}
+
+async function createUserWithPost(
+  db: DatabaseConnection<Database>,
+  userData: { email: string; name: string },
+  postData: { title: string }
+) {
+  return withTransaction(db, async (trx) => {
+    // Create user
+    const user = await trx
+      .insertInto('users')
+      .values(userData)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    // Create post for user
+    const post = await trx
+      .insertInto('posts')
+      .values({
+        userId: user.id,
+        title: postData.title
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    return { user, post };
+  });
+}
+```
+
+## API Reference
+
+### `withTransaction`
+
+Execute a callback within a transaction. If the connection is already a transaction, it reuses it. Otherwise, it creates a new transaction.
+
+```typescript
+function withTransaction<DB, T>(
+  db: DatabaseConnection<DB>,
+  cb: (trx: Transaction<DB>) => Promise<T>
+): Promise<T>
+```
+
+**Parameters:**
+- `db` - A database connection (Kysely, Transaction, or ControlledTransaction)
+- `cb` - Callback function that receives the transaction
+
+**Returns:**
+- Promise resolving to the callback's return value
+
+### `DatabaseConnection<T>`
+
+Type union for all supported database connection types:
+
+```typescript
+type DatabaseConnection<T> =
+  | Kysely<T>
+  | Transaction<T>
+  | ControlledTransaction<T>;
+```
+
+## Usage Examples
+
+### Basic Transaction
+
+```typescript
+import { withTransaction } from '@geekmidas/db/kysely';
+import { Kysely } from 'kysely';
+
+const db = new Kysely<Database>({ /* config */ });
+
+async function transferFunds(fromId: string, toId: string, amount: number) {
+  return withTransaction(db, async (trx) => {
+    // Deduct from sender
+    await trx
+      .updateTable('accounts')
+      .set({ balance: sql`balance - ${amount}` })
+      .where('id', '=', fromId)
+      .execute();
+
+    // Add to receiver
+    await trx
+      .updateTable('accounts')
+      .set({ balance: sql`balance + ${amount}` })
+      .where('id', '=', toId)
+      .execute();
+
+    return { success: true };
+  });
+}
+```
+
+### Nested Transactions
+
+The helper automatically detects existing transactions and reuses them:
+
+```typescript
+async function createUser(
+  db: DatabaseConnection<Database>,
+  email: string
+) {
+  return withTransaction(db, async (trx) => {
+    const user = await trx
+      .insertInto('users')
+      .values({ email })
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    // This will reuse the same transaction
+    await createAuditLog(trx, 'user_created', user.id);
+
+    return user;
+  });
+}
+
+async function createAuditLog(
+  db: DatabaseConnection<Database>,
+  action: string,
+  userId: string
+) {
+  // If db is already a transaction, it's reused
+  return withTransaction(db, async (trx) => {
+    await trx
+      .insertInto('audit_logs')
+      .values({ action, userId, timestamp: new Date() })
+      .execute();
+  });
+}
+```
+
+### Repository Pattern
+
+Use `DatabaseConnection` type in repositories for flexibility:
+
+```typescript
+import type { DatabaseConnection } from '@geekmidas/db/kysely';
+import { withTransaction } from '@geekmidas/db/kysely';
+
+class UserRepository {
+  constructor(private db: DatabaseConnection<Database>) {}
+
+  async create(data: NewUser): Promise<User> {
+    return withTransaction(this.db, async (trx) => {
+      return trx
+        .insertInto('users')
+        .values(data)
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    });
+  }
+
+  async update(id: string, data: UserUpdate): Promise<User> {
+    return withTransaction(this.db, async (trx) => {
+      return trx
+        .updateTable('users')
+        .set(data)
+        .where('id', '=', id)
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    });
+  }
+}
+
+// Can be used with any connection type
+const db = new Kysely<Database>({ /* config */ });
+const repo = new UserRepository(db);
+
+// Or within a transaction
+await withTransaction(db, async (trx) => {
+  const repo = new UserRepository(trx);
+  await repo.create({ email: 'user@example.com' });
+});
+```
+
+### Service Pattern with Transactions
+
+```typescript
+import type { DatabaseConnection } from '@geekmidas/db/kysely';
+import { withTransaction } from '@geekmidas/db/kysely';
+
+class OrderService {
+  constructor(
+    private db: DatabaseConnection<Database>,
+    private inventoryService: InventoryService,
+    private paymentService: PaymentService
+  ) {}
+
+  async createOrder(
+    userId: string,
+    items: OrderItem[]
+  ): Promise<Order> {
+    return withTransaction(this.db, async (trx) => {
+      // All operations share the same transaction
+      const order = await trx
+        .insertInto('orders')
+        .values({ userId, status: 'pending' })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+
+      // These services can accept the transaction
+      await this.inventoryService.reserveItems(trx, items);
+      await this.paymentService.processPayment(trx, order.id);
+
+      // Update order status
+      return trx
+        .updateTable('orders')
+        .set({ status: 'completed' })
+        .where('id', '=', order.id)
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    });
+  }
+}
+
+class InventoryService {
+  async reserveItems(
+    db: DatabaseConnection<Database>,
+    items: OrderItem[]
+  ) {
+    return withTransaction(db, async (trx) => {
+      for (const item of items) {
+        await trx
+          .updateTable('inventory')
+          .set({ reserved: sql`reserved + ${item.quantity}` })
+          .where('productId', '=', item.productId)
+          .execute();
+      }
+    });
+  }
+}
+```
+
+### Error Handling
+
+Transactions automatically roll back on errors:
+
+```typescript
+import { withTransaction } from '@geekmidas/db/kysely';
+
+async function processOrder(db: DatabaseConnection<Database>, orderId: string) {
+  try {
+    return await withTransaction(db, async (trx) => {
+      const order = await trx
+        .selectFrom('orders')
+        .where('id', '=', orderId)
+        .selectAll()
+        .executeTakeFirstOrThrow();
+
+      if (order.status !== 'pending') {
+        throw new Error('Order already processed');
+      }
+
+      // Update order
+      await trx
+        .updateTable('orders')
+        .set({ status: 'processing' })
+        .where('id', '=', orderId)
+        .execute();
+
+      // If this throws, the entire transaction rolls back
+      await processPayment(trx, orderId);
+
+      return order;
+    });
+  } catch (error) {
+    console.error('Transaction failed:', error);
+    // Transaction has been rolled back
+    throw error;
+  }
+}
+```
+
+### Testing with Transactions
+
+Use transactions for test isolation:
+
+```typescript
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import type { Transaction } from 'kysely';
+
+describe('UserRepository', () => {
+  let trx: Transaction<Database>;
+
+  beforeEach(async () => {
+    trx = await db.transaction().execute(async (t) => t);
+  });
+
+  afterEach(async () => {
+    await trx.rollback();
+  });
+
+  it('should create user', async () => {
+    const repo = new UserRepository(trx);
+    const user = await repo.create({ email: 'test@example.com' });
+
+    expect(user.email).toBe('test@example.com');
+    // Transaction will be rolled back after test
+  });
+});
+```
+
+## Type Safety
+
+The package provides full type safety for database operations:
+
+```typescript
+import type { DatabaseConnection } from '@geekmidas/db/kysely';
+import { withTransaction } from '@geekmidas/db/kysely';
+
+interface Database {
+  users: {
+    id: Generated<string>;
+    email: string;
+    name: string | null;
+  };
+}
+
+function updateUser(
+  db: DatabaseConnection<Database>,
+  id: string,
+  data: { name: string }
+) {
+  return withTransaction(db, async (trx) => {
+    // Full autocomplete and type checking
+    return trx
+      .updateTable('users')
+      .set(data) // Type-checked against users table
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+  });
+}
+```
+
+## Advanced Patterns
+
+### Unit of Work Pattern
+
+```typescript
+class UnitOfWork {
+  private transaction: Transaction<Database> | null = null;
+
+  constructor(private db: Kysely<Database>) {}
+
+  async begin() {
+    this.transaction = await this.db.transaction().execute(async (t) => t);
+  }
+
+  async commit() {
+    if (this.transaction) {
+      await this.transaction.commit();
+      this.transaction = null;
+    }
+  }
+
+  async rollback() {
+    if (this.transaction) {
+      await this.transaction.rollback();
+      this.transaction = null;
+    }
+  }
+
+  getConnection(): DatabaseConnection<Database> {
+    return this.transaction || this.db;
+  }
+}
+
+// Usage
+const uow = new UnitOfWork(db);
+await uow.begin();
+
+try {
+  const userRepo = new UserRepository(uow.getConnection());
+  const orderRepo = new OrderRepository(uow.getConnection());
+
+  await userRepo.create({ email: 'user@example.com' });
+  await orderRepo.create({ userId: '123' });
+
+  await uow.commit();
+} catch (error) {
+  await uow.rollback();
+  throw error;
+}
+```
+
+### Connection Pooling
+
+```typescript
+import { Pool } from 'pg';
+import { Kysely, PostgresDialect } from 'kysely';
+
+const pool = new Pool({
+  host: 'localhost',
+  database: 'mydb',
+  max: 10
+});
+
+const db = new Kysely<Database>({
+  dialect: new PostgresDialect({ pool })
+});
+
+// Use with withTransaction
+async function processData(data: unknown[]) {
+  return withTransaction(db, async (trx) => {
+    // Each transaction gets a connection from the pool
+    for (const item of data) {
+      await trx.insertInto('items').values(item).execute();
+    }
+  });
+}
+```
+
+## Best Practices
+
+1. **Use DatabaseConnection Type**: Accept `DatabaseConnection` in functions that work with transactions
+   ```typescript
+   async function myFunction(db: DatabaseConnection<Database>) { }
+   ```
+
+2. **Let withTransaction Handle Reuse**: Don't manually check for transaction type
+   ```typescript
+   // Good
+   await withTransaction(db, async (trx) => { });
+
+   // Avoid
+   if (db.isTransaction) { /* ... */ } else { /* ... */ }
+   ```
+
+3. **Keep Transactions Short**: Execute quickly to avoid blocking
+   ```typescript
+   // Good
+   await withTransaction(db, async (trx) => {
+     await trx.insertInto('users').values(data).execute();
+   });
+
+   // Avoid long-running operations
+   await withTransaction(db, async (trx) => {
+     await fetch('https://api.example.com'); // Bad!
+   });
+   ```
+
+4. **Error Handling**: Let transactions roll back automatically on errors
+
+5. **Testing**: Use transactions for test isolation with automatic rollback
+
+## Related Packages
+
+- [Kysely](https://github.com/kysely-org/kysely) - Type-safe SQL query builder
+- [@geekmidas/testkit](../testkit) - Testing utilities with database factories
+
+## License
+
+MIT

package/dist/kysely-0FOi6ZdO.d.cts

@@ -0,0 +1,11 @@
+import { ControlledTransaction, IsolationLevel, Kysely, Transaction } from "kysely";
+
+//#region src/kysely.d.ts
+interface TransactionSettings {
+  isolationLevel?: IsolationLevel;
+}
+declare function withTransaction<DB, T>(db: DatabaseConnection<DB>, cb: (trx: Transaction<DB>) => Promise<T>, settings?: TransactionSettings): Promise<T>;
+type DatabaseConnection<T> = ControlledTransaction<T> | Kysely<T> | Transaction<T>;
+//#endregion
+export { DatabaseConnection, TransactionSettings, withTransaction };
+//# sourceMappingURL=kysely-0FOi6ZdO.d.cts.map

package/dist/kysely-8WPSKCZG.cjs

@@ -0,0 +1,17 @@
+
+//#region src/kysely.ts
+function withTransaction(db, cb, settings) {
+	if (db.isTransaction) return cb(db);
+	const builder = db.transaction();
+	if (settings?.isolationLevel) return builder.setIsolationLevel(settings.isolationLevel).execute(cb);
+	return builder.execute(cb);
+}
+
+//#endregion
+Object.defineProperty(exports, 'withTransaction', {
+  enumerable: true,
+  get: function () {
+    return withTransaction;
+  }
+});
+//# sourceMappingURL=kysely-8WPSKCZG.cjs.map

package/dist/kysely-8WPSKCZG.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-8WPSKCZG.cjs","names":["db: DatabaseConnection<DB>","cb: (trx: Transaction<DB>) => Promise<T>","settings?: TransactionSettings"],"sources":["../src/kysely.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  IsolationLevel,\n  Kysely,\n  Transaction,\n} from 'kysely';\n\nexport interface TransactionSettings {\n  isolationLevel?: IsolationLevel;\n}\n\nexport function withTransaction<DB, T>(\n  db: DatabaseConnection<DB>,\n  cb: (trx: Transaction<DB>) => Promise<T>,\n  settings?: TransactionSettings,\n): Promise<T> {\n  if (db.isTransaction) {\n    return cb(db as Transaction<DB>);\n  }\n\n  const builder = db.transaction();\n\n  if (settings?.isolationLevel) {\n    return builder.setIsolationLevel(settings.isolationLevel).execute(cb);\n  }\n\n  return builder.execute(cb);\n}\n\nexport type DatabaseConnection<T> =\n  | ControlledTransaction<T>\n  | Kysely<T>\n  | Transaction<T>;\n"],"mappings":";;AAWA,SAAgB,gBACdA,IACAC,IACAC,UACY;AACZ,KAAI,GAAG,cACL,QAAO,GAAG,GAAsB;CAGlC,MAAM,UAAU,GAAG,aAAa;AAEhC,KAAI,UAAU,eACZ,QAAO,QAAQ,kBAAkB,SAAS,eAAe,CAAC,QAAQ,GAAG;AAGvE,QAAO,QAAQ,QAAQ,GAAG;AAC3B"}

package/dist/kysely-Di1LVvL2.d.mts

@@ -0,0 +1,11 @@
+import { ControlledTransaction, IsolationLevel, Kysely, Transaction } from "kysely";
+
+//#region src/kysely.d.ts
+interface TransactionSettings {
+  isolationLevel?: IsolationLevel;
+}
+declare function withTransaction<DB, T>(db: DatabaseConnection<DB>, cb: (trx: Transaction<DB>) => Promise<T>, settings?: TransactionSettings): Promise<T>;
+type DatabaseConnection<T> = ControlledTransaction<T> | Kysely<T> | Transaction<T>;
+//#endregion
+export { DatabaseConnection, TransactionSettings, withTransaction };
+//# sourceMappingURL=kysely-Di1LVvL2.d.mts.map

package/dist/kysely-DmfA94RY.mjs

@@ -0,0 +1,11 @@
+//#region src/kysely.ts
+function withTransaction(db, cb, settings) {
+	if (db.isTransaction) return cb(db);
+	const builder = db.transaction();
+	if (settings?.isolationLevel) return builder.setIsolationLevel(settings.isolationLevel).execute(cb);
+	return builder.execute(cb);
+}
+
+//#endregion
+export { withTransaction };
+//# sourceMappingURL=kysely-DmfA94RY.mjs.map

package/dist/kysely-DmfA94RY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-DmfA94RY.mjs","names":["db: DatabaseConnection<DB>","cb: (trx: Transaction<DB>) => Promise<T>","settings?: TransactionSettings"],"sources":["../src/kysely.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  IsolationLevel,\n  Kysely,\n  Transaction,\n} from 'kysely';\n\nexport interface TransactionSettings {\n  isolationLevel?: IsolationLevel;\n}\n\nexport function withTransaction<DB, T>(\n  db: DatabaseConnection<DB>,\n  cb: (trx: Transaction<DB>) => Promise<T>,\n  settings?: TransactionSettings,\n): Promise<T> {\n  if (db.isTransaction) {\n    return cb(db as Transaction<DB>);\n  }\n\n  const builder = db.transaction();\n\n  if (settings?.isolationLevel) {\n    return builder.setIsolationLevel(settings.isolationLevel).execute(cb);\n  }\n\n  return builder.execute(cb);\n}\n\nexport type DatabaseConnection<T> =\n  | ControlledTransaction<T>\n  | Kysely<T>\n  | Transaction<T>;\n"],"mappings":";AAWA,SAAgB,gBACdA,IACAC,IACAC,UACY;AACZ,KAAI,GAAG,cACL,QAAO,GAAG,GAAsB;CAGlC,MAAM,UAAU,GAAG,aAAa;AAEhC,KAAI,UAAU,eACZ,QAAO,QAAQ,kBAAkB,SAAS,eAAe,CAAC,QAAQ,GAAG;AAGvE,QAAO,QAAQ,QAAQ,GAAG;AAC3B"}

package/dist/kysely.cjs

@@ -1,9 +1,3 @@
+const require_kysely = require('./kysely-8WPSKCZG.cjs');
 
-//#region src/kysely.ts
-function withTransaction(db, cb) {
-	if (db.isTransaction) return cb(db);
-	return db.transaction().execute(cb);
-}
-
-//#endregion
-exports.withTransaction = withTransaction;
+exports.withTransaction = require_kysely.withTransaction;

package/dist/kysely.d.cts

@@ -1,7 +1,2 @@
-import { ControlledTransaction, Kysely, Transaction } from "kysely";
-
-//#region src/kysely.d.ts
-declare function withTransaction<DB, T>(db: DatabaseConnection<DB>, cb: (trx: Transaction<DB>) => Promise<T>): Promise<T>;
-type DatabaseConnection<T> = ControlledTransaction<T> | Kysely<T> | Transaction<T>;
-//#endregion
-export { DatabaseConnection, withTransaction };
+import { DatabaseConnection, TransactionSettings, withTransaction } from "./kysely-0FOi6ZdO.cjs";
+export { DatabaseConnection, TransactionSettings, withTransaction };

package/dist/kysely.d.mts

@@ -1,7 +1,2 @@
-import { ControlledTransaction, Kysely, Transaction } from "kysely";
-
-//#region src/kysely.d.ts
-declare function withTransaction<DB, T>(db: DatabaseConnection<DB>, cb: (trx: Transaction<DB>) => Promise<T>): Promise<T>;
-type DatabaseConnection<T> = ControlledTransaction<T> | Kysely<T> | Transaction<T>;
-//#endregion
-export { DatabaseConnection, withTransaction };
+import { DatabaseConnection, TransactionSettings, withTransaction } from "./kysely-Di1LVvL2.mjs";
+export { DatabaseConnection, TransactionSettings, withTransaction };

package/dist/kysely.mjs

@@ -1,8 +1,3 @@
-//#region src/kysely.ts
-function withTransaction(db, cb) {
-	if (db.isTransaction) return cb(db);
-	return db.transaction().execute(cb);
-}
+import { withTransaction } from "./kysely-DmfA94RY.mjs";
 
-//#endregion
 export { withTransaction };

package/dist/rls.cjs

@@ -0,0 +1,72 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_kysely = require('./kysely-8WPSKCZG.cjs');
+const kysely = __toESM(require("kysely"));
+
+//#region src/rls.ts
+/**
+* Execute a callback within a transaction with RLS context variables set.
+*
+* Sets PostgreSQL session variables using `SET LOCAL` which scopes them to the
+* current transaction. Variables are automatically cleared when the transaction
+* ends (commit or rollback).
+*
+* @example
+* ```ts
+* await withRlsContext(
+*   db,
+*   { user_id: session.userId, tenant_id: session.tenantId },
+*   async (trx) => {
+*     // RLS policies can now use current_setting('app.user_id')
+*     return trx.selectFrom('orders').selectAll().execute();
+*   }
+* );
+* ```
+*
+* @param db - Database connection (Kysely, Transaction, or ControlledTransaction)
+* @param context - Key-value pairs to set as session variables
+* @param callback - Function to execute within the RLS context
+* @param options - Optional prefix and transaction settings
+*/
+async function withRlsContext(db, context, callback, options) {
+	const prefix = options?.prefix ?? "app";
+	return require_kysely.withTransaction(db, async (trx) => {
+		for (const [key, value] of Object.entries(context)) {
+			if (value === null || value === void 0) continue;
+			const settingName = `${prefix}.${key}`;
+			const settingValue = String(value);
+			await kysely.sql`SELECT set_config(${settingName}, ${settingValue}, true)`.execute(trx);
+		}
+		return callback(trx);
+	}, options?.settings);
+}
+/**
+* Bypass marker symbol for explicitly skipping RLS context.
+*/
+const RLS_BYPASS = Symbol.for("geekmidas.rls.bypass");
+
+//#endregion
+exports.RLS_BYPASS = RLS_BYPASS;
+exports.withRlsContext = withRlsContext;
+//# sourceMappingURL=rls.cjs.map

package/dist/rls.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rls.cjs","names":["db: DatabaseConnection<DB>","context: RlsContext","callback: (trx: Transaction<DB>) => Promise<T>","options?: WithRlsContextOptions"],"sources":["../src/rls.ts"],"sourcesContent":["import type { Transaction } from 'kysely';\nimport { sql } from 'kysely';\nimport {\n  type DatabaseConnection,\n  type TransactionSettings,\n  withTransaction,\n} from './kysely';\n\n/**\n * RLS context - key-value pairs to set as PostgreSQL session variables.\n * Keys become `prefix.key` (e.g., `app.user_id`).\n */\nexport interface RlsContext {\n  [key: string]: string | number | boolean | null | undefined;\n}\n\n/**\n * Options for withRlsContext function.\n */\nexport interface WithRlsContextOptions {\n  /** Prefix for PostgreSQL session variables (default: 'app') */\n  prefix?: string;\n  /** Transaction settings (isolation level) */\n  settings?: TransactionSettings;\n}\n\n/**\n * Execute a callback within a transaction with RLS context variables set.\n *\n * Sets PostgreSQL session variables using `SET LOCAL` which scopes them to the\n * current transaction. Variables are automatically cleared when the transaction\n * ends (commit or rollback).\n *\n * @example\n * ```ts\n * await withRlsContext(\n *   db,\n *   { user_id: session.userId, tenant_id: session.tenantId },\n *   async (trx) => {\n *     // RLS policies can now use current_setting('app.user_id')\n *     return trx.selectFrom('orders').selectAll().execute();\n *   }\n * );\n * ```\n *\n * @param db - Database connection (Kysely, Transaction, or ControlledTransaction)\n * @param context - Key-value pairs to set as session variables\n * @param callback - Function to execute within the RLS context\n * @param options - Optional prefix and transaction settings\n */\nexport async function withRlsContext<DB, T>(\n  db: DatabaseConnection<DB>,\n  context: RlsContext,\n  callback: (trx: Transaction<DB>) => Promise<T>,\n  options?: WithRlsContextOptions,\n): Promise<T> {\n  const prefix = options?.prefix ?? 'app';\n\n  return withTransaction(\n    db,\n    async (trx) => {\n      // Set each context variable using SET LOCAL (scoped to transaction)\n      for (const [key, value] of Object.entries(context)) {\n        if (value === null || value === undefined) continue;\n\n        const settingName = `${prefix}.${key}`;\n        const settingValue = String(value);\n\n        // Use raw SQL for SET LOCAL with proper escaping\n        // The setting name is an identifier, value is a string literal\n        await sql`SELECT set_config(${settingName}, ${settingValue}, true)`.execute(\n          trx,\n        );\n      }\n\n      return callback(trx);\n    },\n    options?.settings,\n  );\n}\n\n/**\n * Bypass marker symbol for explicitly skipping RLS context.\n */\nexport const RLS_BYPASS = Symbol.for('geekmidas.rls.bypass');\n\n/**\n * Type for RLS bypass marker.\n */\nexport type RlsBypass = typeof RLS_BYPASS;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,eAAsB,eACpBA,IACAC,SACAC,UACAC,SACY;CACZ,MAAM,SAAS,SAAS,UAAU;AAElC,QAAO,+BACL,IACA,OAAO,QAAQ;AAEb,OAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,QAAQ,EAAE;AAClD,OAAI,UAAU,QAAQ,iBAAqB;GAE3C,MAAM,eAAe,EAAE,OAAO,GAAG,IAAI;GACrC,MAAM,eAAe,OAAO,MAAM;AAIlC,SAAM,WAAI,oBAAoB,YAAY,IAAI,aAAa,SAAS,QAClE,IACD;EACF;AAED,SAAO,SAAS,IAAI;CACrB,GACD,SAAS,SACV;AACF;;;;AAKD,MAAa,aAAa,OAAO,IAAI,uBAAuB"}