### Node-Postgres Setup Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of setting up Node-Postgres for use in Node.js servers. This snippet demonstrates basic connection and initialization.

```typescript
import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

const client = new Client({
  connectionString: "postgres://postgres:password@localhost:5432/postgres",
});
await client.connect();

export const db = drizzle(client);
```

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

### Complete PGLite Database Setup Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

A comprehensive example demonstrating how to initialize a PGLite database with IndexedDB persistence and apply migrations. Ensure migrations are imported correctly.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  // Create PGLite with IndexedDB backing
  const pgLite = new PGlite({
    fs: new IdbFs('my-app-database')
  })

  // Create Drizzle client
  const db = drizzle({ client: pgLite })

  // Apply bundled migrations
  await migrate(db, migrations)

  return db
}

// Use in application
const db = await initializeDatabase()
```

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

### PGLite Setup Example for Browser

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of setting up PGLite for use in the browser with IndexedDB. This snippet demonstrates initializing the database client for browser environments.

```typescript
import { drizzle } from "drizzle-orm/pg-lite";
import { PGLite } from "pg.js";

const pg = new PGLite("postgres://username:password@host:port/database");
export const db = drizzle(pg);
```

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

### Postgres.js Setup Example for Vercel Edge

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of setting up Postgres.js for use in edge runtimes like Vercel. This snippet shows how to initialize the database client for edge environments.

```typescript
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";

const dbClient = postgres({
  host: "...",
  database: "...",
  username: "...",
  password: "...",
  // ... other options
});

export const db = drizzle(dbClient);
```

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

### Complete Database Setup and Initialization

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Example of initializing a PostgreSQL database with Drizzle ORM and running migrations. Includes usage within an Express application.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/node-postgres'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const sql = postgres(process.env.DATABASE_URL)
  const db = drizzle({ client: sql })

  await migrate(db, migrations)

  return db
}

// Usage in Express app
import express from 'express'

const app = express()
const db = await initializeDatabase()

app.get('/users', async (req, res) => {
  const users = await db.query.users.findMany()
  res.json(users)
})
```

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

### Monorepo Setup Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Configuration example for using Drizzle ORM within a monorepo structure. This snippet addresses common challenges in shared database setups.

```typescript
// packages/db/src/index.ts
import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

const client = new Client({
  connectionString: process.env.DATABASE_URL,
});
await client.connect();

export const db = drizzle(client);

// packages/api/src/index.ts
import { db } from "@your-org/db"; // Assuming db package is exported

// Use db instance here
console.log("API using shared DB instance");
```

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

### Automatic Initialization on App Startup

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Demonstrates automatically initializing the database connection when the application starts. This pattern centralizes database setup.

```typescript
// src/db.ts
import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

async function initializeDatabase() {
  const client = new Client({
    connectionString: process.env.DATABASE_URL,
  });
  await client.connect();
  return drizzle(client);
}

export const db = await initializeDatabase();

// src/index.ts
import { db } from "./db";

// Use db instance throughout your application
console.log("Database initialized");
```

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

### Complete Database Setup with Postgres.js and Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

This snippet shows how to initialize a database connection using Postgres.js, integrate with Drizzle ORM, and apply bundled migrations. It also includes an example of how to use the initialized database in a Vercel Edge function.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const sql = postgres(process.env.DATABASE_URL)
  const db = drizzle({ client: sql })

  await migrate(db, migrations)

  return db
}

// Usage in edge function (Vercel Edge)
import { initializeDatabase } from './db'

export default async function handler(request) {
  const db = await initializeDatabase()
  const users = await db.query.users.findMany()

  return new Response(JSON.stringify(users), {
    headers: { 'Content-Type': 'application/json' }
  })
}
```

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

### UnpluginInstance Example Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/types.md

Example showing how to obtain specific framework adapters from a UnpluginInstance.

```typescript
const plugin: UnpluginInstance = newPlugin()
const vitePlugin = plugin.vite
const webpackPlugin = plugin.webpack
// ... etc
```

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

### Logging Output Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

This is an example of the logging output produced by the default logger during migration execution.

```text
[pglite] ℹ 1. Deploying migration:
[pglite]      tag        => 0000_colorful_patch
[pglite]      hash       => abc123def456...
[pglite]      created_at => 2024-01-15T10:30:00.000Z
[pglite] ✓ all 1 pending migrations applied!
```

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

### PostgresJsDatabase Example Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/types.md

Example of how to instantiate a PostgresJsDatabase with a postgres.js client.

```typescript
import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'

