@agentuity/drizzle 0.1.41

package/AGENTS.md

@@ -0,0 +1,117 @@
+# Agent Guidelines for @agentuity/drizzle
+
+## Package Overview
+
+Drizzle ORM integration with resilient PostgreSQL connections for Agentuity projects. Combines the type-safety of Drizzle ORM with @agentuity/postgres's automatic reconnection capabilities.
+
+## Commands
+
+- **Build**: `bun run build`
+- **Typecheck**: `bun run typecheck`
+- **Clean**: `bun run clean`
+
+## Architecture
+
+- **Runtime**: Bun (required for native SQL driver)
+- **Dependencies**: `@agentuity/postgres`, `drizzle-orm`, `better-auth`
+- **Features**: Type-safe queries, automatic reconnection, schema definitions
+
+## Code Conventions
+
+- **Factory function**: Use `createPostgresDrizzle()` to create instances
+- **Schema-first**: Define schemas using Drizzle's `pgTable` and column types
+- **Connection handling**: Automatic reconnection via @agentuity/postgres
+- **Type safety**: Full TypeScript support with schema inference
+
+## Usage Pattern
+
+```typescript
+import { createPostgresDrizzle, pgTable, text, serial, eq } from '@agentuity/drizzle';
+
+// Define schema
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull().unique(),
+});
+
+// Create database instance (uses DATABASE_URL by default)
+const { db, client, close } = createPostgresDrizzle({
+	schema: { users },
+});
+
+// Or with explicit configuration
+const { db, close } = createPostgresDrizzle({
+	connectionString: 'postgres://user:pass@localhost:5432/mydb',
+	schema: { users },
+	logger: true,
+	reconnect: {
+		maxAttempts: 5,
+		initialDelayMs: 100,
+	},
+	onReconnected: () => console.log('Reconnected!'),
+});
+
+// Execute type-safe queries
+const allUsers = await db.select().from(users);
+const user = await db.select().from(users).where(eq(users.id, 1));
+
+// Access underlying client for raw queries or stats
+console.log(client.stats);
+const raw = await client`SELECT NOW()`;
+
+// Clean up
+await close();
+```
+
+## Integration with @agentuity/auth
+
+```typescript
+import { createPostgresDrizzle, drizzleAdapter } from '@agentuity/drizzle';
+import { createAuth } from '@agentuity/auth';
+import * as schema from './schema';
+
+const { db, close } = createPostgresDrizzle({ schema });
+
+const auth = createAuth({
+	database: drizzleAdapter(db, {
+		provider: 'pg',
+	}),
+});
+```
+
+## Re-exports
+
+This package re-exports commonly used items for convenience:
+
+### From @agentuity/postgres
+
+- `postgres` - Factory function for creating postgres clients
+- `PostgresClient` - Client class
+- `CallablePostgresClient` - Callable client type
+- `PostgresConfig`, `ReconnectConfig`, `ConnectionStats`, etc.
+
+### From drizzle-orm
+
+- Query operators: `sql`, `eq`, `and`, `or`, `not`, `desc`, `asc`, `gt`, `gte`, `lt`, `lte`, `ne`, `isNull`, `isNotNull`, `inArray`, `notInArray`, `between`, `like`, `ilike`
+
+### From drizzle-orm/pg-core
+
+- Schema definitions: `pgTable`, `pgSchema`, `pgEnum`
+- Column types: `text`, `integer`, `serial`, `boolean`, `timestamp`, `uuid`, `json`, `jsonb`, etc.
+- Constraints: `primaryKey`, `foreignKey`, `unique`, `uniqueIndex`, `index`, `check`
+
+### From better-auth
+
+- `drizzleAdapter` - For use with @agentuity/auth
+
+## Testing
+
+- Tests require a running PostgreSQL instance
+- Use `@agentuity/test-utils` for mocking
+- When running tests, prefer using a subagent (Task tool) to avoid context bloat
+
+## Publishing
+
+1. Run build and typecheck
+2. Publish **after** `@agentuity/postgres`

package/README.md

