### Get Drizzle Instance with Turso Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-service.md

Example of how to initialize and retrieve a Drizzle database instance using the getDrizzle method with Turso/LibSQL configuration and optional Drizzle ORM configuration.

```typescript
const db = await getDrizzle({
  turso: {
    config: {
      url: 'libsql://my-database.turso.io',
      authToken: 'token123',
    },
  },
  config: { schema: { ...schema } },
});
```

--------------------------------

### Initialize Drizzle Database Instance

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-service.md

Demonstrates how to use DrizzlePostgresService to get a Drizzle database instance with PostgresJS. This is an internal usage example and direct injection is not recommended.

```typescript
import { Injectable } from '@nestjs/common';
import { DrizzlePostgresService } from '@knaadh/nestjs-drizzle-postgres';
import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';

@Injectable()
export class DataAccessLayer {
  constructor(private drizzleService: DrizzlePostgresService) {}

  initializeDatabase() {
    const db: PostgresJsDatabase = this.drizzleService.getDrizzle({
      postgres: {
        url: 'postgres://user:password@localhost:5432/mydb',
        config: { 
          ssl: true,
          connection: { 
            timeout: 10000 
          } 
        },
      },
      config: { 
        schema: { /* schema definitions */ } 
      },
    });

    return db;
  }
}
```

--------------------------------

### Install PlanetScale Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the PlanetScale package for NestJS Drizzle. Ensure drizzle-orm and the @planetscale/database are also installed.

```bash
npm install @knaadh/nestjs-drizzle-planetscale drizzle-orm @planetscale/database
```

--------------------------------

### Configure Turso/LibSQL with Local File

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring the Turso/LibSQL driver to connect to a local SQLite database file.

```typescript
const config: DrizzleTursoConfig = {
  turso: {
    config: {
      url: 'file:./local.db'
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Module Registration Example

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-service.md

Shows the recommended way to register DrizzlePostgresModule using `register()` for dependency injection.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  DrizzlePostgresModule
} from '@knaadh/nestjs-drizzle-postgres';

@Module({
  imports: [
    DrizzlePostgresModule.register({
      tag: 'DB',
      postgres: { url: 'postgres://...' },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Service Injection Example

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-service.md

Illustrates how to inject the Drizzle database instance into a service after module registration.

```typescript
import {
  Injectable,
  Inject
} from '@nestjs/common';
import {
  PostgresJsDatabase
} from 'drizzle-orm/postgres-js';