const sql = postgres('postgresql://localhost:5432/mydb')
const db: PostgresJsDatabase = drizzle({ client: sql })
```

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

### Example Migration SQL File

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Shows an example of a migration SQL file located in the `drizzle/` directory. The plugin reads these files to compute hashes and split statements.

```sql
CREATE TABLE users (
  id bigserial PRIMARY KEY NOT NULL,
  name varchar(255) NOT NULL
);

--> statement-breakpoint

CREATE INDEX idx_users_name ON users(name);
```

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

### Run Development Server

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/README.md

Use this command to start the development server for the project.

```bash
pnpm dev

```

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

### Initialize Database (Node-Postgres Example)

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of initializing the database connection using Node-Postgres. This sets up the Drizzle instance for use in a Node.js application.

```typescript
import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

const client = new Client({
  connectionString: process.env.DATABASE_URL,
});

async function initDb() {
  await client.connect();
  return drizzle(client);
}

export const db = initDb(); // Exporting a promise that resolves to the db instance
```

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

### Install Dependencies

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Command to install the necessary Drizzle ORM packages and the database driver. This is the first step in setting up Drizzle.

```bash
npm install drizzle-orm pg
# or
yarn add drizzle-orm pg
# or
pnpm add drizzle-orm pg
```

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

### Complete Drizzle ORM Browser Configuration

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

A comprehensive example demonstrating the setup for `drizzle.config.ts`, `vite.config.ts`, `tsconfig.json`, and runtime database configuration.

```typescript
import { defineConfig } from 'drizzle-kit'
import path from 'path'

export default defineConfig({
  dialect: 'postgresql',
  schema: path.join(__dirname, 'src/db/schema.ts'),
  out: path.join(__dirname, 'drizzle')
})
```

```typescript
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/vite'

export default defineConfig({
  plugins: [
    react(),
    DrizzleORMMigrations({
      root: process.cwd()
    })
  ],
  build: {
    minify: 'esbuild'
  }
})
```

```json
{
  "compilerOptions": {
    "target": "ES2020",
    "useDefineForClassFields": true,
    "lib": ["ES2020", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "skipLibCheck": true,
    "types": ["@proj-airi/unplugin-drizzle-orm-migrations/types"]
  },
  "include": ["src"],
  "references": [{ "path": "./tsconfig.node.json" }]
}
```

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'
import { useLogg } from '@guiiai/logg'

const pgLite = new PGlite({ fs: new IdbFs('app-db') })
const db = drizzle({ client: pgLite })

const logger = useLogg('database')
await migrate(db, migrations, { logger })

export default db
```

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

### Postgres.js Migrator Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Example of how to import the migrate function and MigrateOptions type for the postgres.js migrator.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
import type { MigrateOptions } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
```

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

### Use in Application

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of how to use the Drizzle ORM instance within an application after setup. Shows a basic query operation.

```typescript
import { db } from "./db"; // Assuming db is exported from db.ts

async function main() {
  // Example: Fetching users
  const users = await db.query.users.findMany();
  console.log("Users:", users);

  // Example: Inserting a new user
  await db.insert(usersTable).values({
    name: "John Doe",
    email: "john.doe@example.com",
  });
  console.log("User inserted.");
}

main().catch(console.error);
```

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

### One-time Setup in Application Initialization

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

This snippet shows how to set up the database and apply migrations once during application initialization. Ensure you have the necessary imports for drizzle and the migrator.

```typescript
// src/db.ts
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const db = drizzle({ client: pgLite })
  await migrate(db, migrations)
  return db
}
```

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

### Example Migration Object

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/types.md

An example of a concrete Migration object, illustrating the expected values for each field.

```typescript
{
  idx: 0,
  when: 1704067800000,
  tag: "0000_initial_schema",
  hash: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
  sql: [
    "CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(255))",
    "CREATE TABLE posts (id SERIAL PRIMARY KEY, user_id INTEGER, title VARCHAR(255))"
  ]
}
```

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

### Initialize Database with Custom Logging

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

This example shows how to integrate custom logging into the database initialization process using the `@guiiai/logg` library. It applies migrations with a configured logger.

```typescript
import { useLogg, Format } from '@guiiai/logg'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'

const logger = useLogg('database')
  .withFormat(Format.Pretty)