@@ -0,0 +1,239 @@
+# @agentuity/drizzle
+
+Drizzle ORM integration with resilient PostgreSQL connections for Agentuity projects.
+
+## Installation
+
+```bash
+bun add @agentuity/drizzle
+```
+
+## Features
+
+- **Type-safe queries** - Full TypeScript support with Drizzle ORM's schema inference
+- **Automatic reconnection** - Built on @agentuity/postgres with exponential backoff
+- **Convenient re-exports** - Common Drizzle utilities available from a single import
+- **Auth integration** - Works seamlessly with @agentuity/auth via drizzleAdapter
+
+## Basic Usage
+
+```typescript
+import { createPostgresDrizzle, pgTable, text, serial, eq } from '@agentuity/drizzle';
+
+// Define your schema
+const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull().unique(),
+});
+
+// Create database instance (uses DATABASE_URL by default)
+const { db, close } = createPostgresDrizzle({
+	schema: { users },
+});
+
+// Execute type-safe queries
+const allUsers = await db.select().from(users);
+const user = await db.select().from(users).where(eq(users.id, 1));
+
+// Insert data
+await db.insert(users).values({ name: 'Alice', email: 'alice@example.com' });
+
+// Clean up when done
+await close();
+```
+
+## Custom Configuration
+
+```typescript
+import { createPostgresDrizzle } from '@agentuity/drizzle';
+import * as schema from './schema';
+
+const { db, client, close } = createPostgresDrizzle({
+	// Connection string (defaults to DATABASE_URL)
+	connectionString: 'postgres://user:pass@localhost:5432/mydb',
+
+	// Your Drizzle schema
+	schema,
+
+	// Enable query logging
+	logger: true,
+
+	// Reconnection settings
+	reconnect: {
+		maxAttempts: 5,
+		initialDelayMs: 100,
+		maxDelayMs: 30000,
+	},
+
+	// Callbacks
+	onConnect: () => console.log('Connected to database'),
+	onReconnected: () => console.log('Reconnected to database'),
+});
+
+// Access connection statistics
+console.log(client.stats);
+// { connected: true, reconnecting: false, totalConnections: 1, ... }
+```
+
+## Using with @agentuity/auth
+
+```typescript
+import { createPostgresDrizzle, drizzleAdapter } from '@agentuity/drizzle';
+import { createAuth } from '@agentuity/auth';
+import * as schema from './schema';
+
+// Create database instance
+const { db, close } = createPostgresDrizzle({ schema });
+
+// Create auth with Drizzle adapter
+const auth = createAuth({
+	database: drizzleAdapter(db, {
+		provider: 'pg',
+	}),
+});
+```
+
+## Accessing the Underlying Client
+
+The `client` property gives you access to the @agentuity/postgres client for raw queries:
+
+```typescript
+const { db, client, close } = createPostgresDrizzle({ schema });
+
+// Use Drizzle for type-safe queries
+const users = await db.select().from(schema.users);
+
+// Use the client for raw queries
+const result = await client`SELECT NOW()`;
+
+// Check connection status
+if (client.connected) {
+	console.log('Database is connected');
+}
+
+// Access connection statistics
+console.log(client.stats);
+```
+
+## Available Re-exports
+
+### Query Operators (from drizzle-orm)
+
+```typescript
+import {
+	sql,
+	eq,
+	and,
+	or,
+	not,
+	desc,
+	asc,
+	gt,
+	gte,
+	lt,
+	lte,
+	ne,
+	isNull,
+	isNotNull,
+	inArray,
+	notInArray,
+	between,
+	like,
+	ilike,
+} from '@agentuity/drizzle';
+```
+
+### Schema Definitions (from drizzle-orm/pg-core)
+
+```typescript
+import {
+	// Table and schema
+	pgTable,
+	pgSchema,
+	pgEnum,
+
+	// Column types
+	text,
+	varchar,
+	char,
+	integer,
+	smallint,
+	bigint,
+	serial,
+	smallserial,
+	bigserial,
+	boolean,
+	timestamp,
+	date,
+	time,
+	interval,
+	json,
+	jsonb,
+	uuid,
+	numeric,
+	real,
+	doublePrecision,
+	inet,
+	cidr,
+	macaddr,
+	macaddr8,
+
+	// Constraints
+	primaryKey,
+	foreignKey,
+	unique,
+	uniqueIndex,
+	index,
+	check,
+} from '@agentuity/drizzle';
+```
+
+### Postgres Client (from @agentuity/postgres)
+
+```typescript
+import {
+	postgres,
+	PostgresClient,
+	type CallablePostgresClient,
+	type PostgresConfig,
+	type ReconnectConfig,
+	type ConnectionStats,
+} from '@agentuity/drizzle';
+```
+
+### Auth Adapter (from better-auth)
+
+```typescript
+import { drizzleAdapter } from '@agentuity/drizzle';
+```
+
+## API Reference
+
+### createPostgresDrizzle(config?)
+
+Creates a Drizzle ORM instance with a resilient PostgreSQL connection.
+
+#### Parameters
+
+| Parameter                 | Type                       | Description                                           |
+| ------------------------- | -------------------------- | ----------------------------------------------------- |
+| `config.connectionString` | `string`                   | PostgreSQL connection URL. Defaults to `DATABASE_URL` |
+| `config.connection`       | `PostgresConfig`           | Full connection configuration object                  |
+| `config.schema`           | `TSchema`                  | Drizzle schema for type-safe queries                  |
+| `config.logger`           | `boolean \| DrizzleLogger` | Enable query logging                                  |
+| `config.reconnect`        | `ReconnectConfig`          | Reconnection behavior configuration                   |
+| `config.onConnect`        | `() => void`               | Called when initially connected                       |
+| `config.onReconnected`    | `() => void`               | Called after successful reconnection                  |
+
+#### Returns
+
+| Property | Type                      | Description                    |
+| -------- | ------------------------- | ------------------------------ |
+| `db`     | `BunSQLDatabase<TSchema>` | The Drizzle database instance  |
+| `client` | `CallablePostgresClient`  | The underlying postgres client |
+| `close`  | `() => Promise<void>`     | Cleanup function               |
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @agentuity/drizzle - Drizzle ORM integration with resilient PostgreSQL connections
+ *
+ * This package provides a seamless integration between Drizzle ORM and
+ * @agentuity/postgres, combining type-safe database queries with automatic
+ * reconnection capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle, pgTable, text, serial } from '@agentuity/drizzle';
+ *
+ * // Define your schema
+ * const users = pgTable('users', {
+ *   id: serial('id').primaryKey(),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ * });
+ *
+ * // Create the database instance
+ * const { db, close } = createPostgresDrizzle({
+ *   schema: { users },
+ * });
+ *
+ * // Execute type-safe queries
+ * const allUsers = await db.select().from(users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createPostgresDrizzle } from './postgres';
+export type { PostgresDrizzleConfig, PostgresDrizzle } from './types';
+export { postgres, PostgresClient, type CallablePostgresClient, type PostgresConfig, type ReconnectConfig, type ConnectionStats, type TLSConfig, type TransactionOptions, type ReserveOptions, } from '@agentuity/postgres';
+export { sql, eq, and, or, not, desc, asc, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, between, like, ilike, } from 'drizzle-orm';
+export { pgTable, pgSchema, pgEnum, bigint, bigserial, boolean, char, cidr, customType, date, doublePrecision, inet, integer, interval, json, jsonb, macaddr, macaddr8, numeric, real, serial, smallint, smallserial, text, time, timestamp, uuid, varchar, primaryKey, foreignKey, unique, uniqueIndex, index, check, } from 'drizzle-orm/pg-core';
+export { drizzleAdapter } from 'better-auth/adapters/drizzle';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAGtE,OAAO,EACN,QAAQ,EACR,cAAc,EACd,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACN,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,IAAI,EACJ,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,MAAM,EACN,SAAS,EACT,OAAO,EACP,UAAU,EACV,OAAO,EACP,IAAI,EACJ,KAAK,GACL,MAAM,aAAa,CAAC;AAGrB,OAAO,EACN,OAAO,EACP,QAAQ,EACR,MAAM,EAEN,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,eAAe,EACf,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,OAAO,EACP,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,WAAW,EACX,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,OAAO,EAEP,UAAU,EACV,UAAU,EACV,MAAM,EACN,WAAW,EACX,KAAK,EACL,KAAK,GACL,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * @agentuity/drizzle - Drizzle ORM integration with resilient PostgreSQL connections
+ *
+ * This package provides a seamless integration between Drizzle ORM and
+ * @agentuity/postgres, combining type-safe database queries with automatic
+ * reconnection capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle, pgTable, text, serial } from '@agentuity/drizzle';
+ *
+ * // Define your schema
+ * const users = pgTable('users', {
+ *   id: serial('id').primaryKey(),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ * });
+ *
+ * // Create the database instance
+ * const { db, close } = createPostgresDrizzle({
+ *   schema: { users },
+ * });
+ *
+ * // Execute type-safe queries
+ * const allUsers = await db.select().from(users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Main factory function
+export { createPostgresDrizzle } from './postgres';
+// Re-export from @agentuity/postgres for convenience
+export { postgres, PostgresClient, } from '@agentuity/postgres';
+// Re-export common Drizzle utilities for convenience
+export { sql, eq, and, or, not, desc, asc, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, between, like, ilike, } from 'drizzle-orm';
+// Re-export pg-core table and column definitions
+export { pgTable, pgSchema, pgEnum, 
+// Column types
+bigint, bigserial, boolean, char, cidr, customType, date, doublePrecision, inet, integer, interval, json, jsonb, macaddr, macaddr8, numeric, real, serial, smallint, smallserial, text, time, timestamp, uuid, varchar, 
+// Constraints and indexes
+primaryKey, foreignKey, unique, uniqueIndex, index, check, } from 'drizzle-orm/pg-core';
+// Re-export better-auth drizzle adapter for use with @agentuity/auth
+export { drizzleAdapter } from 'better-auth/adapters/drizzle';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAwB;AACxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAKnD,qDAAqD;AACrD,OAAO,EACN,QAAQ,EACR,cAAc,GAQd,MAAM,qBAAqB,CAAC;AAE7B,qDAAqD;AACrD,OAAO,EACN,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,IAAI,EACJ,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,MAAM,EACN,SAAS,EACT,OAAO,EACP,UAAU,EACV,OAAO,EACP,IAAI,EACJ,KAAK,GACL,MAAM,aAAa,CAAC;AAErB,iDAAiD;AACjD,OAAO,EACN,OAAO,EACP,QAAQ,EACR,MAAM;AACN,eAAe;AACf,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,eAAe,EACf,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,KAAK,EACL,OAAO,EACP,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,WAAW,EACX,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,OAAO;AACP,0BAA0B;AAC1B,UAAU,EACV,UAAU,EACV,MAAM,EACN,WAAW,EACX,KAAK,EACL,KAAK,GACL,MAAM,qBAAqB,CAAC;AAE7B,qEAAqE;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/postgres.d.ts

@@ -0,0 +1,47 @@
+import type { PostgresDrizzleConfig, PostgresDrizzle } from './types';
+/**
+ * Creates a Drizzle ORM instance with a resilient PostgreSQL connection.
+ *
+ * This function combines the power of Drizzle ORM with @agentuity/postgres's
+ * automatic reconnection capabilities. The underlying connection will
+ * automatically reconnect with exponential backoff if the connection is lost.
+ *
+ * @template TSchema - The Drizzle schema type for type-safe queries
+ * @param config - Configuration options for the database connection
+ * @returns An object containing the Drizzle instance, underlying client, and close function
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle } from '@agentuity/drizzle';
+ * import * as schema from './schema';
+ *
+ * // Basic usage with DATABASE_URL
+ * const { db, close } = createPostgresDrizzle({ schema });
+ *
+ * // Query with type safety
+ * const users = await db.select().from(schema.users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom connection configuration
+ * const { db, client, close } = createPostgresDrizzle({
+ *   connectionString: 'postgres://user:pass@localhost:5432/mydb',
+ *   schema,
+ *   logger: true,
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 100,
+ *   },
+ *   onReconnected: () => console.log('Database reconnected'),
+ * });
+ *
+ * // Access connection stats
+ * console.log(client.stats);
+ * ```
+ */
+export declare function createPostgresDrizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config?: PostgresDrizzleConfig<TSchema>): PostgresDrizzle<TSchema>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAC9D,MAAM,CAAC,EAAE,qBAAqB,CAAC,OAAO,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,CAoDnE"}