@Injectable()
export class UserService {
  constructor(@Inject('DB') private db: PostgresJsDatabase) {
    // Use db directly without accessing the service
  }
}
```

--------------------------------

### Install Turso Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the Turso package for NestJS Drizzle. Ensure drizzle-orm and the @libsql/client are also installed.

```bash
npm install @knaadh/nestjs-drizzle-turso drizzle-orm @libsql/client
```

--------------------------------

### Configure Turso/LibSQL with In-Memory Database

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring the Turso/LibSQL driver to use an in-memory database for temporary data.

```typescript
const config: DrizzleTursoConfig = {
  turso: {
    config: {
      url: 'memory:'
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Configure Turso/LibSQL with Turso Cloud

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring the Turso/LibSQL driver to connect to Turso Cloud using a database URL and authentication token.

```typescript
const config: DrizzleTursoConfig = {
  turso: {
    config: {
      url: 'libsql://my-database.turso.io',
      authToken: process.env.TURSO_AUTH_TOKEN
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Install Better-SQLite3 Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the Better-SQLite3 package for NestJS Drizzle. Ensure drizzle-orm and the better-sqlite3 driver are also installed.

```bash
npm install @knaadh/nestjs-drizzle-better-sqlite3 drizzle-orm better-sqlite3
```

--------------------------------

### Install MySQL2 Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the MySQL2 package for NestJS Drizzle. Ensure drizzle-orm and the mysql2 driver are also installed.

```bash
npm install @knaadh/nestjs-drizzle-mysql2 drizzle-orm mysql2
```

--------------------------------

### Local SQLite File URL Format

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-module.md

Example of a URL format for connecting to a local SQLite file.

```typescript
url: 'file:./local.db'
```

--------------------------------

### Install Node-Postgres Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the Node-Postgres package for NestJS Drizzle. Ensure drizzle-orm and the pg driver are also installed.

```bash
npm install @knaadh/nestjs-drizzle-pg drizzle-orm pg
```

--------------------------------

### Configure Better-SQLite3 with a File

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring Better-SQLite3 to use a persistent database file named 'app.db' with specific driver options.

```typescript
const config: DrizzleBetterSQLiteConfig = {
  sqlite3: {
    filename: 'app.db',
    options: {
      readonly: false,
      timeout: 5000
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### MySQL2 Client Connection Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring a single MySQL2 client connection using an options object. Ensure all required connection properties are provided.

```typescript
const config: DrizzleMySqlConfig = {
  mysql: {
    connection: 'client',
    config: {
      host: 'localhost',
      port: 3306,
      database: 'mydb',
      user: 'root',
      password: 'password'
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Environment Variables for PostgreSQL

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/QUICK-START.md

Example .env file for configuring PostgreSQL connection details and pool size for a NestJS application.

```bash
# .env
DATABASE_URL=postgres://user:password@localhost:5432/mydb
DB_POOL_SIZE=10
NODE_ENV=development
```

--------------------------------

### Recommended Usage with Dependency Injection

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-service.md

Demonstrates the recommended way to register the module and inject the Better-SQLite3 database instance into a service. Use `DrizzleBetterSQLiteModule.register()` or `registerAsync()` for module setup.

```typescript
import { Module, Injectable, Inject } from '@nestjs/common';
import { DrizzleBetterSQLiteModule } from 'nestjs-drizzle-better-sqlite3';
import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
import * as schema from './schema';

@Module({
  imports: [
    DrizzleBetterSQLiteModule.register({
      tag: 'DB',
      sqlite3: { filename: 'app.db' },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}

@Injectable()
export class UserService {
  constructor(@Inject('DB') private db: BetterSQLite3Database) {
    // Use db directly
  }
}
```

--------------------------------

### Usage Examples

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/node-postgres-decorator.md

Illustrates how to use the InjectDrizzle decorator with default and custom tags, including scenarios with multiple database instances and different connection modes.

```APIDOC
### With Default Tag

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-pg';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';
import * as schema from './db/schema';

@Injectable()
export class UserService {
  constructor(
    @InjectDrizzle() private db: NodePgDatabase<typeof schema>
  ) {}

  async getUsers() {
    return await this.db.query.users.findMany();
  }
}
```

Requires module registration with default tag:

```typescript
@Module({
  imports: [
    DrizzlePGModule.register({
      pg: {
        connection: 'pool',
        config: { /* ... */ },
      },
      config: { schema: { ...schema } },
      // tag defaults to 'default'
    }),
  ],
})
export class AppModule {}
```

### With Custom Tag

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-pg';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';
import * as schema from './db/schema';

@Injectable()
export class UserService {
  constructor(
    @InjectDrizzle('PRIMARY_DB') private db: NodePgDatabase<typeof schema>
  ) {}

  async getUsers() {
    return await this.db.query.users.findMany();
  }
}
```

Requires module registration with matching tag:

```typescript
@Module({
  imports: [
    DrizzlePGModule.register({
      tag: 'PRIMARY_DB',
      pg: {
        connection: 'pool',
        config: { /* ... */ },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

### Multiple Database Instances

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-pg';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';
import * as schema from './db/schema';

@Injectable()
export class DataService {
  constructor(
    @InjectDrizzle('READ_DB') private readDb: NodePgDatabase<typeof schema>,
    @InjectDrizzle('WRITE_DB') private writeDb: NodePgDatabase<typeof schema>
  ) {}

  async getData() {
    // Read from read replica
    return await this.readDb.query.users.findMany();
  }

  async createUser(data: any) {
    // Write to primary
    return await this.writeDb.insert(usersTable).values(data);
  }
}
```

Module registration:

```typescript
@Module({
  imports: [
    DrizzlePGModule.register({
      tag: 'READ_DB',
      pg: {
        connection: 'pool',
        config: { host: 'read-replica.example.com', /* ... */ },
      },
      config: { schema: { ...schema } },
    }),
    DrizzlePGModule.register({
      tag: 'WRITE_DB',
      pg: {
        connection: 'pool',
        config: { host: 'primary.example.com', /* ... */ },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

### With Client Connection Mode

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-pg';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';

@Injectable()
export class EventService {
  constructor(
    @InjectDrizzle('SERVERLESS_DB') private db: NodePgDatabase
  ) {}

  async logEvent(event: any) {
    return await this.db.insert(eventsTable).values(event);
  }
}
```

Module registration:

```typescript
@Module({
  imports: [
    DrizzlePGModule.register({
      tag: 'SERVERLESS_DB',
      pg: {
        connection: 'client', // Single connection for serverless
        config: { /* ... */ },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```
```

--------------------------------

### Install PostgresJS Package

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/PACKAGES.md

Use this command to install the PostgresJS package for NestJS Drizzle. Ensure drizzle-orm and the postgres driver are also installed.

```bash
npm install @knaadh/nestjs-drizzle-postgres drizzle-orm postgres
```

--------------------------------

### Turso Cloud Database URL Format

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-module.md

Example of a URL format for connecting to a Turso cloud database.

```typescript
url: 'libsql://my-database.turso.io'
```

--------------------------------

### Synchronous Module Registration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/SUMMARY.md

Use for straightforward module setup with direct configuration. Ensure the schema is correctly defined.

```typescript
Module.register({
  tag: 'DB',
  [driver]: { /* config */ },
  config: { schema: { ...schema } }
})
```

--------------------------------

### In-Memory Database URL Format

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-module.md

Example of a URL format for using an in-memory SQLite database.

```typescript
url: 'memory:'
```

--------------------------------

### Turso Cloud Connection

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-service.md

Example configuration for connecting to a Turso Cloud database using its URL and authentication token.

```typescript
url: 'libsql://my-database.turso.io'
authToken: 'eyJhbGciOiJFZDI1NTE5In0...'
```

--------------------------------

### Configure Better-SQLite3 with In-Memory Database

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring Better-SQLite3 to use an in-memory database, suitable for temporary data storage.

```typescript
const config: DrizzleBetterSQLiteConfig = {
  sqlite3: {
    filename: ':memory:'
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### DrizzlePostgresConfig Usage Example

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of how to instantiate the `DrizzlePostgresConfig` for connecting to a PostgreSQL database using PostgresJS. The `config.schema` property is typically required for Drizzle ORM.

```typescript
const config: DrizzlePostgresConfig = {
  postgres: {
    url: 'postgres://user:password@localhost:5432/mydb',
    config: {
      ssl: true,
      connection: { timeout: 10000 }
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### HTTP URL Connection

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-service.md

Example configuration for connecting to a remote database via an HTTP URL, including an authentication token.

```typescript
url: 'http://localhost:8080'
authToken: 'token'
```

--------------------------------

### Environment-Specific Configuration (Production)

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-decorator.md

Provides an example of registering the DrizzleTursoModule for production using environment variables for Turso connection details.

```typescript
import { DrizzleTursoModule } from '@drizzle-orm/nestjs-turso';

// For production:
DrizzleTursoModule.register({
  tag: 'DB',
  turso: {
    config: {
      url: process.env.TURSO_URL,
      authToken: process.env.TURSO_AUTH_TOKEN,
    },
  },
  config: { schema: { ...schema } },
})
```

--------------------------------

### Usage Example: InjectDrizzle with Multiple Environments

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Shows how to inject multiple PlanetScale Drizzle database instances using different custom tags ('DB_PROD', 'DB_DEV') for managing different environments within the same application.

```APIDOC
## Usage Example: Multiple Environments

### Service

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-planetscale';
import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
import * as schema from './db/schema';

@Injectable()
export class DataService {
  constructor(
    @InjectDrizzle('DB_PROD') private prodDb: PlanetScaleDatabase<typeof schema>,
    @InjectDrizzle('DB_DEV') private devDb: PlanetScaleDatabase<typeof schema>
  ) {}

  async getProdData() {
    return await this.prodDb.query.users.findMany();
  }

  async getDevData() {
    return await this.devDb.query.users.findMany();
  }
}
```

### Module Registration

```typescript
@Module({
  imports: [
    DrizzlePlanetScaleModule.register({
      tag: 'DB_PROD',
      planetscale: {
        config: {
          host: process.env.PLANETSCALE_PROD_HOST,
          username: process.env.PLANETSCALE_PROD_USERNAME,
          password: process.env.PLANETSCALE_PROD_PASSWORD,
        },
      },
      config: { schema: { ...schema } },
    }),
    DrizzlePlanetScaleModule.register({
      tag: 'DB_DEV',
      planetscale: {
        config: {
          host: process.env.PLANETSCALE_DEV_HOST,
          username: process.env.PLANETSCALE_DEV_USERNAME,
          password: process.env.PLANETSCALE_DEV_PASSWORD,
        },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```
```

--------------------------------

### PlanetScale Configuration Usage

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of how to configure DrizzlePlanetScaleConfig with PlanetScale client details and Drizzle ORM schema. Ensure environment variables for PlanetScale credentials are set.

```typescript
const config: DrizzlePlanetScaleConfig = {
  planetscale: {
    config: {
      host: process.env.PLANETSCALE_HOST,
      username: process.env.PLANETSCALE_USERNAME,
      password: process.env.PLANETSCALE_PASSWORD
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Usage Example: InjectDrizzle with Error Handling

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Demonstrates how to use InjectDrizzle in conjunction with error handling, including retries and exponential backoff, for robust database operations.

```APIDOC
## Usage Example: With Error Handling

### Service

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-planetscale';
import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';

@Injectable()
export class SafeDataService {
  constructor(
    @InjectDrizzle('DB') private db: PlanetScaleDatabase
  ) {}

  async getUserWithRetry(id: number, retries = 3) {
    for (let attempt = 0; attempt < retries; attempt++) {
      try {
        return await this.db.query.users.findFirst({
          where: (users) => sql`${users.id} = ${id}`,
        });
      } catch (error) {
        if (attempt === retries - 1) throw error;
        // Exponential backoff
        await new Promise(resolve => 
          setTimeout(resolve, Math.pow(2, attempt) * 1000)
        );
      }
    }
  }
}
```
```

--------------------------------

### Registering Drizzle for Multiple Environments

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Shows the module registration for multiple PlanetScale Drizzle database instances, each tagged for a specific environment ('DB_PROD', 'DB_DEV'). This setup allows for distinct configurations and connections.

```typescript
@Module({
  imports: [
    DrizzlePlanetScaleModule.register({
      tag: 'DB_PROD',
      planetscale: {
        config: {
          host: process.env.PLANETSCALE_PROD_HOST,
          username: process.env.PLANETSCALE_PROD_USERNAME,
          password: process.env.PLANETSCALE_PROD_PASSWORD,
        },
      },
      config: { schema: { ...schema } },
    }),
    DrizzlePlanetScaleModule.register({
      tag: 'DB_DEV',
      planetscale: {
        config: {
          host: process.env.PLANETSCALE_DEV_HOST,
          username: process.env.PLANETSCALE_DEV_USERNAME,
          password: process.env.PLANETSCALE_DEV_PASSWORD,
        },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Custom Database Configuration Service

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/configuration.md

Utilize the `useClass` pattern with a custom configuration service for complex Drizzle ORM setup scenarios. This allows for dynamic configuration based on environment variables or other services.

```typescript
@Injectable()
export class DatabaseConfigService {
  constructor(private configService: ConfigService) {}

  create() {
    return {
      postgres: {
        url: this.configService.get('DATABASE_URL'),
        config: {
          max: this.configService.get('DB_POOL_SIZE', 10),
          ssl: this.configService.get('DB_SSL', false)
        }
      },
      config: { schema: { ...schema } }
    };
  }
}

@Module({
  imports: [
    DrizzlePostgresModule.registerAsync({
      tag: 'DB',
      useClass: DatabaseConfigService
    })
  ]
})
export class AppModule {}
```

--------------------------------

### Module Configuration for Multiple Databases

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-decorator.md

Example NestJS module configuration demonstrating how to register multiple Better-SQLite3 Drizzle database instances with different tags ('DEV_DB' and 'TEST_DB'). The 'DEV_DB' uses a file, while 'TEST_DB' uses an in-memory database.

```typescript
import { Module } from '@nestjs/common';
import { DrizzleBetterSQLiteModule } from '@knaadh/nestjs-drizzle-better-sqlite3';
import * as schema from './db/schema';

@Module({
  imports: [
    // Production database
    DrizzleBetterSQLiteModule.register({
      tag: 'DEV_DB',
      sqlite3: { filename: 'app.db' },
      config: { schema: { ...schema } },
    }),
    // Test database (in-memory)
    DrizzleBetterSQLiteModule.register({
      tag: 'TEST_DB',
      sqlite3: { filename: ':memory:' },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### File-Based Database Initialization

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-service.md

Creates or opens a file-based SQLite database. The file will be created in the specified directory if it does not exist.

```typescript
const db = await getDrizzle({
  sqlite3: {
    filename: 'data/app.db',
  },
  config: { schema: { ...schema } },
});
// Creates/opens: data/app.db
```

--------------------------------

### DrizzleTursoService Class Definition

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-service.md

Defines the DrizzleTursoService class with a method to get the Drizzle database instance.

```typescript
@Injectable()
export class DrizzleTursoService {
  public async getDrizzle(options: DrizzleTursoConfig): Promise<LibSQLDatabase<any>>
}
```

--------------------------------

### Initialize PlanetScale Drizzle Instance

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-service.md

Use this to create a Drizzle database instance configured for PlanetScale. Ensure you provide the correct PlanetScale host, username, and password in the configuration.

```typescript
const db = await getDrizzle({
  planetscale: {
    config: {
      host: 'db.example.com',
      username: 'user',
      password: 'password',
    },
  },
  config: { schema: { ...schema } },
});
```

--------------------------------

### Registering Multiple Databases with Tags

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/QUICK-START.md

Configure multiple PostgreSQL database instances by providing unique `tag` identifiers for each. This allows for distinct connections, such as read replicas and primary instances.

```typescript
@Module({
  imports: [
    DrizzlePostgresModule.register({
      tag: 'DB_READ',
      postgres: { url: 'postgres://...read-replica...' },
      config: { schema: { ...schema } },
    }),
    DrizzlePostgresModule.register({
      tag: 'DB_WRITE',
      postgres: { url: 'postgres://...primary...' },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### PlanetScale Configuration with Environment Variables

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-module.md

Configure the PlanetScale database connection using environment variables for host, username, and password. The schema must also be provided.

```typescript
DrizzlePlanetScaleModule.register({
  tag: 'DB',
  planetscale: {
    config: {
      host: process.env.PLANETSCALE_HOST,
      username: process.env.PLANETSCALE_USERNAME,
      password: process.env.PLANETSCALE_PASSWORD,
    },
  },
  config: { schema: { ...schema } },
})
```

--------------------------------

### MySQL2 Connection Configuration Options

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/mysql2-module.md

Illustrates the two primary ways to configure the MySQL2 connection: using a URL string or a configuration object.

```typescript
// Option 1: URL string
config: 'mysql://user:password@localhost:3306/database'
```

```typescript
// Option 2: Object format
config: {
  host: 'localhost',
  port: 3306,
  database: 'mydb',
  user: 'root',
  password: 'password',
}
```

--------------------------------

### Initialize Better-SQLite3 with Drizzle

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-service.md

Use this to create a Drizzle instance with a Better-SQLite3 database. Ensure the schema is correctly defined.

```typescript
const db = await getDrizzle({
  sqlite3: {
    filename: 'app.db',
    options: { timeout: 5000 },
  },
  config: { schema: { ...schema } },
});
```

--------------------------------

### Full PostgresJS Configuration with Options

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/configuration.md

Configure advanced PostgresJS connection options like SSL, timeouts, and pool settings. Reads database URL from environment variables.

```typescript
DrizzlePostgresModule.register({
  tag: 'DB',
  postgres: {
    url: process.env.DATABASE_URL,
    config: {
      ssl: true,
      connection: {
        timeout: 10000,
        idle_in_transaction_session_timeout: 10000
      },
      max: 10,
      idle_timeout: 30,
      max_lifetime: 600
    }
  },
  config: {
    schema: { ...schema },
    logger: true
  }
})
```

--------------------------------

### In-Memory SQLite Testing Setup

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/QUICK-START.md

Configure DrizzleBetterSQLiteModule for in-memory testing within a NestJS application. This is useful for unit and integration tests.

```typescript
import { Test } from '@nestjs/testing';
import { DrizzleBetterSQLiteModule } from '@knaadh/nestjs-drizzle-better-sqlite3';

describe('UserService', () => {
  let service: UsersService;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      imports: [
        DrizzleBetterSQLiteModule.register({
          tag: 'DB',
          sqlite3: { filename: ':memory:' },
          config: { schema: { ...schema } },
        }),
      ],
      providers: [UsersService],
    }).compile();

    service = module.get(UsersService);
  });

  it('should get all users', async () => {
    const users = await service.getAllUsers();
    expect(Array.isArray(users)).toBe(true);
  });
});
```

--------------------------------

### Basic PostgresJS Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/configuration.md

Use this for simple PostgresJS connections with a direct URL. Ensure your schema is defined.

```typescript
DrizzlePostgresModule.register({
  tag: 'DB',
  postgres: {
    url: 'postgres://user:password@localhost:5432/mydb'
  },
  config: { schema: { ...schema } }
})
```

--------------------------------

### DrizzlePGConfig Usage with Client

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example configuration for `DrizzlePGConfig` using a single Node-Postgres client. This is suitable for simpler applications or specific connection needs.

```typescript
const config: DrizzlePGConfig = {
  pg: {
    connection: 'client',
    config: {
      host: 'localhost',
      port: 5432,
      database: 'mydb',
      user: 'postgres',
      password: 'password'
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Register Postgres JS Database Asynchronously with useClass

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-module.md

Use `registerAsync()` with `useClass` for configuring the Drizzle Postgres database instance via a dedicated service. The service must provide a `create()` method that returns the configuration object.

```typescript
import { Injectable } from '@nestjs/common';

@Injectable()
export class DatabaseConfigService {
  create() {
    return {
      postgres: {
        url: process.env.DATABASE_URL,
      },
      config: { schema: { ...schema } },
    };
  }
}

@Module({
  imports: [
    DrizzlePostgresModule.registerAsync({
      tag: 'DB_PRIMARY',
      useClass: DatabaseConfigService,
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Register DrizzleBetterSQLiteModule with File-Based Database

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-module.md

Use this example to synchronously register the DrizzleBetterSQLiteModule for a file-based SQLite database. Ensure your schema is imported correctly.

```typescript
import { Module } from '@nestjs/common';
import { DrizzleBetterSQLiteModule } from '@knaadh/nestjs-drizzle-better-sqlite3';
import * as schema from './db/schema';

@Module({
  imports: [
    DrizzleBetterSQLiteModule.register({
      tag: 'DB',
      sqlite3: {
        filename: 'app.db',
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Drizzle ORM Schema Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example of configuring the Drizzle ORM with a schema definition. This enables type-safe database interactions within your NestJS services.

```typescript
import * as schema from './db/schema';

const config = {
  schema: { ...schema }
};
```

--------------------------------

### Async Module Registration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/INDEX.md

Use `registerAsync` for dynamic configuration, allowing you to inject services like `ConfigService` to retrieve database connection details or other configuration parameters at runtime.

```typescript
Module.registerAsync({
  tag: 'DB',
  useFactory: (configService) => ({
    postgres: { url: configService.get('DATABASE_URL') },
    config: { schema: { ...schema } }
  }),
  inject: [ConfigService]
})
```

--------------------------------

### Register DrizzleBetterSQLiteModule with In-Memory Database

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-module.md

This example demonstrates synchronous registration of the DrizzleBetterSQLiteModule for an in-memory SQLite database, suitable for testing or temporary data storage.

```typescript
@Module({
  imports: [
    DrizzleBetterSQLiteModule.register({
      tag: 'DB_TEST',
      sqlite3: {
        filename: ':memory:',
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class TestModule {}
```

--------------------------------

### Configuration Service for Drizzle Module

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/packages/better-sqlite3/README.md

Define a configuration service class to provide Drizzle module options asynchronously. This is useful for more complex setup scenarios.

```typescript
export class DBConfigService {
  create = () => {
    return {
      sqlite3: {
        filename: 'demo.db',
      },
      config: { schema: { ...schema } },
    };
  };
}
```

--------------------------------

### Configuration Service for Async Registration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/packages/postgres-js/README.md

Define a service class to provide configuration options asynchronously for DrizzlePostgresModule registration.

```typescript
export class DBConfigService {
  create = () => {
    return {
      postgres: {
        url: 'postgres://postgres:@127.0.0.1:5432/drizzleDB',
      },
      config: { schema: { ...schema } },
    };
  };
}
```

--------------------------------

### DrizzlePGConfig Usage with Pool

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/types.md

Example configuration for `DrizzlePGConfig` using a Node-Postgres connection pool. This is recommended for applications with concurrent database access to manage connections efficiently.

```typescript
const config: DrizzlePGConfig = {
  pg: {
    connection: 'pool',
    config: {
      host: 'localhost',
      port: 5432,
      database: 'mydb',
      user: 'postgres',
      password: 'password',
      max: 10,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 2000
    }
  },
  config: { schema: { ...schema } }
};
```

--------------------------------

### Register DrizzleBetterSQLiteModule with Options

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/packages/better-sqlite3/README.md

Initialize the DrizzleBetterSQLiteModule by providing an options object directly. This method is suitable for straightforward configurations.

```typescript
import {
  Module
} from '@nestjs/common';
import {
  AppController
} from './app.controller';
import {
  AppService
} from './app.service';
import * as schema from '../db/schema';
import {
  DrizzleBetterSQLiteModule
} from '@knaadh/nestjs-drizzle-better-sqlite3';

@Module({
  imports: [
    // Method #1: Pass options object
    DrizzleBetterSQLiteModule.register({
      tag: 'DB_DEV',
      sqlite3: {
        filename: 'demo.db',
      },
      config: { schema: { ...schema } },
    }),

    // Method #2: useFactory() 
   DrizzleBetterSQLiteModule.registerAsync({
      tag: 'DB_PROD',
      useFactory() {
        return {
          sqlite3: {
            filename: 'demo.db',
          },
          config: { schema: { ...schema } },
        };
      },
    }),

    // Method #3: useClass()
    DrizzleBetterSQLiteModule.registerAsync({
      tag: 'DB_STAGING',
      useClass: DBConfigService,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

--------------------------------

### Initialize Drizzle with Client Connection

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/node-postgres-service.md

Use this when you need direct control over a single PostgreSQL connection. Ensure your connection configuration is valid.

```typescript
const db = await getDrizzle({
  pg: {
    connection: 'client',
    config: {
      host: 'localhost',
      port: 5432,
      database: 'mydb',
      user: 'postgres',
      password: 'password',
    },
  },
  config: { schema: { ...schema } },
});
```

--------------------------------

### Usage Example: InjectDrizzle with Default Tag

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Demonstrates how to use the InjectDrizzle decorator with its default tag to inject a PlanetScale Drizzle database instance into a NestJS service.

```APIDOC
## Usage Example: With Default Tag

### Service

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-planetscale';
import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';
import * as schema from './db/schema';

@Injectable()
export class UserService {
  constructor(
    @InjectDrizzle() private db: PlanetScaleDatabase<typeof schema>
  ) {}

  async getUsers() {
    return await this.db.query.users.findMany();
  }
}
```

### Module Registration

```typescript
@Module({
  imports: [
    DrizzlePlanetScaleModule.register({
      planetscale: {
        config: {
          host: process.env.PLANETSCALE_HOST,
          username: process.env.PLANETSCALE_USERNAME,
          password: process.env.PLANETSCALE_PASSWORD,
        },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```
```

--------------------------------

### Asynchronous Registration with useClass

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/node-postgres-module.md

Use `registerAsync()` with `useClass` to configure the Drizzle database instance using a separate provider class. This class must have a `create()` method that returns the Drizzle configuration object.

```typescript
import { Injectable } from '@nestjs/common';

@Injectable()
export class DatabaseConfigService {
  create() {
    return {
      pg: {
        connection: 'pool',
        config: {
          host: process.env.DB_HOST,
          port: parseInt(process.env.DB_PORT),
          database: process.env.DB_NAME,
          user: process.env.DB_USER,
          password: process.env.DB_PASSWORD,
          max: 10,
        },
      },
      config: { schema: { ...schema } },
    };
  }
}

@Module({
  imports: [
    DrizzlePGModule.registerAsync({
      tag: 'DB',
      useClass: DatabaseConfigService,
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Define Database Schema

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/QUICK-START.md

Create your database schema using Drizzle ORM's pgTable, serial, and varchar types. This example defines 'users' and 'posts' tables.

```typescript
// db/schema.ts
import { pgTable, serial, varchar } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  email: varchar('email', { length: 256 }).unique(),
  name: varchar('name', { length: 256 }),
});

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: varchar('title', { length: 512 }),
  content: varchar('content'),
  userId: serial('user_id').references(() => users.id),
});
```

--------------------------------

### Injecting Postgres.js Database Instance

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-module.md

Demonstrates how to inject the initialized Drizzle database instance into a service using its configured tag.

```typescript
import {
  Injectable,
  Inject
} from '@nestjs/common';
import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';

@Injectable()
export class UserService {
  constructor(@Inject('DB_PRIMARY') private db: PostgresJsDatabase) {
    // db is now the initialized Drizzle database instance
  }
}
```

--------------------------------

### Inject Drizzle Instance with Tag

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/README.md

Inject Drizzle instances into your services using the 'tag' specified during module registration. This example demonstrates injecting a BetterSQLite3 database instance.

```typescript
import { Inject, Injectable } from '@nestjs/common';
import * as schema from '../db/schema';
import { LibSQLDatabase } from 'drizzle-orm/libsql';
@Injectable()
export class AppService {
  constructor(
    @Inject('DB_DEV') private drizzleDev: LibSQLDatabase<typeof schema>
  ) {}
  async getData() {
    const books = await this.drizzleDev.query.books.findMany();
    const authors = await this.drizzleDev.query.authors.findMany();
    return {
      books: books,
      authors: authors,
    };
  }
}
```

--------------------------------

### Separating Test and Production Databases

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-decorator.md

Advises on the best practice of using separate database configurations for testing and production environments. This typically involves using an in-memory database for tests to ensure isolation and speed.

```typescript
import { DrizzleBetterSQLiteModule } from 'nestjs-drizzle';
import * as schema from './schema';

// app.module.ts - Production
DrizzleBetterSQLiteModule.register({
  tag: 'DB',
  sqlite3: { filename: 'app.db' },
  config: { schema: { ...schema } },
})

// test.module.ts - Testing
DrizzleBetterSQLiteModule.register({
  tag: 'DB',
  sqlite3: { filename: ':memory:' },  // In-memory for tests
  config: { schema: { ...schema } },
})
```

--------------------------------

### Injecting Default Drizzle Instance

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-decorator.md

Example of injecting the default Better-SQLite3 Drizzle instance into a NestJS service. Ensure the DrizzleBetterSQLiteModule is registered without a specific tag for this to work.

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-better-sqlite3';
import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
import * as schema from './db/schema';

@Injectable()
export class UserService {
  constructor(
    @InjectDrizzle() private db: BetterSQLite3Database<typeof schema>
  ) {}

  getUsers() {
    return this.db.query.users.findMany();
  }
}
```

--------------------------------

### Better-SQLite3 Options Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-service.md

Configure Better-SQLite3 options such as read-only mode, timeouts, and verbose logging during Drizzle initialization.

```typescript
const db = await getDrizzle({
  sqlite3: {
    filename: 'app.db',
    options: {
      readonly: false,
      timeout: 10000,
      verbose: (sql) => console.log('SQL:', sql),
    },
  },
  config: { schema: { ...schema } },
});
```

--------------------------------

### Configure MySQL2 URL String

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/configuration.md

Register the DrizzleMySqlModule using a database URL string for pool configuration. This simplifies connection setup by providing all parameters in a single string.

```typescript
DrizzleMySqlModule.register({
  tag: 'DB',
  mysql: {
    connection: 'pool',
    config: `mysql://${process.env.DB_USER}:${process.env.DB_PASSWORD}@${process.env.DB_HOST}:3306/${process.env.DB_NAME}`
  },
  config: { schema: { ...schema } }
})
```

--------------------------------

### Environment-Specific Configuration

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Illustrates how to configure PlanetScale databases for different environments (production and development) using `DrizzlePlanetScaleModule.register`. It shows how to set environment-specific connection details and schema.

```typescript
import { DrizzlePlanetScaleModule } from '@drizzle-orm/nestjs-planetscale';

// Assuming 'schema' is defined elsewhere
// import schema from './schema';

// Production environment
DrizzlePlanetScaleModule.register({
  tag: 'DB_PROD',
  planetscale: {
    config: {
      host: process.env.PLANETSCALE_PROD_HOST,
      username: process.env.PLANETSCALE_PROD_USERNAME,
      password: process.env.PLANETSCALE_PROD_PASSWORD,
    },
  },
  config: { schema: { ...schema } },
})

// Development environment
DrizzlePlanetScaleModule.register({
  tag: 'DB_DEV',
  planetscale: {
    config: {
      host: process.env.PLANETSCALE_DEV_HOST,
      username: process.env.PLANETSCALE_DEV_USERNAME,
      password: process.env.PLANETSCALE_DEV_PASSWORD,
    },
  },
  config: { schema: { ...schema } },
})
```

--------------------------------

### Registering for Development with Local SQLite

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-module.md

Configuration for registering the module in a development environment using a local SQLite file.

```typescript
DrizzleTursoModule.register({
  turso: {
    config: {
      url: 'file:./dev.db',
    },
  },
  config: { schema: { ...schema } },
})
```

--------------------------------

### registerAsync()

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/postgres-js-module.md

Asynchronously registers a Drizzle database instance with NestJS. This method is ideal for configurations that depend on external factors like environment variables or a ConfigService, allowing for dynamic setup.

```APIDOC
## registerAsync()

### Description
Asynchronously register a Drizzle database instance. Useful for dynamic configuration from ConfigService, environment variables, or custom providers.

### Signature
```typescript
static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule
```

### Parameters
#### Path Parameters
- **options** (object) - Required - Async configuration object
  - **options.tag** (string) - Optional - Injection token name for the database instance (default: `'default'`)
  - **options.useFactory** (Function) - Conditional - Factory function returning `DrizzlePostgresConfig`. Mutually exclusive with `useClass`
  - **options.inject** (any[]) - Optional - Array of injectable providers to inject into `useFactory`
  - **options.useClass** (Type<any>) - Conditional - Class with `create()` method returning `DrizzlePostgresConfig`. Mutually exclusive with `useFactory`
  - **options.imports** (Type<any>[]) - Optional - Modules to import before the factory is resolved

### Return Type
```typescript
DynamicModule
```
A NestJS DynamicModule with async providers that resolves configuration and creates the database instance.

### Factory Function Return Type
```typescript
Promise<DrizzlePostgresConfig> | DrizzlePostgresConfig
```

### Example using useFactory
```typescript
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { DrizzlePostgresModule } from '@knaadh/nestjs-drizzle-postgres';

@Module({
  imports: [
    ConfigModule.forRoot(),
    DrizzlePostgresModule.registerAsync({
      tag: 'DB_PRIMARY',
      imports: [ConfigModule],
      useFactory: (configService: ConfigService) => ({
        postgres: {
          url: configService.get('DATABASE_URL'),
          config: {
            ssl: configService.get('NODE_ENV') === 'production',
          },
        },
        config: { schema: { ...schema } },
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}
```

### Example using useClass
```typescript
import { Injectable } from '@nestjs/common';

@Injectable()
export class DatabaseConfigService {
  create() {
    return {
      postgres: {
        url: process.env.DATABASE_URL,
      },
      config: { schema: { ...schema } },
    };
  }
}

@Module({
  imports: [
    DrizzlePostgresModule.registerAsync({
      tag: 'DB_PRIMARY',
      useClass: DatabaseConfigService,
    }),
  ],
})
export class AppModule {}
```
```

--------------------------------

### Register Better-SQLite3 Module for Production

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/better-sqlite3-service.md

Set up the DrizzleBetterSQLiteModule for a production environment, specifying a persistent database file path and optional SQLite options like timeout and read-only mode.

```typescript
import { Module } from '@nestjs/common';
import { DrizzleBetterSQLiteModule } from 'nestjs-drizzle-better-sqlite3';
import * as schema from './schema';

@Module({
  imports: [
    DrizzleBetterSQLiteModule.register({
      tag: 'DB',
      sqlite3: {
        filename: '/var/lib/myapp/data.db',
        options: { readonly: false, timeout: 15000 },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```

--------------------------------

### Handling Network Errors with Timeout

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/planetscale-decorator.md

Provides an example of a resilient data service that handles network errors by implementing a query timeout using `Promise.race`. This prevents indefinite waiting for database queries.

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@drizzle-orm/nestjs-planetscale';
import { PlanetScaleDatabase } from '@planetscale/database';

@Injectable()
export class ResilientDataService {
  constructor(@InjectDrizzle('DB') private db: PlanetScaleDatabase) {}

  async getDataWithTimeout(timeoutMs = 10000) {
    return Promise.race([
      this.db.query.users.findMany(),
      new Promise((_, reject) =>
        setTimeout(() => reject(new Error('Query timeout')), timeoutMs)
      ),
    ]);
  }
}
```

--------------------------------

### Configuring Multiple Turso Databases

Source: https://github.com/knaadh/nestjs-drizzle/blob/main/_autodocs/api-reference/turso-decorator.md

Use this pattern to configure and inject multiple Turso database instances with distinct tags. This allows for managing primary and replica databases or other specialized connections.

```typescript
import { Injectable } from '@nestjs/common';
import { InjectDrizzle } from '@knaadh/nestjs-drizzle-turso';
import { LibSQLDatabase } from 'drizzle-orm/libsql';
import * as schema from './db/schema';

@Injectable()
export class MultiDatabaseService {
  constructor(
    @InjectDrizzle('PRIMARY_DB') private primaryDb: LibSQLDatabase<typeof schema>,
    @InjectDrizzle('REPLICA_DB') private replicaDb: LibSQLDatabase<typeof schema>
  ) {}

  async readFromReplica() {
    return await this.replicaDb.query.users.findMany();
  }

  async writeToMaster(data: any) {
    return await this.primaryDb.insert(usersTable).values(data);
  }
}
```

```typescript
@Module({
  imports: [
    DrizzleTursoModule.register({
      tag: 'PRIMARY_DB',
      turso: {
        config: {
          url: process.env.TURSO_PRIMARY_URL,
          authToken: process.env.TURSO_PRIMARY_TOKEN,
        },
      },
      config: { schema: { ...schema } },
    }),
    DrizzleTursoModule.register({
      tag: 'REPLICA_DB',
      turso: {
        config: {
          url: process.env.TURSO_REPLICA_URL,
          authToken: process.env.TURSO_REPLICA_TOKEN,
        },
      },
      config: { schema: { ...schema } },
    }),
  ],
})
export class AppModule {}
```