export async function initializeDatabase() {
  const pgLite = new PGlite({ fs: new IdbFs('app-db') })
  const db = drizzle({ client: pgLite })

  await migrate(db, migrations, { logger })

  logger.log('Database ready')
  return db
}
```

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

### Environment-Specific Logging for Database Initialization

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

This example configures database logging based on the environment. It uses pretty formatting for development and JSON formatting for production.

```typescript
import { useLogg, Format } from '@guiiai/logg'

const getLogger = () => {
  const isDev = process.env.NODE_ENV !== 'production'
  
  return useLogg('database').withFormat(
    isDev ? Format.Pretty : Format.Json
  )
}

export async function initializeDatabase() {
  const logger = getLogger()
  await migrate(db, migrations, { logger })
```

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

### Configure Build Tool (Vite Example)

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of configuring Vite to work with Drizzle ORM, particularly for handling virtual modules or specific build optimizations.

```typescript
// vite.config.ts
import { defineConfig } from 'vite';

export default defineConfig({
  // ... other Vite configurations
  resolve: {
    alias: {
      // Example: Resolving a specific Drizzle module if needed
      // 'drizzle-orm/pg-js': require.resolve('drizzle-orm/pg-js/index.js'),
    },
  },
});
```

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

### Node-Postgres Migrator Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Example of how to import the migrate function and MigrateOptions type for the Node-Postgres migrator.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'
import type { MigrateOptions } from '@proj-airi/drizzle-orm-browser-migrator/pg'
```

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

### Install @proj-airi/drizzle-orm-browser-migrator

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/packages/drizzle-orm-browser-migrator/README.md

Install the package using your preferred package manager. This is a development dependency.

```shell
ni @proj-airi/drizzle-orm-browser-migrator -D
```

```shell
pnpm i @proj-airi/drizzle-orm-browser-migrator -D
```

```shell
yarn i @proj-airi/drizzle-orm-browser-migrator -D
```

```shell
npm i @proj-airi/drizzle-orm-browser-migrator -D
```

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

### Example Usage of migrate() with Postgres.js

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

Demonstrates how to use the `migrate` function with a Postgres.js database instance. Ensure you have the necessary imports and a configured postgres client.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
import migrations from 'virtual:drizzle-migrations.sql'

const sql = postgres('postgresql://user:password@localhost:5432/mydb')
const db = drizzle({ client: sql })

await migrate(db, migrations)
```

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

### Logg Example Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/types.md

Demonstrates typical usage of the Logg type for logging migration progress and debugging information.

```typescript
import { useLogg, Format } from '@guiiai/logg'

const logger = useLogg('my-app').withFormat(Format.Pretty)
logger.log('Starting migrations')
logger.debug('Migration details')
logger.withField('table_count', 5).debug('Schema update')
```

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

### Install Drizzle ORM Browser Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/README.md

Install the necessary packages for Drizzle ORM browser migrations using your preferred package manager.

```shell
# from @antfu/ni, can be installed via `npm i -g @antfu/ni`
ni -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
pnpm i -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
yarn i -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
npm i -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
```

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

### PGLite Migrator Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Example of how to import the migrate function and MigrateOptions type for the PGLite migrator.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import type { MigrateOptions } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
```

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

### Install Drizzle ORM Browser Migrations Dependencies

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/README.md

Installs the necessary Drizzle ORM migration packages using pnpm.

```bash
pnpm install -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
```

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

### Virtual Module Generation Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

This is an example of the JavaScript module generated by the plugin. It contains migration metadata including index, timestamp, tag, hash, and SQL statements. The format is minified in production and formatted in development.

```typescript
export default [
  {
    "idx": 0,
    "when": 1704067800000,
    "tag": "0000_colorful_patch",
    "hash": "abc123...",
    "sql": ["CREATE TABLE users..."]
  }
]
```

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

### Example Usage of migrate() with Node-Postgres

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

Demonstrates how to use the `migrate` function with a node-postgres database instance. Ensure you have the necessary imports and a configured postgres client.

```typescript
import { drizzle } from 'drizzle-orm/node-postgres'
import postgres from 'postgres'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'
import migrations from 'virtual:drizzle-migrations.sql'

const client = postgres('postgresql://user:password@localhost:5432/mydb')
const db = drizzle({ client })

await migrate(db, migrations)
```

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

### Completion Logging Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Logs the successful completion of the migration process. This provides a clear indication that all migrations have been applied.

```typescript
import { migrate } from "drizzle-orm/migrator";
import { db } from "./db";

async function runMigrations() {
  try {
    await migrate(db, {
      migrationsFolder: "./drizzle",
    });
    console.log("All migrations applied successfully.");
  } catch (error) {
    console.error("An error occurred during migrations:", error);
  }
}

runMigrations();
```

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

### Rollup Plugin with Options

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Configure the Rollup plugin with options, such as specifying the root directory. This example shows how to pass configuration to the plugin.

```javascript
export default {
  input: 'src/index.ts',
  plugins: [
    DrizzleORMMigrations({
      root: process.cwd()
    })
  ],
  output: { file: 'dist/bundle.js', format: 'esm' }
}
```

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

### Importing Migrate Function by Driver

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

These examples show how to import the `migrate` function from the `@proj-airi/drizzle-orm-browser-migrator` package, specifying the database driver.

```typescript
// PGLite
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'

// Node-Postgres
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'

// Postgres.js
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
```

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

### Install Unplugin Drizzle ORM Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/packages/unplugin-drizzle-orm-migrations/README.md

Install the package using your preferred package manager. This command adds the package as a development dependency.

```shell
ni @proj-airi/unplugin-drizzle-orm-migrations -D
```

```shell
pnpm i @proj-airi/unplugin-drizzle-orm-migrations -D
```

```shell
yarn i @proj-airi/unplugin-drizzle-orm-migrations -D
```

```shell
npm i @proj-airi/unplugin-drizzle-orm-migrations -D
```

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

### Conditional Database Initialization (Dev vs Prod)

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of conditionally initializing the database based on the environment (development vs. production). This allows for different configurations or disabling the database in certain environments.

```typescript
// src/db.ts
import { drizzle } from "drizzle-orm/node-postgres";
import { Client } from "pg";

let dbInstance: ReturnType<typeof drizzle> | null = null;

export async function getDb() {
  if (process.env.NODE_ENV === "production" && dbInstance) {
    return dbInstance;
  }

  const client = new Client({
    connectionString: process.env.DATABASE_URL,
  });
  await client.connect();
  dbInstance = drizzle(client);
  return dbInstance;
}

// src/index.ts
import { getDb } from "./db";

async function startApp() {
  const db = await getDb();
  console.log("Database connection obtained");
  // Use db...
}

startApp();
```

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

### Migration Progress Logging Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Logging the progress of migration operations. This helps track which migrations are being processed and their status.

```typescript
import { migrate } from "drizzle-orm/migrator";
import { db } from "./db";

async function runMigrations() {
  console.log("Starting database migrations...");
  await migrate(db, {
    migrationsFolder: "./drizzle",
  });
  console.log("Database migrations finished.");
}

runMigrations().catch(console.error);
```

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

### Drizzle Kit Configuration Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Shows the expected structure for `drizzle.config.ts`. The plugin specifically uses the `out` property to locate migration files.

```typescript
import { defineConfig } from 'drizzle-kit'

export default defineConfig({
  dialect: 'postgresql',
  schema: './src/db/schema.ts',
  out: './drizzle'  // ← Plugin uses this path
})
```

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

### Vite Plugin Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Import the Vite-specific plugin for use in your Vite configuration.

```typescript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/vite'
import { defineConfig } from 'vite'

export default defineConfig({
  plugins: [DrizzleORMMigrations()]
})
```

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

### Esbuild Plugin Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Import the esbuild-specific plugin for use in your esbuild build process.

```typescript
import { build } from 'esbuild'
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/esbuild'

await build({
  entryPoints: ['src/index.ts'],
  plugins: [DrizzleORMMigrations()]
})
```

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

### Importing Drizzle ORM Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Demonstrates standard and alternative ways to import Drizzle ORM migration SQL files. Includes an example with type checking to verify the imported migrations.

```typescript
// Standard import
import migrations from 'virtual:drizzle-migrations.sql'
```

```typescript
// Alternative
import migrations from 'drizzle-migrations.sql'
```

```typescript
// With type checking
import migrations from 'virtual:drizzle-migrations.sql'
console.log(migrations.length)  // ✓ Valid
```

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

### Example Usage of splitSQL

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Demonstrates how to use the `splitSQL` function with a sample SQL string. The function processes the input SQL to extract individual statements, handling comments and breakpoints.

```typescript
const sql = "
  CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255)
  );

  -- Create index
  CREATE INDEX idx_users_name ON users(name);
";

const statements = splitSQL(sql);
// Result: [
//   "CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(255));",
//   "CREATE INDEX idx_users_name ON users(name);"
// ]
```

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

### Conditional Logger Configuration for Environment

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

This example shows how to configure the logger based on the environment (development vs. production). It uses different formats for each environment.

```typescript
const isDev = process.env.NODE_ENV !== 'production'

const loggerOptions: MigrateOptions = isDev
  ? {
      logger: useLogg('migrations')
        .withFormat(Format.Pretty)
    }
  : {
      logger: useLogg('migrations')
        .withFormat(Format.Json)
    }

await migrate(db, migrations, loggerOptions)
```

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

### Rollup Plugin Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Import the Rollup-specific plugin for use in your Rollup configuration.

```typescript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/rollup'

export default {
  input: 'src/index.ts',
  plugins: [DrizzleORMMigrations()],
  output: { file: 'dist/bundle.js', format: 'esm' }
}
```

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

### PGLite Migrator Basic Example Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

Demonstrates basic usage of the PGLite migrator by applying bundled migrations to a PGLite database instance. Ensure necessary imports are included.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'

const pgLite = new PGlite({ 
  fs: new IdbFs('my-app-db') 
})
const db = drizzle({ client: pgLite })

await migrate(db, migrations)

console.log('Migrations applied successfully')
```

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

### Webpack Plugin Import Example (ESM)

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Import the Webpack plugin constructor using ES Modules for your Webpack configuration.

```typescript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/webpack'

export default {
  plugins: [
    new DrizzleORMMigrations()
  ]
}
```

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

### Postgres.js Simplified API Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Demonstrates the more direct API offered by the postgres.js client for executing queries. The result is directly an array of rows.

```typescript
import postgres from 'postgres'

const sql = postgres('postgresql://...')

// More direct API
const users = await sql`SELECT * FROM users`
// Directly returns array of rows, not QueryResult
```

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

### Runtime Migration with Custom Logger

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

This example demonstrates how to pass a custom logger instance to the migrate function. The custom logger can be configured with specific formats and fields.

```typescript
import { useLogg, Format } from '@guiiai/logg'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'

const logger = useLogg('my-app')
  .withFormat(Format.Pretty)
  .withField('context', 'database-init')

await migrate(db, migrations, { logger })
```

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

### Migration Validation Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Demonstrates how to validate migration hashes before applying them. This is a crucial step for ensuring data integrity and preventing unexpected schema changes.

```typescript
import { migrate } from "drizzle-orm/migrator";
import { db } from "./db";
import { readFileSync } from "fs";
import { createHash } from "crypto";

async function validateMigration(migrationPath: string) {
  const migrationContent = readFileSync(migrationPath, "utf-8");
  const expectedHash = createHash("sha256")
    .update(migrationContent)
    .digest("hex");

  // In a real scenario, you'd fetch the stored hash from your database
  // and compare it with expectedHash.
  console.log(`Migration ${migrationPath} hash: ${expectedHash}`);
  // if (storedHash !== expectedHash) {
  //   throw new Error("Migration hash mismatch!");
  // }
}

async function runMigrations() {
  // Assuming migrations are in ./drizzle folder
  const migrationFiles = await fs.readdir("./drizzle");
  for (const file of migrationFiles) {
    if (file.endsWith(".sql")) {
      await validateMigration(`./drizzle/${file}`);
    }
  }

  await migrate(db, {
    migrationsFolder: "./drizzle",
  });
  console.log("Migrations applied successfully");
}

runMigrations().catch(console.error);
```

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

### Configure Vite Build Tool for Drizzle ORM Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/README.md

Example Vite configuration to integrate the Drizzle ORM migrations unplugin.

```typescript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/vite'

export default defineConfig({
  plugins: [DrizzleORMMigrations()]
})
```

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

### Testing with Postgres.js

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Integrate Drizzle ORM with Postgres.js for testing. This snippet shows the setup, migration, and connection closing process.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'

describe('Database operations', () => {
  let db, sql

  beforeEach(async () => {
    sql = postgres('postgresql://localhost:5432/test')
    db = drizzle({ client: sql })
    await migrate(db, migrations)
  })

  afterEach(async () => {
    await sql.end()
  })

  it('should create users', async () => {
    // Test queries
  })
})
```

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

### Rspack Plugin with Options

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Example of integrating the Rspack Drizzle ORM migrations plugin with options, such as specifying the root directory using __dirname.

```javascript
const DrizzleORMMigrations = require('@proj-airi/unplugin-drizzle-orm-migrations/rspack')

module.exports = {
  plugins: [
    new DrizzleORMMigrations({ root: __dirname })
  ]
}
```

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

### PGLite Migrator Advanced Example with Logger

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

Shows advanced usage of the PGLite migrator, including passing a custom logger instance for enhanced logging during migration.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import { useLogg } from '@guiiai/logg'

const logger = useLogg('my-app')
await migrate(db, migrations, { logger })
```

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

### Error Handling for Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-migrator.md

This example demonstrates how to handle potential errors during the migration process. Wrap your migrate call in a try-catch block to log and re-throw any exceptions.

```typescript
try {
  await migrate(db, migrations)
} catch (error) {
  console.error('Failed to apply migrations:', error)
  throw error
}
```

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

### Webpack Plugin with Options

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Instantiate the Webpack Drizzle ORM migrations plugin with options, like setting the root directory. This example demonstrates how to pass configuration to the plugin.

```javascript
const DrizzleORMMigrations = require('@proj-airi/unplugin-drizzle-orm-migrations/webpack')

module.exports = {
  plugins: [
    DrizzleORMMigrations({ root: process.cwd() })
  ]
}
```

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

### Runtime Migration without Custom Logger

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

This example shows how to call the migrate function without providing a custom logger. It will use the default logger provided by the library.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'

await migrate(db, migrations)
```

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

### Monorepo Root Configuration

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Example of a root `drizzle.config.ts` file for a monorepo using pnpm workspaces. Specifies the output directory, schema location, and database dialect.

```typescript
// ./drizzle.config.ts
export default {
  out: './drizzle',
  schema: './packages/backend/src/db/schema.ts',
  dialect: 'postgresql'
}
```

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

### PGLite Migration Flow Diagram

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Visual representation of the migration process when using PGLite in a browser environment, starting from browser startup to query readiness.

```text
Browser startup
  ↓
Initialize PGLite with IndexedDB
  ↓
Connect Drizzle ORM to PGLite
  ↓
Import bundled migrations
  ↓
Call migrate(db, migrations)
  ↓
Check __drizzle_migrations table
  ↓
Filter pending migrations
  ↓
Execute in transaction
  ↓
Store migration history
  ↓
Ready for queries
```

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

### Cloudflare Worker Database Initialization with Postgres.js

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Example of initializing a Drizzle ORM database using postgres.js within a Cloudflare Worker. It uses environment variables for the database URL and performs migrations.

```typescript
// Cloudflare Worker example
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'

export default {
  async fetch(request, env) {
    const sql = postgres(env.DATABASE_URL)
    const db = drizzle({ client: sql })

    await migrate(db, migrations)

    return new Response('Database initialized')
  }
}
```

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

### Rollup Plugin Basic Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Integrate the Rollup plugin for Drizzle ORM migrations into your rollup.config.js. This example demonstrates basic setup.

```javascript
// rollup.config.js
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/rollup'

export default {
  input: 'src/index.ts',
  plugins: [
    DrizzleORMMigrations()
  ],
  output: {
    file: 'dist/bundle.js',
    format: 'esm'
  }
}
```

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

### Drizzle Kit Configuration for Browser Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/README.md

Example drizzle.config.ts configuration specifying the output directory for migrations and the schema file. This configuration is used by drizzle-kit to generate migration files.

```typescript
import { defineConfig } from 'drizzle-kit'

export default defineConfig({
  out: './drizzle',
  schema: './src/db/schema.ts',
  dialect: 'postgresql',
})
```

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

### Rspack Plugin Basic Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Configure the Rspack plugin for Drizzle ORM migrations. This example demonstrates basic setup within an rspack.config.js file.

```javascript
// rspack.config.js
const DrizzleORMMigrations = require('@proj-airi/unplugin-drizzle-orm-migrations/rspack')

module.exports = {
  mode: 'development',
  entry: './src/index.ts',
  plugins: [
    new DrizzleORMMigrations()
  ]
}
```

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

### Drizzle ORM Migration Execution in Browser

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Execute Drizzle ORM migrations in a browser environment using PGlite and the drizzle-orm-browser-migrator. This example shows how to import migrations and apply them to a PGlite database instance.

```typescript
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'
import { drizzle } from 'drizzle-orm/pglite'
import { PGlite } from '@electric-sql/pglite'

const db = drizzle({ client: new PGlite() })
await migrate(db, migrations)
```

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

### Rolldown Plugin Integration

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/api-reference-bundler.md

Integrate the Drizzle ORM migrations plugin into your Rolldown build configuration. This example shows basic setup for Rolldown, a Rust-based bundler.

```javascript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/rolldown'

export default {
  input: 'src/main.ts',
  plugins: [
    DrizzleORMMigrations()
  ],
  output: {
    file: 'dist/bundle.js',
    format: 'esm'
  }
}
```

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

### Initialize Node-Postgres Database and Run Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

Set up a database connection using `postgres` for Node.js environments and initialize Drizzle ORM. Apply pending migrations using the `migrate` function with the Drizzle DB instance and the virtual migrations SQL.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/node-postgres'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const sql = postgres(process.env.DATABASE_URL)
  const db = drizzle({ client: sql })
  
  await migrate(db, migrations)
  
  return db
}
```

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

### Initialize PGLite Database with Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Sets up a PGLite database instance, either with IndexedDB persistence or in-memory, and applies bundled migrations using drizzle-orm-browser.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'

// Option 1: With IndexedDB persistence
const pgLite = new PGlite({
  fs: new IdbFs('app-name')  // Data stored in IndexedDB
})

// Option 2: In-memory only
const pgLite = new PGlite()  // Data not persisted

const db = drizzle({ client: pgLite })
await migrate(db, migrations)
```

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