package/dist/postgres.js

@@ -0,0 +1,94 @@
+import { drizzle } from 'drizzle-orm/bun-sql';
+import { postgres } from '@agentuity/postgres';
+/**
+ * Creates a Drizzle ORM instance with a resilient PostgreSQL connection.
+ *
+ * This function combines the power of Drizzle ORM with @agentuity/postgres's
+ * automatic reconnection capabilities. The underlying connection will
+ * automatically reconnect with exponential backoff if the connection is lost.
+ *
+ * @template TSchema - The Drizzle schema type for type-safe queries
+ * @param config - Configuration options for the database connection
+ * @returns An object containing the Drizzle instance, underlying client, and close function
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle } from '@agentuity/drizzle';
+ * import * as schema from './schema';
+ *
+ * // Basic usage with DATABASE_URL
+ * const { db, close } = createPostgresDrizzle({ schema });
+ *
+ * // Query with type safety
+ * const users = await db.select().from(schema.users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom connection configuration
+ * const { db, client, close } = createPostgresDrizzle({
+ *   connectionString: 'postgres://user:pass@localhost:5432/mydb',
+ *   schema,
+ *   logger: true,
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 100,
+ *   },
+ *   onReconnected: () => console.log('Database reconnected'),
+ * });
+ *
+ * // Access connection stats
+ * console.log(client.stats);
+ * ```
+ */
+export function createPostgresDrizzle(config) {
+    // Build postgres client configuration by cloning the connection config
+    // to avoid mutating the caller's object
+    const clientConfig = config?.connection ? { ...config.connection } : {};
+    // Use connectionString only if no url is already present on the cloned config
+    // This ensures connection (when provided) keeps precedence over connectionString
+    if (!clientConfig.url) {
+        if (config?.connectionString) {
+            clientConfig.url = config.connectionString;
+        }
+        else if (process.env.DATABASE_URL) {
+            clientConfig.url = process.env.DATABASE_URL;
+        }
+    }
+    // Add reconnection configuration
+    if (config?.reconnect) {
+        clientConfig.reconnect = config.reconnect;
+    }
+    // Add callbacks
+    if (config?.onReconnected) {
+        clientConfig.onreconnected = config.onReconnected;
+    }
+    // Create the postgres client
+    const client = postgres(clientConfig);
+    // Wait for connection before calling onConnect callback
+    // This ensures the callback executes only after the connection is established
+    if (config?.onConnect) {
+        client.waitForConnection().then(() => {
+            config.onConnect();
+        });
+    }
+    // Create Drizzle instance using the client's raw SQL connection
+    // The bun-sql driver accepts a client that implements the Bun.SQL interface
+    const db = drizzle({
+        client: client.raw,
+        schema: config?.schema,
+        logger: config?.logger,
+    });
+    // Return the combined interface
+    return {
+        db,
+        client,
+        close: async () => {
+            await client.close();
+        },
+    };
+}
+//# sourceMappingURL=postgres.js.map

