@geekmidas/db 0.0.4 → 0.2.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/pagination.cjs

@@ -0,0 +1,83 @@
+
+//#region src/kysely/pagination.ts
+/**
+* Sort direction for cursor-based pagination.
+*/
+let Direction = /* @__PURE__ */ function(Direction$1) {
+	Direction$1["Asc"] = "asc";
+	Direction$1["Desc"] = "desc";
+	return Direction$1;
+}({});
+/**
+* Generic paginated search function that handles:
+* - Total count calculation
+* - Cursor-based pagination
+* - Fetching one extra row to determine hasMore
+* - Mapping rows to output format
+*
+* @example
+* ```typescript
+* const result = await paginatedSearch({
+*   query: db.selectFrom('users').selectAll(),
+*   cursor: previousCursor,
+*   limit: 20,
+*   mapRow: (row) => ({ id: row.id, name: row.name }),
+*   cursorField: 'id',
+*   cursorDirection: Direction.Asc,
+* });
+* ```
+*/
+async function paginatedSearch({ query, cursor, limit = 20, mapRow, cursorField = "id", cursorDirection = Direction.Asc }) {
+	const countResult = await query.clearSelect().clearOrderBy().select((eb) => eb.fn.countAll().as("count")).executeTakeFirstOrThrow();
+	const count = countResult.count;
+	let paginatedQuery = query;
+	if (cursor) {
+		const operator = cursorDirection === Direction.Asc ? ">" : "<";
+		paginatedQuery = paginatedQuery.where(cursorField, operator, cursor);
+	}
+	const data = await paginatedQuery.orderBy(cursorField, cursorDirection).limit(limit + 1).execute();
+	const hasMore = data.length > limit;
+	const rows = hasMore ? data.slice(0, limit) : data;
+	const lastRow = rows[rows.length - 1];
+	const nextCursor = hasMore && lastRow ? String(lastRow[cursorField]) : void 0;
+	const items = await Promise.all(rows.map(mapRow));
+	return {
+		items,
+		pagination: {
+			total: Number(count),
+			hasMore,
+			cursor: nextCursor
+		}
+	};
+}
+/**
+* Encode a cursor value for safe URL transmission.
+* Supports various types: string, number, Date, etc.
+*/
+function encodeCursor(value) {
+	const payload = {
+		v: value instanceof Date ? value.toISOString() : value,
+		t: value instanceof Date ? "date" : typeof value
+	};
+	return Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+/**
+* Decode a cursor string back to its original value.
+*/
+function decodeCursor(cursor) {
+	try {
+		const json = Buffer.from(cursor, "base64url").toString("utf-8");
+		const payload = JSON.parse(json);
+		if (payload.t === "date") return new Date(payload.v);
+		return payload.v;
+	} catch {
+		throw new Error("Invalid cursor format");
+	}
+}
+
+//#endregion
+exports.Direction = Direction;
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
+exports.paginatedSearch = paginatedSearch;
+//# sourceMappingURL=pagination.cjs.map

package/dist/kysely/pagination.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.cjs","names":["value: unknown","cursor: string"],"sources":["../../src/kysely/pagination.ts"],"sourcesContent":["import type { SelectQueryBuilder } from 'kysely';\n\n/**\n * Sort direction for cursor-based pagination.\n */\nexport enum Direction {\n  Asc = 'asc',\n  Desc = 'desc',\n}\n\n/**\n * Result of a paginated query.\n */\nexport interface PaginationResult<TItem> {\n  items: TItem[];\n  pagination: {\n    total: number;\n    hasMore: boolean;\n    cursor?: string;\n  };\n}\n\n/**\n * Options for paginated search.\n */\nexport interface PaginatedSearchOptions<\n  TRow,\n  TMapRow extends (row: TRow) => unknown,\n> {\n  /** The base Kysely query to paginate */\n  query: SelectQueryBuilder<any, any, TRow>;\n  /** Cursor value for pagination (value of cursorField from previous page) */\n  cursor?: string;\n  /** Maximum number of items per page (default: 20) */\n  limit?: number;\n  /** Function to transform each row to the output format */\n  mapRow: TMapRow;\n  /** Field to use for cursor pagination (default: 'id') */\n  cursorField?: string;\n  /** Sort direction for cursor field (default: Direction.Asc) */\n  cursorDirection?: Direction;\n}\n\n/**\n * Generic paginated search function that handles:\n * - Total count calculation\n * - Cursor-based pagination\n * - Fetching one extra row to determine hasMore\n * - Mapping rows to output format\n *\n * @example\n * ```typescript\n * const result = await paginatedSearch({\n *   query: db.selectFrom('users').selectAll(),\n *   cursor: previousCursor,\n *   limit: 20,\n *   mapRow: (row) => ({ id: row.id, name: row.name }),\n *   cursorField: 'id',\n *   cursorDirection: Direction.Asc,\n * });\n * ```\n */\nexport async function paginatedSearch<\n  TRow extends Record<string, unknown>,\n  TMapRow extends (row: TRow) => unknown,\n>({\n  query,\n  cursor,\n  limit = 20,\n  mapRow,\n  cursorField = 'id',\n  cursorDirection = Direction.Asc,\n}: PaginatedSearchOptions<TRow, TMapRow>): Promise<\n  PaginationResult<Awaited<ReturnType<TMapRow>>>\n> {\n  // Get total count (without cursor)\n  const countResult = await query\n    .clearSelect()\n    .clearOrderBy()\n    .select((eb) => eb.fn.countAll().as('count'))\n    .executeTakeFirstOrThrow();\n\n  const count = countResult.count;\n\n  // Apply cursor if provided\n  let paginatedQuery = query;\n  if (cursor) {\n    const operator = cursorDirection === Direction.Asc ? '>' : '<';\n    paginatedQuery = paginatedQuery.where(\n      cursorField as any,\n      operator,\n      cursor,\n    ) as typeof query;\n  }\n\n  // Fetch one extra to determine if there are more results\n  const data = await paginatedQuery\n    .orderBy(cursorField as any, cursorDirection)\n    .limit(limit + 1)\n    .execute();\n\n  const hasMore = data.length > limit;\n  const rows = hasMore ? data.slice(0, limit) : data;\n  const lastRow = rows[rows.length - 1];\n  const nextCursor =\n    hasMore && lastRow ? String(lastRow[cursorField]) : undefined;\n\n  const items = (await Promise.all(rows.map(mapRow))) as Awaited<\n    ReturnType<TMapRow>\n  >[];\n\n  return {\n    items,\n    pagination: {\n      total: Number(count),\n      hasMore,\n      cursor: nextCursor,\n    },\n  };\n}\n\n/**\n * Encode a cursor value for safe URL transmission.\n * Supports various types: string, number, Date, etc.\n */\nexport function encodeCursor(value: unknown): string {\n  const payload = {\n    v: value instanceof Date ? value.toISOString() : value,\n    t: value instanceof Date ? 'date' : typeof value,\n  };\n  return Buffer.from(JSON.stringify(payload)).toString('base64url');\n}\n\n/**\n * Decode a cursor string back to its original value.\n */\nexport function decodeCursor(cursor: string): unknown {\n  try {\n    const json = Buffer.from(cursor, 'base64url').toString('utf-8');\n    const payload = JSON.parse(json);\n\n    if (payload.t === 'date') {\n      return new Date(payload.v);\n    }\n\n    return payload.v;\n  } catch {\n    throw new Error('Invalid cursor format');\n  }\n}\n"],"mappings":";;;;;AAKA,IAAY,kDAAL;AACL;AACA;;AACD;;;;;;;;;;;;;;;;;;;;AAsDD,eAAsB,gBAGpB,EACA,OACA,QACA,QAAQ,IACR,QACA,cAAc,MACd,kBAAkB,UAAU,KACU,EAEtC;CAEA,MAAM,cAAc,MAAM,MACvB,aAAa,CACb,cAAc,CACd,OAAO,CAAC,OAAO,GAAG,GAAG,UAAU,CAAC,GAAG,QAAQ,CAAC,CAC5C,yBAAyB;CAE5B,MAAM,QAAQ,YAAY;CAG1B,IAAI,iBAAiB;AACrB,KAAI,QAAQ;EACV,MAAM,WAAW,oBAAoB,UAAU,MAAM,MAAM;AAC3D,mBAAiB,eAAe,MAC9B,aACA,UACA,OACD;CACF;CAGD,MAAM,OAAO,MAAM,eAChB,QAAQ,aAAoB,gBAAgB,CAC5C,MAAM,QAAQ,EAAE,CAChB,SAAS;CAEZ,MAAM,UAAU,KAAK,SAAS;CAC9B,MAAM,OAAO,UAAU,KAAK,MAAM,GAAG,MAAM,GAAG;CAC9C,MAAM,UAAU,KAAK,KAAK,SAAS;CACnC,MAAM,aACJ,WAAW,UAAU,OAAO,QAAQ,aAAa;CAEnD,MAAM,QAAS,MAAM,QAAQ,IAAI,KAAK,IAAI,OAAO,CAAC;AAIlD,QAAO;EACL;EACA,YAAY;GACV,OAAO,OAAO,MAAM;GACpB;GACA,QAAQ;EACT;CACF;AACF;;;;;AAMD,SAAgB,aAAaA,OAAwB;CACnD,MAAM,UAAU;EACd,GAAG,iBAAiB,OAAO,MAAM,aAAa,GAAG;EACjD,GAAG,iBAAiB,OAAO,gBAAgB;CAC5C;AACD,QAAO,OAAO,KAAK,KAAK,UAAU,QAAQ,CAAC,CAAC,SAAS,YAAY;AAClE;;;;AAKD,SAAgB,aAAaC,QAAyB;AACpD,KAAI;EACF,MAAM,OAAO,OAAO,KAAK,QAAQ,YAAY,CAAC,SAAS,QAAQ;EAC/D,MAAM,UAAU,KAAK,MAAM,KAAK;AAEhC,MAAI,QAAQ,MAAM,OAChB,QAAO,IAAI,KAAK,QAAQ;AAG1B,SAAO,QAAQ;CAChB,QAAO;AACN,QAAM,IAAI,MAAM;CACjB;AACF"}

package/dist/kysely/pagination.d.cts

@@ -0,0 +1,78 @@
+import { SelectQueryBuilder } from "kysely";
+
+//#region src/kysely/pagination.d.ts
+
+/**
+ * Sort direction for cursor-based pagination.
+ */
+declare enum Direction {
+  Asc = "asc",
+  Desc = "desc",
+}
+/**
+ * Result of a paginated query.
+ */
+interface PaginationResult<TItem> {
+  items: TItem[];
+  pagination: {
+    total: number;
+    hasMore: boolean;
+    cursor?: string;
+  };
+}
+/**
+ * Options for paginated search.
+ */
+interface PaginatedSearchOptions<TRow, TMapRow extends (row: TRow) => unknown> {
+  /** The base Kysely query to paginate */
+  query: SelectQueryBuilder<any, any, TRow>;
+  /** Cursor value for pagination (value of cursorField from previous page) */
+  cursor?: string;
+  /** Maximum number of items per page (default: 20) */
+  limit?: number;
+  /** Function to transform each row to the output format */
+  mapRow: TMapRow;
+  /** Field to use for cursor pagination (default: 'id') */
+  cursorField?: string;
+  /** Sort direction for cursor field (default: Direction.Asc) */
+  cursorDirection?: Direction;
+}
+/**
+ * Generic paginated search function that handles:
+ * - Total count calculation
+ * - Cursor-based pagination
+ * - Fetching one extra row to determine hasMore
+ * - Mapping rows to output format
+ *
+ * @example
+ * ```typescript
+ * const result = await paginatedSearch({
+ *   query: db.selectFrom('users').selectAll(),
+ *   cursor: previousCursor,
+ *   limit: 20,
+ *   mapRow: (row) => ({ id: row.id, name: row.name }),
+ *   cursorField: 'id',
+ *   cursorDirection: Direction.Asc,
+ * });
+ * ```
+ */
+declare function paginatedSearch<TRow extends Record<string, unknown>, TMapRow extends (row: TRow) => unknown>({
+  query,
+  cursor,
+  limit,
+  mapRow,
+  cursorField,
+  cursorDirection
+}: PaginatedSearchOptions<TRow, TMapRow>): Promise<PaginationResult<Awaited<ReturnType<TMapRow>>>>;
+/**
+ * Encode a cursor value for safe URL transmission.
+ * Supports various types: string, number, Date, etc.
+ */
+declare function encodeCursor(value: unknown): string;
+/**
+ * Decode a cursor string back to its original value.
+ */
+declare function decodeCursor(cursor: string): unknown;
+//#endregion
+export { Direction, PaginatedSearchOptions, PaginationResult, decodeCursor, encodeCursor, paginatedSearch };
+//# sourceMappingURL=pagination.d.cts.map