### Initialize Database in React App Startup

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

This snippet shows how to initialize the database when a React component mounts using `useEffect`. It handles loading and error states.

```typescript
import { useEffect, useState } from 'react'
import { initializeDatabase } from './db'

export function App() {
  const [db, setDb] = useState(null)
  const [error, setError] = useState(null)

  useEffect(() => {
    initializeDatabase()
      .then(setDb)
      .catch(error => {
        console.error('Database init failed:', error)
        setError(error)
      })
  }, [])

  if (error) return <div>Database error: {error.message}</div>
  if (!db) return <div>Initializing database...</div>

  return <YourApp db={db} />
}
```

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

### Configure Drizzle Kit for Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

Set up your `drizzle.config.ts` file to specify the database dialect, schema location, and output directory for migration files. Run `npx drizzle-kit generate` to create initial migration files.

```typescript
import { defineConfig } from 'drizzle-kit'

export default defineConfig({
  dialect: 'postgresql',
  schema: './src/db/schema.ts',
  out: './drizzle'  // ← Bundler will read from here
})
```

```bash
npx drizzle-kit generate
```

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

### Initialize PGLite Database and Run Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

Initialize a PGLite database instance for browser environments, persisting data to IndexedDB. Then, use the `migrate` function with the Drizzle DB instance and the virtual migrations SQL to apply pending migrations.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const pgLite = new PGlite({
    fs: new IdbFs('my-app-db')  // Persists to IndexedDB
  })
  
  const db = drizzle({ client: pgLite })
  
  await migrate(db, migrations)
  
  return db
}
```

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

### Initialize Postgres.js Database and Run Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

Connect to a PostgreSQL database using `postgres` (for Postgres.js) and initialize Drizzle ORM. Apply pending migrations by calling the `migrate` function with the Drizzle DB instance and the virtual migrations SQL.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'
import migrations from 'virtual:drizzle-migrations.sql'

export async function initializeDatabase() {
  const sql = postgres(process.env.DATABASE_URL)
  const db = drizzle({ client: sql })
  
  await migrate(db, migrations)
  
  return db
}
```

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