package/dist/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAA+B,MAAM,qBAAqB,CAAC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,UAAU,qBAAqB,CAEnC,MAAuC;IACxC,uEAAuE;IACvE,wCAAwC;IACxC,MAAM,YAAY,GAAG,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAExE,8EAA8E;IAC9E,iFAAiF;IACjF,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,MAAM,EAAE,gBAAgB,EAAE,CAAC;YAC9B,YAAY,CAAC,GAAG,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAC5C,CAAC;aAAM,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YACrC,YAAY,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;QAC7C,CAAC;IACF,CAAC;IAED,iCAAiC;IACjC,IAAI,MAAM,EAAE,SAAS,EAAE,CAAC;QACvB,YAAY,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IAC3C,CAAC;IAED,gBAAgB;IAChB,IAAI,MAAM,EAAE,aAAa,EAAE,CAAC;QAC3B,YAAY,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;IACnD,CAAC;IAED,6BAA6B;IAC7B,MAAM,MAAM,GAA2B,QAAQ,CAAC,YAAY,CAAC,CAAC;IAE9D,wDAAwD;IACxD,8EAA8E;IAC9E,IAAI,MAAM,EAAE,SAAS,EAAE,CAAC;QACvB,MAAM,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACpC,MAAM,CAAC,SAAU,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,gEAAgE;IAChE,4EAA4E;IAC5E,MAAM,EAAE,GAAG,OAAO,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC,GAAG;QAClB,MAAM,EAAE,MAAM,EAAE,MAAM;QACtB,MAAM,EAAE,MAAM,EAAE,MAAM;KACtB,CAAC,CAAC;IAEH,gCAAgC;IAChC,OAAO;QACN,EAAE;QACF,MAAM;QACN,KAAK,EAAE,KAAK,IAAI,EAAE;YACjB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+import type { Logger as DrizzleLogger } from 'drizzle-orm';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
+import type { PostgresConfig, ReconnectConfig, CallablePostgresClient } from '@agentuity/postgres';
+/**
+ * Configuration options for creating a PostgreSQL Drizzle instance.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface PostgresDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> {
+    /**
+     * PostgreSQL connection string.
+     * If not provided, uses `process.env.DATABASE_URL`.
+     */
+    connectionString?: string;
+    /**
+     * Full PostgreSQL connection configuration.
+     * Takes precedence over `connectionString` if both are provided.
+     */
+    connection?: PostgresConfig;
+    /**
+     * Drizzle schema for type-safe queries.
+     */
+    schema?: TSchema;
+    /**
+     * Enable query logging.
+     * - `true`: Use default console logger
+     * - `DrizzleLogger`: Custom logger implementation
+     */
+    logger?: boolean | DrizzleLogger;
+    /**
+     * Reconnection configuration passed to the underlying postgres client.
+     */
+    reconnect?: ReconnectConfig;
+    /**
+     * Callback invoked when the initial connection is established.
+     */
+    onConnect?: () => void;
+    /**
+     * Callback invoked when the connection is re-established after a disconnect.
+     */
+    onReconnected?: () => void;
+}
+/**
+ * The result of creating a PostgreSQL Drizzle instance.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface PostgresDrizzle<TSchema extends Record<string, unknown> = Record<string, never>> {
+    /**
+     * The Drizzle database instance for executing queries.
+     */
+    db: BunSQLDatabase<TSchema>;
+    /**
+     * The underlying PostgreSQL client with reconnection support.
+     * Can be used for raw queries or accessing connection state.
+     */
+    client: CallablePostgresClient;
+    /**
+     * Closes the database connection and releases resources.
+     */
+    close: () => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEnG;;;;GAIG;AACH,MAAM,WAAW,qBAAqB,CACrC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAE/D;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;IAE5B;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;IAEjC;;OAEG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAE5B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAEvB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAC/F;;OAEG;IACH,EAAE,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAE5B;;;OAGG;IACH,MAAM,EAAE,sBAAsB,CAAC;IAE/B;;OAEG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@agentuity/drizzle",
+	"version": "0.1.41",
+	"license": "Apache-2.0",
+	"author": "Agentuity employees and contributors",
+	"type": "module",
+	"description": "Drizzle ORM integration with resilient PostgreSQL connections for Agentuity projects",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"AGENTS.md",
+		"README.md",
+		"src",
+		"dist"
+	],
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"typesVersions": {
+		"*": {
+			".": [
+				"./dist/index.d.ts"
+			]
+		}
+	},
+	"scripts": {
+		"clean": "rm -rf dist tsconfig.tsbuildinfo",
+		"build": "bunx tsc --build --force",
+		"typecheck": "bunx tsc --noEmit",
+		"prepublishOnly": "bun run clean && bun run build"
+	},
+	"dependencies": {
+		"@agentuity/postgres": "0.1.41",
+		"drizzle-orm": "^0.45.0",
+		"better-auth": "^1.4.9"
+	},
+	"devDependencies": {
+		"@agentuity/test-utils": "0.1.41",
+		"@types/bun": "latest",
+		"bun-types": "latest",
+		"typescript": "^5.9.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"sideEffects": false
+}

