@nextlyhq/adapter-drizzle 0.0.2-alpha.5 → 0.0.2-alpha.50

package/dist/{adapter-BxJVtttb.d.ts → adapter-C-DmzBg8.d.ts}

@@ -1,7 +1,8 @@
+import { AnyRelations, SQL } from 'drizzle-orm';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.js';
-import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-Qe70wDOC.js';
+import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-Bj84e15B.js';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BIQ0YQZ_.js';
-import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.js';
+import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.js';
 
 /**
  * Base database adapter abstract class.
@@ -16,53 +17,6 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.js'
  * @packageDocumentation
  */
 
-/**
- * Abstract base class for database adapters.
- *
- * @remarks
- * All dialect-specific adapters must extend this class and implement the abstract methods.
- * Default implementations are provided for CRUD operations, which can be overridden for
- * optimization or dialect-specific behavior.
- *
- * ## Required Implementations
- *
- * Subclasses must implement:
- * - `dialect` - Database dialect identifier
- * - `connect()` - Establish database connection
- * - `disconnect()` - Close database connection
- * - `executeQuery()` - Execute raw SQL query
- * - `transaction()` - Execute operations within a transaction
- * - `getCapabilities()` - Report database feature support
- *
- * ## Optional Overrides
- *
- * Subclasses can override default CRUD methods for optimization:
- * - `select()`, `selectOne()` - Custom query optimization
- * - `insert()`, `insertMany()` - Bulk insert optimization
- * - `update()`, `delete()` - Custom update/delete logic
- * - `upsert()` - Dialect-specific upsert syntax
- *
- * @example
- * ```typescript
- * export class PostgresAdapter extends DrizzleAdapter {
- *   readonly dialect = 'postgresql' as const;
- *
- *   async connect() {
- *     this.pool = new Pool({ connectionString: this.config.url });
- *     // ... connection logic
- *   }
- *
- *   async executeQuery<T>(sql: string, params?: SqlParam[]) {
- *     const result = await this.pool.query(sql, params);
- *     return result.rows as T[];
- *   }
- *
- *   // ... other required methods
- * }
- * ```
- *
- * @public
- */
 declare abstract class DrizzleAdapter {
     /**
      * Database dialect identifier.
@@ -106,11 +60,29 @@ declare abstract class DrizzleAdapter {
      * The transaction is automatically committed on success or rolled back on error.
      * Supports nested transactions via savepoints on databases that support them.
      *
+     * Two kinds of error leave this method, and a caller has to be able to tell
+     * them apart. An error carrying the Nextly application brand — see
+     * `isApplicationError` — arrives exactly as it was thrown, because that is
+     * the application refusing the write rather than the database failing to
+     * perform it, and rewriting it would discard the code and payload the caller
+     * is meant to act on.
+     *
+     * Everything else arrives as a `DatabaseError` with its kind classified, and
+     * that deliberately includes an unbranded error the callback itself threw:
+     * the brand is the only thing distinguishing a deliberate refusal from a
+     * driver failure that surfaced through callback code, and guessing from the
+     * throw site would put raw driver text on the wire under a caller's own
+     * error shape.
+     *
+     * The rollback is the same either way.
+     *
      * @param callback - Function to execute within transaction
      * @param options - Transaction options
      * @returns Result from the callback
      *
-     * @throws {DatabaseError} If transaction fails
+     * @throws {DatabaseError} If the transaction itself fails, or if the callback
+     * threw an error that does not carry the application brand
+     * @throws The callback's own error, unchanged, when it carries that brand
      */
     abstract transaction<T>(callback: (ctx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
     /**
@@ -136,17 +108,18 @@ declare abstract class DrizzleAdapter {
      * - Consistent error handling
      * - Proper connection pooling
      *
-     * @param schema - Optional schema object for typed queries
+     * @param relations - Optional drizzle v1 relations config (defineRelations
+     *   output) that enables the typed relational query API on the instance
      * @returns Raw Drizzle ORM database instance
      *
      * @example
      * ```typescript
      * // For legacy code that needs direct Drizzle access
-     * const db = adapter.getDrizzle(mySchemas);
+     * const db = adapter.getDrizzle(myRelations); // defineRelations output
      * const result = await db.insert(users).values({ ... }).returning();
      * ```
      */
-    abstract getDrizzle<T = unknown>(schema?: Record<string, unknown>): T;
+    abstract getDrizzle<T = unknown>(relations?: AnyRelations): T;
     /**
      * Table resolver for looking up Drizzle table objects by name.
      * When set, CRUD methods use Drizzle's query API instead of raw SQL.
@@ -167,6 +140,27 @@ declare abstract class DrizzleAdapter {
      * Returns null if no resolver is set or table is not found.
      */
     protected getTableObject(tableName: string): unknown;
+    /**
+     * Run a Drizzle-built statement and return its rows.
+     *
+     * @remarks
+     * The CRUD methods resolve their table through the schema registry and reject
+     * any name it does not declare, which leaves no way to read from a table the
+     * ORM does not know — one mid-rename, above all — except by assembling SQL and
+     * quoting identifiers by hand. This takes Drizzle's `sql` template instead, so
+     * the dialect in use decides the quoting and the parameter binding.
+     *
+     * Concrete rather than abstract so existing adapters keep working unchanged.
+     * The three drivers disagree about both the call and the result: node-postgres
+     * returns `{ rows }`, mysql2 a `[rows, fields]` tuple, and better-sqlite3 has
+     * no `execute` at all and answers `all`. Keeping that here rather than at each
+     * call site is the point — a caller reasoning about it would be reasoning
+     * about a driver it cannot see.
+     *
+     * @param statement - Drizzle `sql` template to run
+     * @returns Rows the statement produced
+     */
+    queryStatement<T = Record<string, unknown>>(statement: SQL): Promise<T[]>;
     /**
      * Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
      * Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
@@ -174,6 +168,44 @@ declare abstract class DrizzleAdapter {
      * because they match the DB column names. This method maps them to the JS names Drizzle expects.
      */
     protected mapDataToColumnNames(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Map data keys from Drizzle JS property names to SQL column names for the
+     * raw-SQL transaction insert path. The transaction context builds INSERT
+     * statements from Object.keys(data) used directly as column identifiers, so a
+     * table whose Drizzle property names differ from its SQL column names
+     * (camelCase core tables like nextly_versions) needs its keys translated
+     * first. For tables whose property names already equal their column names
+     * (the dynamic dc_/single_/comp_ tables) every lookup is identity, so
+     * existing callers are unaffected.
+     */
+    protected mapKeysToSqlColumns(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Map a list of column identifiers (Drizzle property names) to their SQL
+     * column names, for the raw-SQL transaction insert paths that build a
+     * RETURNING clause from `options.returning`. Same identity behavior as
+     * `mapKeysToSqlColumns`: names that are already SQL columns (the dynamic
+     * dc_/single_/comp_ tables) pass through unchanged.
+     */
+    protected mapColumnNamesToSql(tableObj: unknown, names: string[]): string[];
+    /**
+     * Remap a raw-SQL result row's KEYS from SQL column names to Drizzle property
+     * names, so the raw-SQL transaction insert paths return the same key casing
+     * as the non-transactional (Drizzle) insert. Keys only - values are left
+     * untouched, so this does not change how JSON/date columns are decoded. For
+     * tables whose property names already equal their SQL columns (the dynamic
+     * dc_/single_/comp_ tables) every lookup is identity, so existing callers see
+     * no change.
+     */
+    protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Build a Drizzle column projection object (`{ propertyName: column }`) from a
+     * requested column list, used by `select` (columns) and `insert` (returning).
+     * A requested name resolves against either the Drizzle property name
+     * (camelCase) or the SQL column name (snake_case); the projection is keyed by
+     * the property name so the row shape matches a full select. Returns undefined
+     * for `"*"` or when nothing resolves, so callers fall back to all columns.
+     */
+    protected buildColumnProjection(tableObj: unknown, names: string[] | "*" | undefined): Record<string, unknown> | undefined;
     /**
      * Check if the adapter is currently connected.
      *
@@ -286,7 +318,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    select<T = unknown>(table: string, options?: SelectOptions): Promise<T[]>;
+    select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     /**
      * Select a single record from a table.
      *
@@ -307,7 +339,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    selectOne<T = unknown>(table: string, options?: SelectOptions): Promise<T | null>;
+    selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
     /**
      * Insert a single record into a table.
      *
@@ -378,7 +410,7 @@ declare abstract class DrizzleAdapter {
      * );
      * ```
      */
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions): Promise<T[]>;
+    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     /**
      * Delete records from a table.
      *
@@ -401,7 +433,7 @@ declare abstract class DrizzleAdapter {
      * console.log(`Deleted ${count} users`);
      * ```
      */
-    delete(table: string, where: WhereClause, _options?: DeleteOptions): Promise<number>;
+    delete(table: string, where: WhereClause, _options?: DeleteOptions, executor?: unknown): Promise<number>;
     /**
      * Upsert (INSERT or UPDATE) a record.
      *
@@ -429,7 +461,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions): Promise<T>;
+    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
     /**
      * Run pending migrations.
      *

package/dist/{adapter-nvlxFkF-.d.cts → adapter-CZUQ2aV4.d.cts}

@@ -1,7 +1,8 @@
+import { AnyRelations, SQL } from 'drizzle-orm';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.cjs';
-import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-BbO5meEV.cjs';
+import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-BUc56kip.cjs';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BDn8WfSL.cjs';
-import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.cjs';
+import { D as DatabaseErrorKind, a as DatabaseError } from './error-BrdknH2s.cjs';
 
 /**
  * Base database adapter abstract class.
@@ -16,53 +17,6 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.cjs
  * @packageDocumentation
  */
 
-/**
- * Abstract base class for database adapters.
- *
- * @remarks
- * All dialect-specific adapters must extend this class and implement the abstract methods.
- * Default implementations are provided for CRUD operations, which can be overridden for
- * optimization or dialect-specific behavior.
- *
- * ## Required Implementations
- *
- * Subclasses must implement:
- * - `dialect` - Database dialect identifier
- * - `connect()` - Establish database connection
- * - `disconnect()` - Close database connection
- * - `executeQuery()` - Execute raw SQL query
- * - `transaction()` - Execute operations within a transaction
- * - `getCapabilities()` - Report database feature support
- *
- * ## Optional Overrides
- *
- * Subclasses can override default CRUD methods for optimization:
- * - `select()`, `selectOne()` - Custom query optimization
- * - `insert()`, `insertMany()` - Bulk insert optimization
- * - `update()`, `delete()` - Custom update/delete logic
- * - `upsert()` - Dialect-specific upsert syntax
- *
- * @example
- * ```typescript
- * export class PostgresAdapter extends DrizzleAdapter {
- *   readonly dialect = 'postgresql' as const;
- *
- *   async connect() {
- *     this.pool = new Pool({ connectionString: this.config.url });
- *     // ... connection logic
- *   }
- *
- *   async executeQuery<T>(sql: string, params?: SqlParam[]) {
- *     const result = await this.pool.query(sql, params);
- *     return result.rows as T[];
- *   }
- *
- *   // ... other required methods
- * }
- * ```
- *
- * @public
- */
 declare abstract class DrizzleAdapter {
     /**
      * Database dialect identifier.
@@ -106,11 +60,29 @@ declare abstract class DrizzleAdapter {
      * The transaction is automatically committed on success or rolled back on error.
      * Supports nested transactions via savepoints on databases that support them.
      *
+     * Two kinds of error leave this method, and a caller has to be able to tell
+     * them apart. An error carrying the Nextly application brand — see
+     * `isApplicationError` — arrives exactly as it was thrown, because that is
+     * the application refusing the write rather than the database failing to
+     * perform it, and rewriting it would discard the code and payload the caller
+     * is meant to act on.
+     *
+     * Everything else arrives as a `DatabaseError` with its kind classified, and
+     * that deliberately includes an unbranded error the callback itself threw:
+     * the brand is the only thing distinguishing a deliberate refusal from a
+     * driver failure that surfaced through callback code, and guessing from the
+     * throw site would put raw driver text on the wire under a caller's own
+     * error shape.
+     *
+     * The rollback is the same either way.
+     *
      * @param callback - Function to execute within transaction
      * @param options - Transaction options
      * @returns Result from the callback
      *
-     * @throws {DatabaseError} If transaction fails
+     * @throws {DatabaseError} If the transaction itself fails, or if the callback
+     * threw an error that does not carry the application brand
+     * @throws The callback's own error, unchanged, when it carries that brand
      */
     abstract transaction<T>(callback: (ctx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
     /**
@@ -136,17 +108,18 @@ declare abstract class DrizzleAdapter {
      * - Consistent error handling
      * - Proper connection pooling
      *
-     * @param schema - Optional schema object for typed queries
+     * @param relations - Optional drizzle v1 relations config (defineRelations
+     *   output) that enables the typed relational query API on the instance
      * @returns Raw Drizzle ORM database instance
      *
      * @example
      * ```typescript
      * // For legacy code that needs direct Drizzle access
-     * const db = adapter.getDrizzle(mySchemas);
+     * const db = adapter.getDrizzle(myRelations); // defineRelations output
      * const result = await db.insert(users).values({ ... }).returning();
      * ```
      */
-    abstract getDrizzle<T = unknown>(schema?: Record<string, unknown>): T;
+    abstract getDrizzle<T = unknown>(relations?: AnyRelations): T;
     /**
      * Table resolver for looking up Drizzle table objects by name.
      * When set, CRUD methods use Drizzle's query API instead of raw SQL.
@@ -167,6 +140,27 @@ declare abstract class DrizzleAdapter {
      * Returns null if no resolver is set or table is not found.
      */
     protected getTableObject(tableName: string): unknown;
+    /**
+     * Run a Drizzle-built statement and return its rows.
+     *
+     * @remarks
+     * The CRUD methods resolve their table through the schema registry and reject
+     * any name it does not declare, which leaves no way to read from a table the
+     * ORM does not know — one mid-rename, above all — except by assembling SQL and
+     * quoting identifiers by hand. This takes Drizzle's `sql` template instead, so
+     * the dialect in use decides the quoting and the parameter binding.
+     *
+     * Concrete rather than abstract so existing adapters keep working unchanged.
+     * The three drivers disagree about both the call and the result: node-postgres
+     * returns `{ rows }`, mysql2 a `[rows, fields]` tuple, and better-sqlite3 has
+     * no `execute` at all and answers `all`. Keeping that here rather than at each
+     * call site is the point — a caller reasoning about it would be reasoning
+     * about a driver it cannot see.
+     *
+     * @param statement - Drizzle `sql` template to run
+     * @returns Rows the statement produced
+     */
+    queryStatement<T = Record<string, unknown>>(statement: SQL): Promise<T[]>;
     /**
      * Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
      * Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
@@ -174,6 +168,44 @@ declare abstract class DrizzleAdapter {
      * because they match the DB column names. This method maps them to the JS names Drizzle expects.
      */
     protected mapDataToColumnNames(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Map data keys from Drizzle JS property names to SQL column names for the
+     * raw-SQL transaction insert path. The transaction context builds INSERT
+     * statements from Object.keys(data) used directly as column identifiers, so a
+     * table whose Drizzle property names differ from its SQL column names
+     * (camelCase core tables like nextly_versions) needs its keys translated
+     * first. For tables whose property names already equal their column names
+     * (the dynamic dc_/single_/comp_ tables) every lookup is identity, so
+     * existing callers are unaffected.
+     */
+    protected mapKeysToSqlColumns(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Map a list of column identifiers (Drizzle property names) to their SQL
+     * column names, for the raw-SQL transaction insert paths that build a
+     * RETURNING clause from `options.returning`. Same identity behavior as
+     * `mapKeysToSqlColumns`: names that are already SQL columns (the dynamic
+     * dc_/single_/comp_ tables) pass through unchanged.
+     */
+    protected mapColumnNamesToSql(tableObj: unknown, names: string[]): string[];
+    /**
+     * Remap a raw-SQL result row's KEYS from SQL column names to Drizzle property
+     * names, so the raw-SQL transaction insert paths return the same key casing
+     * as the non-transactional (Drizzle) insert. Keys only - values are left
+     * untouched, so this does not change how JSON/date columns are decoded. For
+     * tables whose property names already equal their SQL columns (the dynamic
+     * dc_/single_/comp_ tables) every lookup is identity, so existing callers see
+     * no change.
+     */
+    protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Build a Drizzle column projection object (`{ propertyName: column }`) from a
+     * requested column list, used by `select` (columns) and `insert` (returning).
+     * A requested name resolves against either the Drizzle property name
+     * (camelCase) or the SQL column name (snake_case); the projection is keyed by
+     * the property name so the row shape matches a full select. Returns undefined
+     * for `"*"` or when nothing resolves, so callers fall back to all columns.
+     */
+    protected buildColumnProjection(tableObj: unknown, names: string[] | "*" | undefined): Record<string, unknown> | undefined;
     /**
      * Check if the adapter is currently connected.
      *
@@ -286,7 +318,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    select<T = unknown>(table: string, options?: SelectOptions): Promise<T[]>;
+    select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     /**
      * Select a single record from a table.
      *
@@ -307,7 +339,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    selectOne<T = unknown>(table: string, options?: SelectOptions): Promise<T | null>;
+    selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
     /**
      * Insert a single record into a table.
      *
@@ -378,7 +410,7 @@ declare abstract class DrizzleAdapter {
      * );
      * ```
      */
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions): Promise<T[]>;
+    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     /**
      * Delete records from a table.
      *
@@ -401,7 +433,7 @@ declare abstract class DrizzleAdapter {
      * console.log(`Deleted ${count} users`);
      * ```
      */
-    delete(table: string, where: WhereClause, _options?: DeleteOptions): Promise<number>;
+    delete(table: string, where: WhereClause, _options?: DeleteOptions, executor?: unknown): Promise<number>;
     /**
      * Upsert (INSERT or UPDATE) a record.
      *
@@ -429,7 +461,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions): Promise<T>;
+    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
     /**
      * Run pending migrations.
      *

package/dist/{error-um1d_3Uo.d.cts → error-BrdknH2s.d.cts}

@@ -64,6 +64,23 @@ interface DatabaseError extends Error {
  * @public
  */
 declare function isDatabaseError(error: unknown): error is DatabaseError;
+/**
+ * Whether an error is the application's verdict rather than the database's
+ * failure.
+ *
+ * Work running inside a transaction may throw to roll the write back — a
+ * refused value, a permission denial — and such an error is not something the
+ * driver produced. Classifying it as a database error replaces its code and its
+ * payload with a generic one, so a caller that asked for a refusal is handed an
+ * unexplained failure instead, and per-field validation detail is lost on the
+ * way out.
+ *
+ * @param error - Error to check
+ * @returns True if the error was raised by application code
+ *
+ * @public
+ */
+declare function isApplicationError(error: unknown): boolean;
 /**
  * Database error constructor options.
  *
@@ -102,4 +119,4 @@ interface DatabaseErrorOptions {
  */
 declare function createDatabaseError(options: DatabaseErrorOptions): DatabaseError;
 
-export { type DatabaseErrorKind as D, type DatabaseError as a, type DatabaseErrorOptions as b, createDatabaseError as c, isDatabaseError as i };
+export { type DatabaseErrorKind as D, type DatabaseError as a, type DatabaseErrorOptions as b, createDatabaseError as c, isDatabaseError as d, isApplicationError as i };

package/dist/{error-um1d_3Uo.d.ts → error-BrdknH2s.d.ts}

@@ -64,6 +64,23 @@ interface DatabaseError extends Error {
  * @public
  */
 declare function isDatabaseError(error: unknown): error is DatabaseError;
+/**
+ * Whether an error is the application's verdict rather than the database's
+ * failure.
+ *
+ * Work running inside a transaction may throw to roll the write back — a
+ * refused value, a permission denial — and such an error is not something the
+ * driver produced. Classifying it as a database error replaces its code and its
+ * payload with a generic one, so a caller that asked for a refusal is handed an
+ * unexplained failure instead, and per-field validation detail is lost on the
+ * way out.
+ *
+ * @param error - Error to check
+ * @returns True if the error was raised by application code
+ *
+ * @public
+ */
+declare function isApplicationError(error: unknown): boolean;
 /**
  * Database error constructor options.
  *
@@ -102,4 +119,4 @@ interface DatabaseErrorOptions {
  */
 declare function createDatabaseError(options: DatabaseErrorOptions): DatabaseError;
 
-export { type DatabaseErrorKind as D, type DatabaseError as a, type DatabaseErrorOptions as b, createDatabaseError as c, isDatabaseError as i };
+export { type DatabaseErrorKind as D, type DatabaseError as a, type DatabaseErrorOptions as b, createDatabaseError as c, isDatabaseError as d, isApplicationError as i };