### Validate Migration Hashes Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Example of validating migration hashes to ensure data integrity. This involves calculating and comparing SHA256 hashes of migration files.

```typescript
import { createHash } from "crypto";
import fs from "fs/promises";
import path from "path";

async function validateMigrationHash(filePath: string): Promise<string> {
  const content = await fs.readFile(filePath, "utf-8");
  return createHash("sha256").update(content).digest("hex");
}

async function checkAllMigrationHashes() {
  const migrationsDir = path.resolve("./drizzle");
  const files = await fs.readdir(migrationsDir);

  for (const file of files) {
    if (file.endsWith(".sql")) {
      const filePath = path.join(migrationsDir, file);
      const hash = await validateMigrationHash(filePath);
      console.log(`Migration ${file} hash: ${hash}`);
      // In a real scenario, compare this hash against a stored value.
    }
  }
}

checkAllMigrationHashes().catch(console.error);
```

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

### Initialize PGlite and Apply Migrations in Browser

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/README.md

Initialize PGlite with IdbFs and apply bundled SQL migrations using the browser-compatible migrator. Ensure the virtual module 'virtual:drizzle-migrations.sql' is correctly imported.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
// Import the migrator
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import { drizzle } from 'drizzle-orm/pglite'
// Import the bundled migrations
import migrations from 'virtual:drizzle-migrations.sql'

