data-api-client 2.0.0 → 2.1.1

package/README.md

@@ -3,16 +3,34 @@
 [![npm](https://img.shields.io/npm/v/data-api-client.svg)](https://www.npmjs.com/package/data-api-client)
 [![npm](https://img.shields.io/npm/l/data-api-client.svg)](https://www.npmjs.com/package/data-api-client)
 
-> **Note:** Version 2.0.0 is currently in active development. We welcome your feedback and bug reports! Please [open an issue](https://github.com/jeremydaly/data-api-client/issues) if you encounter any problems or have suggestions for improvement.
+> **Note:** Version 2.1.0 introduces mysql2 and pg compatibility layers with full ORM support! We welcome your feedback and bug reports. Please [open an issue](https://github.com/jeremydaly/data-api-client/issues) if you encounter any problems or have suggestions for improvement.
 >
 > **Using v1.x?** See [README_v1.md](README_v1.md) for v1.x documentation.
 
-The **Data API Client** is a lightweight wrapper that simplifies working with the Amazon Aurora Serverless Data API by abstracting away the notion of field values. This abstraction annotates native JavaScript types supplied as input parameters, as well as converts annotated response data to native JavaScript types. It's basically a [DocumentClient](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) for the Data API. It also dramatically simplifies **transactions** and uses modern async/await patterns with AWS SDK v3.
+The **Data API Client** is a lightweight wrapper that simplifies working with the Amazon Aurora Serverless Data API by abstracting away the notion of field values. This abstraction annotates native JavaScript types supplied as input parameters, as well as converts annotated response data to native JavaScript types. It's basically a [DocumentClient](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) for the Data API. It also dramatically simplifies **transactions**, provides **automatic retry logic** for scale-to-zero clusters, and includes **compatibility layers** for mysql2 and pg with full **ORM support**.
 
-**Version 2.0** introduces support for the new [RDS Data API for Aurora Serverless v2 and Aurora provisioned database instances](https://aws.amazon.com/about-aws/whats-new/2024/09/amazon-aurora-mysql-rds-data-api/), enhanced [Amazon Aurora PostgreSQL-Compatible Edition](https://aws.amazon.com/about-aws/whats-new/2023/12/amazon-aurora-postgresql-rds-data-api/) support, migration to AWS SDK v3, full TypeScript implementation, and comprehensive PostgreSQL data type coverage including **automatic array handling**.
+**Version 2.1** adds mysql2 and pg compatibility layers, automatic retry logic for cluster wake-ups, and verified support for Drizzle ORM and Kysely query builder.
+
+**Version 2.0** introduced support for the new [RDS Data API for Aurora Serverless v2 and Aurora provisioned database instances](https://aws.amazon.com/about-aws/whats-new/2024/09/amazon-aurora-mysql-rds-data-api/), enhanced [Amazon Aurora PostgreSQL-Compatible Edition](https://aws.amazon.com/about-aws/whats-new/2023/12/amazon-aurora-postgresql-rds-data-api/) support, migration to AWS SDK v3, full TypeScript implementation, and comprehensive PostgreSQL data type coverage including **automatic array handling**.
 
 For more information about the Aurora Serverless Data API, you can review the [official documentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html) or read [Aurora Serverless Data API: An (updated) First Look](https://www.jeremydaly.com/aurora-serverless-data-api-a-first-look/) for some more insights on performance.
 
+## What's New in v2.1
+
+- **Automatic Retry Logic**: Built-in retry handling for Aurora Serverless scale-to-zero wake-ups
+  - Smart detection of `DatabaseResumingException` with optimized retry delays
+  - Automatic handling of connection errors with exponential backoff
+  - Configurable and enabled by default
+- **mysql2 Compatibility Layer**: Drop-in replacement for the `mysql2/promise` library
+  - Full support for connection pools and transactions
+  - Works seamlessly with ORMs like Drizzle and Kysely
+- **pg Compatibility Layer**: Drop-in replacement for the `pg` (node-postgres) library
+  - Promise-based and callback-based APIs
+  - Compatible with ORMs and query builders
+- **ORM Support**: Tested and verified with popular ORMs:
+  - **Drizzle ORM**: Full support for both MySQL and PostgreSQL
+  - **Kysely**: Query builder support for both engines
+
 ## What's New in v2.0
 
 - **AWS SDK v3**: Migrated from AWS SDK v2 to v3 for smaller bundle sizes and better tree-shaking
@@ -186,8 +204,49 @@ Below is a table containing all of the possible configuration options for the `d
 | database           | `string`        | _Optional_ default database to use with queries. Can be overridden when querying.                                                                                                                                                                   |                                                  |
 | engine             | `mysql` or `pg` | The type of database engine you're connecting to (MySQL or Postgres).                                                                                                                                                                               | `pg`                                             |
 | hydrateColumnNames | `boolean`       | When `true`, results will be returned as objects with column names as keys. If `false`, results will be returned as an array of values.                                                                                                             | `true`                                           |
+| namedPlaceholders  | `boolean`       | Enable named placeholders (`:name` syntax) for mysql2 compatibility layer. When `true`, parameters use object format. Only applies to mysql2 compat layer.                                                                                          | `false`                                          |
 | options            | `object`        | An _optional_ configuration object that is passed directly into the RDSDataClient constructor. See [AWS SDK docs](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/clients/client-rds-data/classes/rdsdataclient.html) for available options. | `{}`                                             |
 | formatOptions      | `object`        | Formatting options to auto parse dates and coerce native JavaScript date objects to supported date formats. Valid keys are `deserializeDate` and `treatAsLocalDate`. Both accept boolean values.                                                    | `deserializeDate: true, treatAsLocalDate: false` |
+| retryOptions       | `object`        | Configuration for automatic retry logic. Valid keys are `enabled` (boolean), `maxRetries` (number), and `retryableErrors` (string array).                                                                                                            | `enabled: true, maxRetries: 9`                   |
+
+### Automatic Retry Logic
+
+Version 2.1 includes built-in retry logic to handle Aurora Serverless scale-to-zero cluster wake-ups automatically. When your cluster is paused and needs to resume, the client will automatically retry your queries with optimized delays.
+
+**Features:**
+- **Smart Error Detection**: Automatically detects `DatabaseResumingException` and connection errors
+- **Strategy-Based Retries**: Different retry strategies based on error type:
+  - DatabaseResumingException: Up to 10 attempts with progressive delays (0s, 2s, 5s, 10s, 15s, 20s, 25s, 30s, 35s, 40s)
+  - Connection errors: 3 quick retries with exponential backoff (0s, 2s, 4s)
+- **Enabled by Default**: Works automatically without any configuration
+- **Configurable**: Customize retry behavior per your needs
+
+**Configuration:**
+
+```javascript
+const data = dataApiClient({
+  secretArn: 'arn:...',
+  resourceArn: 'arn:...',
+  database: 'myDatabase',
+  retryOptions: {
+    enabled: true, // Enable/disable retries (default: true)
+    maxRetries: 9, // Maximum retry attempts (default: 9 for up to 40s total)
+    retryableErrors: [] // Additional error patterns to retry (optional)
+  }
+})
+```
+
+**Disable retries** (not recommended for scale-to-zero clusters):
+
+```javascript
+const data = dataApiClient({
+  secretArn: 'arn:...',
+  resourceArn: 'arn:...',
+  retryOptions: { enabled: false }
+})
+```
+
+The retry logic works seamlessly across all operations: queries, transactions, batch operations, and compatibility layer methods.
 
 ### Connection Reuse
 
@@ -455,6 +514,293 @@ const data = dataApiClient({
 })
 ```
 
+## mysql2 and pg Compatibility Layers
+
+Version 2.1 introduces compatibility layers that allow you to use the Data API Client as a drop-in replacement for popular database libraries. This makes it easy to migrate existing applications or use ORMs without modification.
+
+### mysql2 Compatibility
+
+Use the Data API Client as a replacement for `mysql2/promise`:
+
+```javascript
+import { createMySQLConnection, createMySQLPool } from 'data-api-client/compat/mysql2'
+
+// Create a connection
+const connection = createMySQLConnection({
+  resourceArn: 'arn:aws:rds:us-east-1:XXXXXXXXXXXX:cluster:my-cluster',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:XXXXXXXXXXXX:secret:mySecret',
+  database: 'myDatabase'
+})
+
+// Use like mysql2/promise with positional placeholders
+const [rows, fields] = await connection.query('SELECT * FROM users WHERE id = ?', [123])
+await connection.execute('INSERT INTO users (name, email) VALUES (?, ?)', ['Alice', 'alice@example.com'])
+
+// Note: connection.end() is optional - it's a no-op for Data API (no connection to close)
+
+// Create a pool for connection pooling
+const pool = createMySQLPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+// Get connection from pool
+pool.getConnection((err, connection) => {
+  if (err) throw err
+  connection.query('SELECT * FROM users', (err, results) => {
+    connection.release() // Optional - no-op for Data API
+    // Handle results
+  })
+})
+
+// Or use promises
+const connection = await pool.getConnection()
+const [rows] = await connection.query('SELECT * FROM users')
+connection.release() // Optional - no-op for Data API
+```
+
+#### Named Placeholders Support
+
+The mysql2 compatibility layer supports **named placeholders** (`:name` syntax), matching the behavior of the native mysql2 library's `namedPlaceholders` option:
+
+```javascript
+import { createMySQLConnection, createMySQLPool } from 'data-api-client/compat/mysql2'
+
+// Create a connection with namedPlaceholders enabled
+const connection = createMySQLConnection({
+  resourceArn: 'arn:aws:rds:us-east-1:XXXXXXXXXXXX:cluster:my-cluster',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:XXXXXXXXXXXX:secret:mySecret',
+  database: 'myDatabase',
+  namedPlaceholders: true  // Enable named placeholders
+})
+
+// Use named placeholders with object parameters
+const [users] = await connection.query(
+  'SELECT * FROM users WHERE name = :name AND age > :age',
+  { name: 'Alice', age: 25 }
+)
+
+// INSERT with named placeholders
+await connection.query(
+  'INSERT INTO users (name, email, active) VALUES (:name, :email, :active)',
+  { name: 'Bob', email: 'bob@example.com', active: true }
+)
+
+// UPDATE with named placeholders
+await connection.query(
+  'UPDATE users SET age = :newAge WHERE id = :id',
+  { id: 123, newAge: 30 }
+)
+
+// Named placeholders work with transactions
+await connection.beginTransaction()
+try {
+  await connection.query(
+    'INSERT INTO orders (user_id, total) VALUES (:userId, :total)',
+    { userId: 123, total: 99.99 }
+  )
+  await connection.query(
+    'UPDATE users SET last_order = NOW() WHERE id = :userId',
+    { userId: 123 }
+  )
+  await connection.commit()
+} catch (err) {
+  await connection.rollback()
+}
+
+// Named placeholders also work with pools
+const pool = createMySQLPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase',
+  namedPlaceholders: true
+})
+
+const [results] = await pool.query(
+  'SELECT * FROM products WHERE category = :category AND price < :maxPrice',
+  { category: 'electronics', maxPrice: 500 }
+)
+```
+
+**Named Placeholders Features:**
+- Use `:paramName` syntax in SQL (colon followed by identifier)
+- Pass parameters as objects: `{ paramName: value }`
+- Same parameter can be referenced multiple times in the query
+- Works with all query types (SELECT, INSERT, UPDATE, DELETE)
+- Fully compatible with transactions, pools, and callbacks
+- Backward compatible: positional `?` placeholders still work when `namedPlaceholders` is disabled (default)
+
+**Query-Level namedPlaceholders:**
+
+You can also enable or disable named placeholders on a per-query basis, which overrides the connection-level setting:
+
+```javascript
+// Connection WITHOUT namedPlaceholders at config level
+const connection = createMySQLConnection({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+  // namedPlaceholders NOT set (defaults to false)
+})
+
+// Enable namedPlaceholders for specific queries
+const [rows] = await connection.query(
+  {
+    sql: 'SELECT * FROM users WHERE username = :username AND age > :minAge',
+    namedPlaceholders: true  // Enable for this query only
+  },
+  { username: 'john_doe', minAge: 25 }
+)
+
+// Or explicitly disable for a specific query (when connection has it enabled)
+const [rows2] = await connection.query(
+  {
+    sql: 'SELECT * FROM users WHERE id = ?',
+    namedPlaceholders: false  // Use positional placeholders for this query
+  },
+  [123]
+)
+```
+
+This allows you to:
+- Use named placeholders in specific queries without enabling it globally
+- Mix named and positional placeholders in different queries
+- Override connection-level settings when needed
+
+### pg Compatibility
+
+Use the Data API Client as a replacement for `pg` (node-postgres):
+
+```javascript
+import { createPgClient, createPgPool } from 'data-api-client/compat/pg'
+
+// Create a client
+const client = createPgClient({
+  resourceArn: 'arn:aws:rds:us-east-1:XXXXXXXXXXXX:cluster:my-cluster',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:XXXXXXXXXXXX:secret:mySecret',
+  database: 'myDatabase'
+})
+
+// Note: client.connect() is optional - it's a no-op for Data API (no connection needed)
+await client.connect() // Optional
+
+// Use like pg
+const result = await client.query('SELECT * FROM users WHERE id = $1', [123])
+console.log(result.rows)
+
+// With callback style
+client.query('SELECT * FROM users', (err, result) => {
+  console.log(result.rows)
+})
+
+// Note: client.end() is optional - it's a no-op for Data API (no connection to close)
+await client.end() // Optional
+
+// Create a pool
+const pool = createPgPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+const result = await pool.query('SELECT * FROM users WHERE id = $1', [123])
+```
+
+### Using with ORMs
+
+The compatibility layers work seamlessly with popular ORMs:
+
+#### Drizzle ORM
+
+**MySQL with Drizzle:**
+
+```typescript
+import { drizzle } from 'drizzle-orm/mysql2'
+import { createMySQLPool } from 'data-api-client/compat/mysql2'
+
+const pool = createMySQLPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+const db = drizzle(pool as any)
+
+// Use Drizzle normally
+const users = await db.select().from(usersTable).where(eq(usersTable.id, 123))
+```
+
+**PostgreSQL with Drizzle:**
+
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { createPgClient } from 'data-api-client/compat/pg'
+
+const client = createPgClient({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+// Note: client.connect() is optional (no-op for Data API)
+await client.connect() // Optional - can be omitted
+const db = drizzle(client as any)
+
+// Use Drizzle normally
+const users = await db.select().from(usersTable).where(eq(usersTable.id, 123))
+```
+
+#### Kysely Query Builder
+
+**MySQL with Kysely:**
+
+```typescript
+import { Kysely, MysqlDialect } from 'kysely'
+import { createMySQLPool } from 'data-api-client/compat/mysql2'
+
+const pool = createMySQLPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+const db = new Kysely<Database>({
+  dialect: new MysqlDialect({ pool: pool as any })
+})
+
+// Use Kysely normally
+const users = await db.selectFrom('users').selectAll().where('id', '=', 123).execute()
+```
+
+**PostgreSQL with Kysely:**
+
+```typescript
+import { Kysely, PostgresDialect } from 'kysely'
+import { createPgPool } from 'data-api-client/compat/pg'
+
+const pool = createPgPool({
+  resourceArn: 'arn:...',
+  secretArn: 'arn:...',
+  database: 'myDatabase'
+})
+
+const db = new Kysely<Database>({
+  dialect: new PostgresDialect({ pool: pool as any })
+})
+
+// Use Kysely normally
+const users = await db.selectFrom('users').selectAll().where('id', '=', 123).execute()
+```
+
+**Benefits of Compatibility Layers:**
+- **Zero code changes** when migrating from mysql2 or pg
+- **Full ORM support** (Drizzle, Kysely)
+- **Automatic retry logic** for cluster wake-ups
+- **Connection pooling simulation** (getConnection, release)
+- **Both Promise and callback APIs** supported
+- **No-op connection management**: `connect()`, `end()`, and `release()` are optional since the Data API is connectionless - they're included only for backward compatibility with existing code
+
 ## PostgreSQL Array Support
 
 One of the most powerful features in v2.0 is automatic PostgreSQL array handling. While the Data API has limitations with array _parameters_, array _results_ are fully supported and automatically converted to native JavaScript arrays.

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,mBAAmB,EAAkB,aAAa,EAA6B,MAAM,SAAS,CAAA;AAyB5G,eAAO,MAAM,IAAI,GAAI,QAAQ,mBAAmB,KAAG,aAkHlD,CAAA"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,mBAAmB,EAAkB,aAAa,EAA6B,MAAM,SAAS,CAAA;AA0B5G,eAAO,MAAM,IAAI,GAAI,QAAQ,mBAAmB,KAAG,aAoJlD,CAAA"}

package/dist/client.js

@@ -5,6 +5,7 @@ const client_rds_data_1 = require("@aws-sdk/client-rds-data");
 const utils_1 = require("./utils");
 const query_1 = require("./query");
 const transaction_1 = require("./transaction");
+const retry_1 = require("./retry");
 const init = (params) => {
     const options = typeof params.options === 'object'
         ? params.options
@@ -31,39 +32,48 @@ const init = (params) => {
             deserializeDate: typeof params.formatOptions === 'object' && params.formatOptions.deserializeDate === false ? false : true,
             treatAsLocalDate: typeof params.formatOptions === 'object' && params.formatOptions.treatAsLocalDate ? true : false
         },
+        retryOptions: {
+            enabled: typeof params.retryOptions === 'object' && params.retryOptions.enabled === false ? false : true,
+            maxRetries: typeof params.retryOptions === 'object' && typeof params.retryOptions.maxRetries === 'number'
+                ? params.retryOptions.maxRetries
+                : 9,
+            retryableErrors: typeof params.retryOptions === 'object' && Array.isArray(params.retryOptions.retryableErrors)
+                ? params.retryOptions.retryableErrors
+                : []
+        },
         RDS: params.client ? params.client : new client_rds_data_1.RDSDataClient(options)
     };
     return {
         query: (...x) => query_1.query.call(undefined, config, ...x),
         transaction: (x) => (0, transaction_1.transaction)(config, x),
-        batchExecuteStatement: async (args) => config.RDS.send(new client_rds_data_1.BatchExecuteStatementCommand({
+        batchExecuteStatement: async (args) => (0, retry_1.withRetry)(() => config.RDS.send(new client_rds_data_1.BatchExecuteStatementCommand({
             ...args,
             resourceArn: args.resourceArn || config.resourceArn,
             secretArn: args.secretArn || config.secretArn,
             database: args.database || config.database
-        })),
-        beginTransaction: async (args) => config.RDS.send(new client_rds_data_1.BeginTransactionCommand({
+        })), config.retryOptions),
+        beginTransaction: async (args) => (0, retry_1.withRetry)(() => config.RDS.send(new client_rds_data_1.BeginTransactionCommand({
             ...(args || {}),
             resourceArn: (args === null || args === void 0 ? void 0 : args.resourceArn) || config.resourceArn,
             secretArn: (args === null || args === void 0 ? void 0 : args.secretArn) || config.secretArn,
             database: (args === null || args === void 0 ? void 0 : args.database) || config.database
-        })),
-        commitTransaction: async (args) => config.RDS.send(new client_rds_data_1.CommitTransactionCommand({
+        })), config.retryOptions),
+        commitTransaction: async (args) => (0, retry_1.withRetry)(() => config.RDS.send(new client_rds_data_1.CommitTransactionCommand({
             ...args,
             resourceArn: args.resourceArn || config.resourceArn,
             secretArn: args.secretArn || config.secretArn
-        })),
-        executeStatement: async (args) => config.RDS.send(new client_rds_data_1.ExecuteStatementCommand({
+        })), config.retryOptions),
+        executeStatement: async (args) => (0, retry_1.withRetry)(() => config.RDS.send(new client_rds_data_1.ExecuteStatementCommand({
             ...args,
             resourceArn: args.resourceArn || config.resourceArn,
             secretArn: args.secretArn || config.secretArn,
             database: args.database || config.database
-        })),
-        rollbackTransaction: async (args) => config.RDS.send(new client_rds_data_1.RollbackTransactionCommand({
+        })), config.retryOptions),
+        rollbackTransaction: async (args) => (0, retry_1.withRetry)(() => config.RDS.send(new client_rds_data_1.RollbackTransactionCommand({
             ...args,
             resourceArn: args.resourceArn || config.resourceArn,
             secretArn: args.secretArn || config.secretArn
-        }))
+        })), config.retryOptions)
     };
 };
 exports.init = init;

package/dist/compat/errors.d.ts

@@ -0,0 +1,28 @@
+export interface PostgresError extends Error {
+    code?: string;
+    severity?: string;
+    detail?: string;
+    hint?: string;
+    position?: string;
+    internalPosition?: string;
+    internalQuery?: string;
+    where?: string;
+    schema?: string;
+    table?: string;
+    column?: string;
+    dataType?: string;
+    constraint?: string;
+    file?: string;
+    line?: string;
+    routine?: string;
+}
+export interface MySQLError extends Error {
+    code?: string;
+    errno?: number;
+    sqlState?: string;
+    sqlMessage?: string;
+    sql?: string;
+}
+export declare function mapToPostgresError(error: any): PostgresError;
+export declare function mapToMySQLError(error: any): MySQLError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/compat/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/compat/errors.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAc,SAAQ,KAAK;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAKD,MAAM,WAAW,UAAW,SAAQ,KAAK;IACvC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AA6BD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,GAAG,aAAa,CAgE5D;AAKD,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,UAAU,CA+GtD"}

package/dist/compat/errors.js

@@ -0,0 +1,163 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToPostgresError = mapToPostgresError;
+exports.mapToMySQLError = mapToMySQLError;
+function extractConstraintName(message) {
+    const match = message.match(/constraint "([^"]+)"/);
+    return match ? match[1] : undefined;
+}
+function extractTableName(message) {
+    const match = message.match(/table "([^"]+)"/);
+    return match ? match[1] : undefined;
+}
+function extractColumnName(message) {
+    const match = message.match(/column "([^"]+)"/);
+    return match ? match[1] : undefined;
+}
+function mapToPostgresError(error) {
+    var _a, _b;
+    const pgError = new Error(error.message);
+    pgError.name = 'error';
+    pgError.severity = 'ERROR';
+    const message = error.message || '';
+    if (message.includes('duplicate key') || message.includes('already exists')) {
+        pgError.code = '23505';
+        pgError.constraint = extractConstraintName(message);
+        pgError.detail = (_a = message.match(/Detail: (.+)/)) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    else if (message.includes('violates foreign key constraint')) {
+        pgError.code = '23503';
+        pgError.constraint = extractConstraintName(message);
+        pgError.table = extractTableName(message);
+    }
+    else if (message.includes('violates not-null constraint')) {
+        pgError.code = '23502';
+        pgError.column = extractColumnName(message);
+        pgError.table = extractTableName(message);
+    }
+    else if (message.includes('violates check constraint')) {
+        pgError.code = '23514';
+        pgError.constraint = extractConstraintName(message);
+    }
+    else if (message.includes('syntax error')) {
+        pgError.code = '42601';
+        pgError.position = (_b = message.match(/at or near "(.+?)"/)) === null || _b === void 0 ? void 0 : _b[1];
+    }
+    else if (message.includes('column') && message.includes('does not exist')) {
+        pgError.code = '42703';
+        pgError.column = extractColumnName(message);
+    }
+    else if (message.includes('relation') && message.includes('does not exist')) {
+        pgError.code = '42P01';
+        pgError.table = extractTableName(message);
+    }
+    else if (message.includes('function') && message.includes('does not exist')) {
+        pgError.code = '42883';
+    }
+    else if (message.includes('invalid input syntax')) {
+        pgError.code = '22P02';
+    }
+    else if (message.includes('division by zero')) {
+        pgError.code = '22012';
+    }
+    else if (message.includes('value too long')) {
+        pgError.code = '22001';
+    }
+    else if (message.includes('permission denied')) {
+        pgError.code = '42501';
+    }
+    else if (message.includes('connection') || message.includes('timeout')) {
+        pgError.code = '08006';
+    }
+    else {
+        pgError.code = 'EUNKNOWN';
+    }
+    return pgError;
+}
+function mapToMySQLError(error) {
+    const mysqlError = new Error(error.message);
+    mysqlError.sqlMessage = error.message || '';
+    const message = error.message || '';
+    if (message.includes('Duplicate entry') || message.includes('duplicate key')) {
+        mysqlError.code = 'ER_DUP_ENTRY';
+        mysqlError.errno = 1062;
+        mysqlError.sqlState = '23000';
+    }
+    else if (message.includes('foreign key constraint fails')) {
+        if (message.includes('Cannot delete or update a parent row')) {
+            mysqlError.code = 'ER_ROW_IS_REFERENCED_2';
+            mysqlError.errno = 1451;
+        }
+        else {
+            mysqlError.code = 'ER_NO_REFERENCED_ROW_2';
+            mysqlError.errno = 1452;
+        }
+        mysqlError.sqlState = '23000';
+    }
+    else if (message.includes('cannot be null') || message.includes('NOT NULL')) {
+        mysqlError.code = 'ER_BAD_NULL_ERROR';
+        mysqlError.errno = 1048;
+        mysqlError.sqlState = '23000';
+    }
+    else if (message.includes("Table") && message.includes("doesn't exist")) {
+        mysqlError.code = 'ER_NO_SUCH_TABLE';
+        mysqlError.errno = 1146;
+        mysqlError.sqlState = '42S02';
+    }
+    else if (message.includes('Unknown column')) {
+        mysqlError.code = 'ER_BAD_FIELD_ERROR';
+        mysqlError.errno = 1054;
+        mysqlError.sqlState = '42S22';
+    }
+    else if (message.includes('syntax') || message.includes('SQL syntax')) {
+        mysqlError.code = 'ER_PARSE_ERROR';
+        mysqlError.errno = 1064;
+        mysqlError.sqlState = '42000';
+    }
+    else if (message.includes('Data too long') || message.includes('too long')) {
+        mysqlError.code = 'ER_DATA_TOO_LONG';
+        mysqlError.errno = 1406;
+        mysqlError.sqlState = '22001';
+    }
+    else if (message.includes('Division by 0')) {
+        mysqlError.code = 'ER_DIVISION_BY_ZERO';
+        mysqlError.errno = 1365;
+        mysqlError.sqlState = '22012';
+    }
+    else if (message.includes('Access denied')) {
+        mysqlError.code = 'ER_ACCESS_DENIED_ERROR';
+        mysqlError.errno = 1045;
+        mysqlError.sqlState = '28000';
+    }
+    else if (message.includes('Deadlock')) {
+        mysqlError.code = 'ER_LOCK_DEADLOCK';
+        mysqlError.errno = 1213;
+        mysqlError.sqlState = '40001';
+    }
+    else if (message.includes('Lock wait timeout')) {
+        mysqlError.code = 'ER_LOCK_WAIT_TIMEOUT';
+        mysqlError.errno = 1205;
+        mysqlError.sqlState = 'HY000';
+    }
+    else if (message.includes("Can't connect")) {
+        mysqlError.code = 'ER_CONNECTION_ERROR';
+        mysqlError.errno = 2003;
+        mysqlError.sqlState = 'HY000';
+    }
+    else if (message.includes('server has gone away')) {
+        mysqlError.code = 'ER_SERVER_GONE_ERROR';
+        mysqlError.errno = 2006;
+        mysqlError.sqlState = 'HY000';
+    }
+    else if (message.includes('Lost connection')) {
+        mysqlError.code = 'ER_SERVER_LOST';
+        mysqlError.errno = 2013;
+        mysqlError.sqlState = 'HY000';
+    }
+    else {
+        mysqlError.code = 'EUNKNOWN';
+        mysqlError.errno = 0;
+        mysqlError.sqlState = 'HY000';
+    }
+    return mysqlError;
+}

package/dist/compat/index.d.ts

@@ -0,0 +1,7 @@
+export { createPgClient, createPgPool } from './pg';
+export type { PgCompatClient, PgCompatPool, PgQueryResult } from './pg';
+export { createMySQLConnection, createMySQLPool } from './mysql2';
+export type { Connection, Pool, PoolConnection, MySQL2QueryResult } from './mysql2';
+export { mapToPostgresError, mapToMySQLError } from './errors';
+export type { PostgresError, MySQLError } from './errors';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compat/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AACnD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAEvE,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AACjE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEnF,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC9D,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA"}