package/src/index.ts

@@ -0,0 +1,117 @@
+/**
+ * @agentuity/drizzle - Drizzle ORM integration with resilient PostgreSQL connections
+ *
+ * This package provides a seamless integration between Drizzle ORM and
+ * @agentuity/postgres, combining type-safe database queries with automatic
+ * reconnection capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle, pgTable, text, serial } from '@agentuity/drizzle';
+ *
+ * // Define your schema
+ * const users = pgTable('users', {
+ *   id: serial('id').primaryKey(),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ * });
+ *
+ * // Create the database instance
+ * const { db, close } = createPostgresDrizzle({
+ *   schema: { users },
+ * });
+ *
+ * // Execute type-safe queries
+ * const allUsers = await db.select().from(users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Main factory function
+export { createPostgresDrizzle } from './postgres';
+
+// Types
+export type { PostgresDrizzleConfig, PostgresDrizzle } from './types';
+
+// Re-export from @agentuity/postgres for convenience
+export {
+	postgres,
+	PostgresClient,
+	type CallablePostgresClient,
+	type PostgresConfig,
+	type ReconnectConfig,
+	type ConnectionStats,
+	type TLSConfig,
+	type TransactionOptions,
+	type ReserveOptions,
+} from '@agentuity/postgres';
+
+// Re-export common Drizzle utilities for convenience
+export {
+	sql,
+	eq,
+	and,
+	or,
+	not,
+	desc,
+	asc,
+	gt,
+	gte,
+	lt,
+	lte,
+	ne,
+	isNull,
+	isNotNull,
+	inArray,
+	notInArray,
+	between,
+	like,
+	ilike,
+} from 'drizzle-orm';
+
+// Re-export pg-core table and column definitions
+export {
+	pgTable,
+	pgSchema,
+	pgEnum,
+	// Column types
+	bigint,
+	bigserial,
+	boolean,
+	char,
+	cidr,
+	customType,
+	date,
+	doublePrecision,
+	inet,
+	integer,
+	interval,
+	json,
+	jsonb,
+	macaddr,
+	macaddr8,
+	numeric,
+	real,
+	serial,
+	smallint,
+	smallserial,
+	text,
+	time,
+	timestamp,
+	uuid,
+	varchar,
+	// Constraints and indexes
+	primaryKey,
+	foreignKey,
+	unique,
+	uniqueIndex,
+	index,
+	check,
+} from 'drizzle-orm/pg-core';
+
+// Re-export better-auth drizzle adapter for use with @agentuity/auth
+export { drizzleAdapter } from 'better-auth/adapters/drizzle';

package/src/postgres.ts

@@ -0,0 +1,103 @@
+import { drizzle } from 'drizzle-orm/bun-sql';
+import { postgres, type CallablePostgresClient } from '@agentuity/postgres';
+import type { PostgresDrizzleConfig, PostgresDrizzle } from './types';
+
+/**
+ * Creates a Drizzle ORM instance with a resilient PostgreSQL connection.
+ *
+ * This function combines the power of Drizzle ORM with @agentuity/postgres's
+ * automatic reconnection capabilities. The underlying connection will
+ * automatically reconnect with exponential backoff if the connection is lost.
+ *
+ * @template TSchema - The Drizzle schema type for type-safe queries
+ * @param config - Configuration options for the database connection
+ * @returns An object containing the Drizzle instance, underlying client, and close function
+ *
+ * @example
+ * ```typescript
+ * import { createPostgresDrizzle } from '@agentuity/drizzle';
+ * import * as schema from './schema';
+ *
+ * // Basic usage with DATABASE_URL
+ * const { db, close } = createPostgresDrizzle({ schema });
+ *
+ * // Query with type safety
+ * const users = await db.select().from(schema.users);
+ *
+ * // Clean up when done
+ * await close();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom connection configuration
+ * const { db, client, close } = createPostgresDrizzle({
+ *   connectionString: 'postgres://user:pass@localhost:5432/mydb',
+ *   schema,
+ *   logger: true,
+ *   reconnect: {
+ *     maxAttempts: 5,
+ *     initialDelayMs: 100,
+ *   },
+ *   onReconnected: () => console.log('Database reconnected'),
+ * });
+ *
+ * // Access connection stats
+ * console.log(client.stats);
+ * ```
+ */
+export function createPostgresDrizzle<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+>(config?: PostgresDrizzleConfig<TSchema>): PostgresDrizzle<TSchema> {
+	// Build postgres client configuration by cloning the connection config
+	// to avoid mutating the caller's object
+	const clientConfig = config?.connection ? { ...config.connection } : {};
+
+	// Use connectionString only if no url is already present on the cloned config
+	// This ensures connection (when provided) keeps precedence over connectionString
+	if (!clientConfig.url) {
+		if (config?.connectionString) {
+			clientConfig.url = config.connectionString;
+		} else if (process.env.DATABASE_URL) {
+			clientConfig.url = process.env.DATABASE_URL;
+		}
+	}
+
+	// Add reconnection configuration
+	if (config?.reconnect) {
+		clientConfig.reconnect = config.reconnect;
+	}
+
+	// Add callbacks
+	if (config?.onReconnected) {
+		clientConfig.onreconnected = config.onReconnected;
+	}
+
+	// Create the postgres client
+	const client: CallablePostgresClient = postgres(clientConfig);
+
+	// Wait for connection before calling onConnect callback
+	// This ensures the callback executes only after the connection is established
+	if (config?.onConnect) {
+		client.waitForConnection().then(() => {
+			config.onConnect!();
+		});
+	}
+
+	// Create Drizzle instance using the client's raw SQL connection
+	// The bun-sql driver accepts a client that implements the Bun.SQL interface
+	const db = drizzle({
+		client: client.raw,
+		schema: config?.schema,
+		logger: config?.logger,
+	});
+
+	// Return the combined interface
+	return {
+		db,
+		client,
+		close: async () => {
+			await client.close();
+		},
+	};
+}