const pgLite = new PGlite({ fs: new IdbFs('pglite-database') })
const db = drizzle({ client: pgLite })

// Apply the migrations
await migrate(db, migrations)
```

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

### Install Drizzle ORM Migrations Dependencies

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

Install the necessary packages for Drizzle ORM migrations using your preferred package manager. Ensure you have drizzle-orm version 0.44.0 or higher and a compatible database driver.

```bash
# Using pnpm
pnpm install -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator

# Using npm
npm install -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator

# Using yarn
yarn add -D @proj-airi/unplugin-drizzle-orm-migrations @proj-airi/drizzle-orm-browser-migrator
```

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

### Postgres.js Database Initialization

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Initialize a Drizzle ORM database instance using the postgres.js client and run migrations. Assumes migrations are available.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/postgres-js'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/postgres'

const sql = postgres('postgresql://user:password@localhost:5432/mydb')
const db = drizzle({ client: sql })
await migrate(db, migrations)
```

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

### Testing with Node-Postgres

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/database-support.md

Configure Drizzle ORM with Node-Postgres for testing. Includes setup, migration, and teardown for the database connection.

```typescript
import postgres from 'postgres'
import { drizzle } from 'drizzle-orm/node-postgres'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pg'

describe('Database operations', () => {
  let db, sql

  beforeEach(async () => {
    sql = postgres('postgresql://localhost:5432/test')
    db = drizzle({ client: sql })
    await migrate(db, migrations)
  })

  afterEach(async () => {
    await sql.end()
  })

  it('should create users', async () => {
    // Test queries
  })
})
```

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

### Rolldown Plugin Import Example

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/modules-and-exports.md

Import the Rolldown-specific plugin for use in your Rolldown configuration. This plugin is designed for Rolldown compatibility.

```typescript
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/rolldown'

export default {
  input: 'src/index.ts',
  plugins: [DrizzleORMMigrations()],
  output: { file: 'dist/bundle.js', format: 'esm' }
}
```

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

### Virtual Module Import Syntaxes

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/README.md

Demonstrates the two import syntaxes supported for virtual modules generated by the bundler plugin.

```typescript
import migrations from 'virtual:drizzle-migrations.sql'
import migrations from 'drizzle-migrations.sql'
```

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

### Centralized Database Instance with Migrations

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/implementation-guide.md

This pattern ensures a single database instance is used throughout the application. It initializes the database using `pglite` and applies migrations on first access.

```typescript
import { IdbFs, PGlite } from '@electric-sql/pglite'
import { drizzle } from 'drizzle-orm/pglite'
import { migrate } from '@proj-airi/drizzle-orm-browser-migrator/pglite'
import migrations from 'virtual:drizzle-migrations.sql'

let dbInstance = null

export async function getDatabase() {
  if (dbInstance) return dbInstance

  const pgLite = new PGlite({ fs: new IdbFs('app-db') })
  const db = drizzle({ client: pgLite })
  
  await migrate(db, migrations)
  
  dbInstance = db
  return db
}
```

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