package/src/types.ts

@@ -0,0 +1,74 @@
+import type { Logger as DrizzleLogger } from 'drizzle-orm';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
+import type { PostgresConfig, ReconnectConfig, CallablePostgresClient } from '@agentuity/postgres';
+
+/**
+ * Configuration options for creating a PostgreSQL Drizzle instance.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface PostgresDrizzleConfig<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> {
+	/**
+	 * PostgreSQL connection string.
+	 * If not provided, uses `process.env.DATABASE_URL`.
+	 */
+	connectionString?: string;
+
+	/**
+	 * Full PostgreSQL connection configuration.
+	 * Takes precedence over `connectionString` if both are provided.
+	 */
+	connection?: PostgresConfig;
+
+	/**
+	 * Drizzle schema for type-safe queries.
+	 */
+	schema?: TSchema;
+
+	/**
+	 * Enable query logging.
+	 * - `true`: Use default console logger
+	 * - `DrizzleLogger`: Custom logger implementation
+	 */
+	logger?: boolean | DrizzleLogger;
+
+	/**
+	 * Reconnection configuration passed to the underlying postgres client.
+	 */
+	reconnect?: ReconnectConfig;
+
+	/**
+	 * Callback invoked when the initial connection is established.
+	 */
+	onConnect?: () => void;
+
+	/**
+	 * Callback invoked when the connection is re-established after a disconnect.
+	 */
+	onReconnected?: () => void;
+}
+
+/**
+ * The result of creating a PostgreSQL Drizzle instance.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface PostgresDrizzle<TSchema extends Record<string, unknown> = Record<string, never>> {
+	/**
+	 * The Drizzle database instance for executing queries.
+	 */
+	db: BunSQLDatabase<TSchema>;
+
+	/**
+	 * The underlying PostgreSQL client with reconnection support.
+	 * Can be used for raw queries or accessing connection state.
+	 */
+	client: CallablePostgresClient;
+
+	/**
+	 * Closes the database connection and releases resources.
+	 */
+	close: () => Promise<void>;
+}