### Custom Root Configuration

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/DOCUMENTATION-SUMMARY.txt

Demonstrates how to configure Drizzle Kit with a custom root configuration path. This is useful for non-standard project structures.

```bash
# In your package.json or drizzle.config.ts
drizzle-kit generate:pg --config=./path/to/your/drizzle.config.ts
```

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

### Rolldown Plugin Basic Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Basic integration of the Rolldown plugin for Drizzle ORM migrations. This example shows the minimal configuration required.

```javascript
// rolldown.config.js
import DrizzleORMMigrations from '@proj-airi/unplugin-drizzle-orm-migrations/rolldown'

export default {
  input: 'src/index.ts',
  plugins: [
    DrizzleORMMigrations()
  ],
  output: {
    file: 'dist/bundle.js',
    format: 'esm'
  }
}
```

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

### Webpack Plugin Basic Usage

Source: https://github.com/proj-airi/drizzle-orm-browser/blob/main/_autodocs/configuration.md

Configure the Webpack plugin for Drizzle ORM migrations. This example shows basic integration into a webpack.config.js file.

```javascript
// webpack.config.js
const DrizzleORMMigrations = require('@proj-airi/unplugin-drizzle-orm-migrations/webpack')

module.exports = {
  mode: 'development',
  entry: './src/index.ts',
  plugins: [
    new DrizzleORMMigrations()
  ],
  // ... rest of config
}
```