hono-crud 0.1.4 → 0.3.0

package/dist/adapters/drizzle/index.d.ts

@@ -1,288 +1,186 @@
+import { Table, SQL, Column } from 'drizzle-orm';
+import { M as MetaInput, I as IncludeOptions, F as FilterCondition, g as RelationConfig, h as NestedUpdateInput, i as NestedWriteResult, L as ListFilters, P as PaginatedResult, j as AggregateOptions, k as AggregateResult, S as SearchOptions, l as SearchResult } from '../../types-CwJSGrCj.js';
 import { Env } from 'hono';
-import { Table, SQL, InferSelectModel, Column } from 'drizzle-orm';
+import { C as CreateEndpoint, M as ModelObject, R as ReadEndpoint, U as UpdateEndpoint, D as DeleteEndpoint, L as ListEndpoint, a as RestoreEndpoint, B as BatchCreateEndpoint, b as BatchDeleteEndpoint, c as BatchRestoreEndpoint, d as BatchUpdateEndpoint, e as BatchUpdateItem, A as AggregateEndpoint, f as BatchUpsertEndpoint, g as UpsertEndpoint, E as ExportEndpoint, I as ImportEndpoint, S as SearchEndpoint, V as VersionCompareEndpoint, h as VersionHistoryEndpoint, i as VersionReadEndpoint, j as VersionRollbackEndpoint } from '../../import-C4cjkYZ1.js';
+import { A as AdapterBundle } from '../../index-BVaCSKwG.js';
 import { z } from 'zod';
-import { M as MetaInput, d as AggregateEndpoint, g as AggregateOptions, h as AggregateResult, B as BatchCreateEndpoint, ak as ModelObject, n as BatchDeleteEndpoint, p as BatchRestoreEndpoint, r as BatchUpdateEndpoint, s as BatchUpdateItem, u as BatchUpsertEndpoint, F as CreateEndpoint, aA as RelationConfig, L as DeleteEndpoint, P as ExportEndpoint, af as ListFilters, ax as PaginatedResult, a2 as ImportEndpoint, ad as ListEndpoint, az as ReadEndpoint, a9 as IncludeOptions, aE as RestoreEndpoint, aI as SearchEndpoint, aJ as SearchOptions, aK as SearchResult, aP as UpdateEndpoint, ap as NestedUpdateInput, ar as NestedWriteResult, aR as UpsertEndpoint, aU as VersionCompareEndpoint, aV as VersionHistoryEndpoint, aY as VersionReadEndpoint, aZ as VersionRollbackEndpoint } from '../../import-C5LLxomK.js';
-import 'hono/utils/http-status';
 import '@hono/zod-openapi';
+import '../../route-BCROG0Mx.js';
+import 'hono/utils/http-status';
+import '../../versioning-4Pn5V1ed.js';
 
 /**
- * Drizzle-Zod schema utilities.
- *
- * This module provides helpers for generating Zod schemas from Drizzle tables
- * using drizzle-zod. This allows automatic schema generation for CRUD operations.
- *
- * Note: drizzle-zod is an optional peer dependency. These utilities will only
- * work if drizzle-zod is installed.
- *
- * @example
- * ```ts
- * import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
- * import { createDrizzleSchemas } from 'hono-crud/adapters/drizzle';
- *
- * const users = pgTable('users', {
- *   id: uuid('id').primaryKey().defaultRandom(),
- *   name: text('name').notNull(),
- *   email: text('email').notNull().unique(),
- *   createdAt: timestamp('created_at').defaultNow(),
- * });
- *
- * const { select: UserSchema, insert: CreateUserSchema } = createDrizzleSchemas(users);
- * ```
+ * Internal query builder interface used for type-safe method calls.
+ * All Drizzle query builders satisfy this interface at runtime.
+ */
+interface QueryBuilder extends PromiseLike<unknown[]> {
+    where(condition: unknown): QueryBuilder;
+    limit(n: number): QueryBuilder;
+    offset(n: number): QueryBuilder;
+    orderBy(...columns: unknown[]): QueryBuilder;
+    set(data: Record<string, unknown>): QueryBuilder;
+    values(data: Record<string, unknown> | Record<string, unknown>[]): QueryBuilder;
+    returning(): QueryBuilder;
+    onConflictDoUpdate(config: {
+        target: unknown[];
+        set: Record<string, unknown>;
+        where?: unknown;
+    }): QueryBuilder;
+    onConflictDoNothing(config?: {
+        target?: unknown[];
+    }): QueryBuilder;
+    onDuplicateKeyUpdate(config: {
+        set: Record<string, unknown>;
+    }): QueryBuilder;
+}
+/**
+ * Internal database interface used for type-safe method calls.
+ * All Drizzle databases (PostgreSQL, MySQL, SQLite) satisfy this interface at runtime.
  */
-
+interface Database {
+    select(fields?: Record<string, unknown>): {
+        from(table: Table): QueryBuilder;
+    };
+    insert(table: Table): QueryBuilder;
+    update(table: Table): QueryBuilder;
+    delete(table: Table): QueryBuilder;
+    transaction<T>(fn: (tx: Database) => Promise<T>): Promise<T>;
+}
 /**
- * Re-export createSelectSchema from drizzle-zod.
- * Creates a Zod schema for SELECT queries (all columns as required/optional based on table definition).
- *
- * @param table - Drizzle table definition
- * @param refine - Optional refinements for specific columns
- * @returns Zod schema for the table's select type
- *
- * @example
- * ```ts
- * import { users } from './schema';
- * import { createSelectSchema } from 'hono-crud/adapters/drizzle';
- *
- * const UserSchema = createSelectSchema(users);
- * type User = z.infer<typeof UserSchema>;
- * ```
+ * Casts a database to the internal Database interface for method calls.
+ * This is safe because all Drizzle databases have these methods at runtime.
  */
-declare function createSelectSchema<T extends Table>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+declare function cast<T>(instance: T): Database;
 /**
- * Re-export createInsertSchema from drizzle-zod.
- * Creates a Zod schema for INSERT queries (columns with defaults become optional).
- *
- * @param table - Drizzle table definition
- * @param refine - Optional refinements for specific columns
- * @returns Zod schema for the table's insert type
+ * Base constraint for Drizzle database types.
+ * Your database type must have select, insert, update, delete, and transaction methods.
  *
  * @example
  * ```ts
- * import { users } from './schema';
- * import { createInsertSchema } from 'hono-crud/adapters/drizzle';
+ * import { drizzle } from 'drizzle-orm/postgres-js';
+ * import * as schema from './schema';
  *
- * const CreateUserSchema = createInsertSchema(users);
- * type CreateUser = z.infer<typeof CreateUserSchema>;
+ * const database = drizzle(client, { schema });
+ *
+ * // Pass typeof database as the DB generic parameter
+ * class UserCreate extends DrizzleCreateEndpoint<Env, UserMeta, typeof database> {
+ *   db = database;  // Full type safety!
+ * }
  * ```
  */
-declare function createInsertSchema<T extends Table>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+interface DrizzleDatabaseConstraint {
+    select: unknown;
+    insert: unknown;
+    update: unknown;
+    delete: unknown;
+    transaction: unknown;
+}
 /**
- * Re-export createUpdateSchema from drizzle-zod (if available).
- * Creates a Zod schema for UPDATE queries (all columns become optional).
- *
- * Note: createUpdateSchema may not be available in older versions of drizzle-zod.
- * Use createInsertSchema(table).partial() as an alternative.
- *
- * @param table - Drizzle table definition
- * @param refine - Optional refinements for specific columns
- * @returns Zod schema for the table's update type
- *
- * @example
- * ```ts
- * import { users } from './schema';
- * import { createUpdateSchema } from 'hono-crud/adapters/drizzle';
- *
- * const UpdateUserSchema = createUpdateSchema(users);
- * type UpdateUser = z.infer<typeof UpdateUserSchema>;
- * ```
+ * @deprecated Pass your database type as a generic parameter instead
  */
-declare function createUpdateSchema<T extends Table>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+type DrizzleDatabase = DrizzleDatabaseConstraint;
 /**
- * Result of createDrizzleSchemas helper.
+ * @deprecated Pass your database type as a generic parameter instead
  */
-interface DrizzleSchemas {
-    /** Schema for SELECT queries (full record) */
-    select: z.ZodObject<Record<string, z.ZodTypeAny>>;
-    /** Schema for INSERT queries (required fields only) */
-    insert: z.ZodObject<Record<string, z.ZodTypeAny>>;
-    /** Schema for UPDATE queries (all fields optional) */
-    update: z.ZodObject<Record<string, z.ZodTypeAny>>;
-}
+type DrizzleDB = DrizzleDatabaseConstraint;
 /**
- * Creates all three common schemas (select, insert, update) for a Drizzle table.
- *
- * This is a convenience helper that generates:
- * - `select`: Full record schema for reading data
- * - `insert`: Schema for creating new records
- * - `update`: Partial schema for updating records
- *
- * @param table - Drizzle table definition
- * @param options - Optional configuration
- * @param options.insertRefine - Refinements for insert schema
- * @param options.selectRefine - Refinements for select schema
- * @param options.updateRefine - Refinements for update schema
- * @returns Object containing select, insert, and update schemas
+ * Type helper for defining Hono Env with database in Variables.
+ * Use this when injecting the database via middleware.
  *
  * @example
  * ```ts
- * import { pgTable, text, uuid } from 'drizzle-orm/pg-core';
- * import { createDrizzleSchemas, defineModel, defineMeta } from 'hono-crud/adapters/drizzle';
- * import { z } from 'zod';
+ * import { DrizzleEnv } from 'hono-crud/adapters/drizzle';
  *
- * const users = pgTable('users', {
- *   id: uuid('id').primaryKey().defaultRandom(),
- *   name: text('name').notNull(),
- *   email: text('email').notNull().unique(),
- * });
+ * type AppEnv = DrizzleEnv<typeof db>;
  *
- * // Generate schemas from table
- * const schemas = createDrizzleSchemas(users, {
- *   insertRefine: {
- *     email: z.string().email(), // Add email validation
- *   },
- * });
+ * const app = new Hono<AppEnv>();
  *
- * // Use with hono-crud model
- * const UserModel = defineModel({
- *   tableName: 'users',
- *   schema: schemas.select,
- *   primaryKeys: ['id'],
- *   table: users,
+ * app.use('*', async (c, next) => {
+ *   c.set('db', db);
+ *   await next();
  * });
- * ```
- */
-declare function createDrizzleSchemas<T extends Table>(table: T, options?: {
-    insertRefine?: Record<string, z.ZodTypeAny>;
-    selectRefine?: Record<string, z.ZodTypeAny>;
-    updateRefine?: Record<string, z.ZodTypeAny>;
-}): DrizzleSchemas;
-/**
- * Async version of createDrizzleSchemas that handles lazy loading.
- * Use this if you're not sure drizzle-zod is already loaded.
  *
- * @param table - Drizzle table definition
- * @param options - Optional configuration
- * @returns Promise resolving to schemas object
- */
-declare function createDrizzleSchemasAsync<T extends Table>(table: T, options?: {
-    insertRefine?: Record<string, z.ZodTypeAny>;
-    selectRefine?: Record<string, z.ZodTypeAny>;
-    updateRefine?: Record<string, z.ZodTypeAny>;
-}): Promise<DrizzleSchemas>;
-/**
- * Checks if drizzle-zod is available.
- * @returns true if drizzle-zod can be imported
- */
-declare function isDrizzleZodAvailable(): boolean;
-
-/**
- * Query builder type returned by select().from()
+ * // Endpoints can now access db from context automatically
+ * class ProjectCreate extends DrizzleCreateEndpoint<AppEnv, typeof projectMeta> {
+ *   _meta = projectMeta;
+ *   // No db property needed - comes from context!
+ * }
+ * ```
  */
-interface DrizzleSelectQuery<T = unknown> {
-    where(condition?: SQL): DrizzleSelectQuery<T>;
-    limit(n: number): DrizzleSelectQuery<T>;
-    offset(n: number): DrizzleSelectQuery<T>;
-    orderBy(...columns: SQL[]): DrizzleSelectQuery<T>;
-    from(table: Table): DrizzleSelectQuery<T>;
-    then<TResult>(onfulfilled?: (value: T[]) => TResult | PromiseLike<TResult>): Promise<TResult>;
-}
+type DrizzleEnv<DB = DrizzleDatabaseConstraint> = {
+    Variables: {
+        db: DB;
+    };
+};
 /**
- * Configuration for ON CONFLICT DO UPDATE (PostgreSQL/SQLite)
+ * Gets the Drizzle table from the model.
  */
-interface OnConflictDoUpdateConfig<T = unknown> {
-    /** Target columns for conflict detection */
-    target: Column[];
-    /** Data to set on conflict */
-    set: Record<string, unknown>;
-    /** Optional where clause for conditional update */
-    where?: SQL;
-}
+declare function getTable<M extends MetaInput>(meta: M): Table;
 /**
- * Insert query builder type with upsert support
+ * Gets a column from the table with proper type safety.
+ * Uses drizzle-orm's getTableColumns for type-safe column access.
+ *
+ * @param table - The Drizzle table
+ * @param field - The field/column name
+ * @returns The column
+ * @throws Error if the column is not found in the table
  */
-interface DrizzleInsertQuery<T = unknown> {
-    values(data: Record<string, unknown> | Record<string, unknown>[]): DrizzleInsertQuery<T>;
-    returning(): Promise<T[]>;
-    /**
-     * PostgreSQL/SQLite: ON CONFLICT DO UPDATE
-     */
-    onConflictDoUpdate(config: OnConflictDoUpdateConfig<T>): DrizzleInsertQuery<T>;
-    /**
-     * PostgreSQL/SQLite: ON CONFLICT DO NOTHING
-     */
-    onConflictDoNothing(config?: {
-        target?: Column[];
-    }): DrizzleInsertQuery<T>;
-    /**
-     * MySQL: ON DUPLICATE KEY UPDATE
-     */
-    onDuplicateKeyUpdate(config: {
-        set: Record<string, unknown>;
-    }): DrizzleInsertQuery<T>;
-}
+declare function getColumn(table: Table, field: string): Column;
 /**
- * Update query builder type
+ * Loads related records for a given item using Drizzle queries.
  */
-interface DrizzleUpdateQuery<T = unknown> {
-    set(data: Record<string, unknown>): DrizzleUpdateQuery<T>;
-    where(condition?: SQL): DrizzleUpdateQuery<T>;
-    returning(): Promise<T[]>;
-}
+declare function loadDrizzleRelation<T extends Record<string, unknown>>(db: DrizzleDatabase, item: T, relationName: string, relationConfig: RelationConfig<Table>): Promise<T>;
 /**
- * Delete query builder type
+ * Loads all requested relations for an item.
+ * Note: For multiple items, use `batchLoadDrizzleRelations` to avoid N+1 queries.
  */
-interface DrizzleDeleteQuery<T = unknown> {
-    where(condition?: SQL): DrizzleDeleteQuery<T>;
-    returning(): Promise<T[]>;
-}
+declare function loadDrizzleRelations<T extends Record<string, unknown>, M extends MetaInput>(db: DrizzleDatabase, item: T, meta: M, includeOptions?: IncludeOptions): Promise<T>;
 /**
- * Generic Drizzle database interface that works with any dialect.
- * This type provides strong typing while remaining dialect-agnostic.
- *
- * @example
- * ```ts
- * import { drizzle } from 'drizzle-orm/node-postgres';
- *
- * const db = drizzle(pool);
- *
- * class UserCreate extends DrizzleCreateEndpoint<Env, UserMeta> {
- *   db: DrizzleDatabase = db;
- * }
- * ```
+ * Batch loads relations for multiple items to avoid N+1 queries.
+ * Instead of N queries per relation, this uses 1 query per relation using inArray().
  */
-interface DrizzleDatabase {
-    /**
-     * Create a SELECT query
-     */
-    select<T extends Record<string, unknown> = Record<string, unknown>>(fields?: T): {
-        from<TTable extends Table>(table: TTable): DrizzleSelectQuery<InferSelectModel<TTable>>;
-    };
-    /**
-     * Create an INSERT query
-     */
-    insert<TTable extends Table>(table: TTable): DrizzleInsertQuery<InferSelectModel<TTable>>;
-    /**
-     * Create an UPDATE query
-     */
-    update<TTable extends Table>(table: TTable): DrizzleUpdateQuery<InferSelectModel<TTable>>;
-    /**
-     * Create a DELETE query
-     */
-    delete<TTable extends Table>(table: TTable): DrizzleDeleteQuery<InferSelectModel<TTable>>;
-    /**
-     * Execute operations within a transaction
-     */
-    transaction<T>(fn: (tx: DrizzleDatabase) => Promise<T>): Promise<T>;
-}
+declare function batchLoadDrizzleRelations<T extends Record<string, unknown>, M extends MetaInput>(db: DrizzleDatabase, items: T[], meta: M, includeOptions?: IncludeOptions): Promise<T[]>;
 /**
- * @deprecated Use DrizzleDatabase instead
+ * Builds a where condition from filter conditions.
  */
-type DrizzleDB = DrizzleDatabase;
+declare function buildWhereCondition(table: Table, filter: FilterCondition): SQL | undefined;
+
 /**
  * Drizzle Create endpoint.
  * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
  *
+ * The database can be provided in three ways:
+ * 1. Direct property: `db = myDb;`
+ * 2. Context injection via middleware: `c.set('db', myDb)`
+ * 3. Factory function: `createDrizzleCrud(db, meta)`
+ *
  * @example
  * ```ts
+ * // Pattern 1: Direct property (backward compatible)
  * class UserCreate extends DrizzleCreateEndpoint<Env, typeof userMeta> {
  *   _meta = userMeta;
- *   db = db;  // Your Drizzle instance
+ *   db = db;
+ * }
+ *
+ * // Pattern 2: Context injection (cleanest - no db property needed)
+ * class UserCreate extends DrizzleCreateEndpoint<AppEnv, typeof userMeta> {
+ *   _meta = userMeta;
+ *   // db comes from c.set('db', myDb) in middleware
+ * }
+ *
+ * // Pattern 3: Factory function (no _meta or db needed)
+ * const User = createDrizzleCrud(db, userMeta);
+ * class UserCreate extends User.Create {
+ *   schema = { tags: ['Users'] };
  * }
  * ```
  */
 declare abstract class DrizzleCreateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends CreateEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /**
+     * Drizzle database instance.
+     * Can be undefined if using context-based injection via middleware.
+     */
+    db?: DrizzleDatabase;
     /**
      * Whether to wrap create and nested operations in a transaction.
      * When true, the entire create operation (including nested writes) will be atomic.
@@ -292,7 +190,10 @@ declare abstract class DrizzleCreateEndpoint<E extends Env = Env, M extends Meta
     /** Current transaction context (set during transaction execution) */
     private _tx?;
     /**
-     * Gets the database instance to use (transaction or main db).
+     * Gets the database instance to use. Checks in order:
+     * 1. Transaction context (if in transaction)
+     * 2. Direct property
+     * 3. Context variables (if middleware injected)
      */
     protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
@@ -321,7 +222,9 @@ declare abstract class DrizzleCreateEndpoint<E extends Env = Env, M extends Meta
  */
 declare abstract class DrizzleReadEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ReadEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     read(lookupValue: string, additionalFilters?: Record<string, string>, includeOptions?: IncludeOptions): Promise<ModelObject<M['model']> | null>;
@@ -335,7 +238,7 @@ declare abstract class DrizzleReadEndpoint<E extends Env = Env, M extends MetaIn
  */
 declare abstract class DrizzleUpdateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends UpdateEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
     /**
      * Whether to wrap update and nested operations in a transaction.
      * When true, the entire update operation (including nested writes) will be atomic.
@@ -344,9 +247,7 @@ declare abstract class DrizzleUpdateEndpoint<E extends Env = Env, M extends Meta
     protected useTransaction: boolean;
     /** Current transaction context (set during transaction execution) */
     private _tx?;
-    /**
-     * Gets the database instance to use (transaction or main db).
-     */
+    /** Gets the database instance from property, transaction, or context */
     protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
@@ -377,7 +278,7 @@ declare abstract class DrizzleUpdateEndpoint<E extends Env = Env, M extends Meta
  */
 declare abstract class DrizzleDeleteEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends DeleteEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
     /**
      * Whether to wrap delete and cascade operations in a transaction.
      * When true, the entire delete operation (including cascade deletes) will be atomic.
@@ -386,9 +287,7 @@ declare abstract class DrizzleDeleteEndpoint<E extends Env = Env, M extends Meta
     protected useTransaction: boolean;
     /** Current transaction context (set during transaction execution) */
     private _tx?;
-    /**
-     * Gets the database instance to use (transaction or main db).
-     */
+    /** Gets the database instance from property, transaction, or context */
     protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
@@ -429,7 +328,9 @@ declare abstract class DrizzleDeleteEndpoint<E extends Env = Env, M extends Meta
  */
 declare abstract class DrizzleListEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ListEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     list(filters: ListFilters): Promise<PaginatedResult<ModelObject<M['model']>>>;
@@ -443,7 +344,7 @@ declare abstract class DrizzleListEndpoint<E extends Env = Env, M extends MetaIn
  */
 declare abstract class DrizzleRestoreEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends RestoreEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
     /**
      * Whether to wrap restore operation in a transaction.
      * Useful when combined with hooks that perform additional operations.
@@ -452,9 +353,7 @@ declare abstract class DrizzleRestoreEndpoint<E extends Env = Env, M extends Met
     protected useTransaction: boolean;
     /** Current transaction context (set during transaction execution) */
     private _tx?;
-    /**
-     * Gets the database instance to use (transaction or main db).
-     */
+    /** Gets the database instance from property, transaction, or context */
     protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
@@ -464,13 +363,16 @@ declare abstract class DrizzleRestoreEndpoint<E extends Env = Env, M extends Met
      */
     handle(): Promise<Response>;
 }
+
 /**
  * Drizzle Batch Create endpoint.
  * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
  */
 declare abstract class DrizzleBatchCreateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchCreateEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     batchCreate(items: Partial<ModelObject<M['model']>>[]): Promise<ModelObject<M['model']>[]>;
 }
@@ -482,7 +384,9 @@ declare abstract class DrizzleBatchCreateEndpoint<E extends Env = Env, M extends
  */
 declare abstract class DrizzleBatchUpdateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchUpdateEndpoint<E, M> {
     /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     batchUpdate(items: BatchUpdateItem<ModelObject<M['model']>>[]): Promise<{
@@ -497,8 +401,10 @@ declare abstract class DrizzleBatchUpdateEndpoint<E extends Env = Env, M extends
  * Supports soft delete when the model has `softDelete` configured.
  */
 declare abstract class DrizzleBatchDeleteEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchDeleteEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     batchDelete(ids: string[]): Promise<{
@@ -513,8 +419,10 @@ declare abstract class DrizzleBatchDeleteEndpoint<E extends Env = Env, M extends
  * Only works with models that have `softDelete` enabled.
  */
 declare abstract class DrizzleBatchRestoreEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchRestoreEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     batchRestore(ids: string[]): Promise<{
@@ -522,13 +430,16 @@ declare abstract class DrizzleBatchRestoreEndpoint<E extends Env = Env, M extend
         notFound: string[];
     }>;
 }
+
 /**
  * Drizzle Upsert endpoint.
  * Creates a record if it doesn't exist, updates it if it does.
  */
 declare abstract class DrizzleUpsertEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends UpsertEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     findExisting(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']> | null>;
@@ -551,8 +462,10 @@ declare abstract class DrizzleUpsertEndpoint<E extends Env = Env, M extends Meta
  * Drizzle Batch Upsert endpoint.
  */
 declare abstract class DrizzleBatchUpsertEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchUpsertEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     findExisting(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']> | null>;
@@ -586,8 +499,10 @@ declare abstract class DrizzleBatchUpsertEndpoint<E extends Env = Env, M extends
  * Lists all versions for a record.
  */
 declare abstract class DrizzleVersionHistoryEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends VersionHistoryEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     protected recordExists(lookupValue: string): Promise<boolean>;
@@ -609,8 +524,10 @@ declare abstract class DrizzleVersionCompareEndpoint<E extends Env = Env, M exte
  * Rolls back a record to a previous version.
  */
 declare abstract class DrizzleVersionRollbackEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends VersionRollbackEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     rollback(lookupValue: string, versionData: Record<string, unknown>, newVersion: number): Promise<ModelObject<M['model']>>;
@@ -620,8 +537,10 @@ declare abstract class DrizzleVersionRollbackEndpoint<E extends Env = Env, M ext
  * Computes aggregations (COUNT, SUM, AVG, MIN, MAX) with GROUP BY support.
  */
 declare abstract class DrizzleAggregateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends AggregateEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     aggregate(options: AggregateOptions): Promise<AggregateResult>;
@@ -655,8 +574,10 @@ declare abstract class DrizzleAggregateEndpoint<E extends Env = Env, M extends M
  * ```
  */
 declare abstract class DrizzleSearchEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends SearchEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     /**
      * Enable PostgreSQL native full-text search.
      * When true and vectorColumn is set, uses tsvector/tsquery.
@@ -684,8 +605,10 @@ declare abstract class DrizzleSearchEndpoint<E extends Env = Env, M extends Meta
  * Exports data in CSV or JSON format with support for filtering and field selection.
  */
 declare abstract class DrizzleExportEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ExportEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     list(filters: ListFilters): Promise<PaginatedResult<ModelObject<M['model']>>>;
@@ -695,8 +618,10 @@ declare abstract class DrizzleExportEndpoint<E extends Env = Env, M extends Meta
  * Imports data from CSV or JSON with support for create and upsert modes.
  */
 declare abstract class DrizzleImportEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ImportEndpoint<E, M> {
-    /** Drizzle database instance */
-    abstract db: DrizzleDatabase;
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /** Gets the database instance from property or context. */
+    protected getDb(): DrizzleDatabase;
     protected getTable(): Table;
     protected getColumn(field: string): Column;
     /**
@@ -713,4 +638,252 @@ declare abstract class DrizzleImportEndpoint<E extends Env = Env, M extends Meta
     update(existing: ModelObject<M['model']>, data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
 }
 
-export { DrizzleAggregateEndpoint, DrizzleBatchCreateEndpoint, DrizzleBatchDeleteEndpoint, DrizzleBatchRestoreEndpoint, DrizzleBatchUpdateEndpoint, DrizzleBatchUpsertEndpoint, DrizzleCreateEndpoint, type DrizzleDB, type DrizzleDatabase, DrizzleDeleteEndpoint, DrizzleExportEndpoint, DrizzleImportEndpoint, DrizzleListEndpoint, DrizzleReadEndpoint, DrizzleRestoreEndpoint, type DrizzleSchemas, DrizzleSearchEndpoint, DrizzleUpdateEndpoint, DrizzleUpsertEndpoint, DrizzleVersionCompareEndpoint, DrizzleVersionHistoryEndpoint, DrizzleVersionReadEndpoint, DrizzleVersionRollbackEndpoint, createDrizzleSchemas, createDrizzleSchemasAsync, createInsertSchema, createSelectSchema, createUpdateSchema, isDrizzleZodAvailable };
+/**
+ * Return type of createDrizzleCrud factory function.
+ * Provides type-safe base classes for all CRUD operations.
+ */
+interface DrizzleCrudClasses<M extends MetaInput> {
+    Create: typeof DrizzleCreateEndpoint<Env, M>;
+    Read: typeof DrizzleReadEndpoint<Env, M>;
+    Update: typeof DrizzleUpdateEndpoint<Env, M>;
+    Delete: typeof DrizzleDeleteEndpoint<Env, M>;
+    List: typeof DrizzleListEndpoint<Env, M>;
+    Restore: typeof DrizzleRestoreEndpoint<Env, M>;
+    Upsert: typeof DrizzleUpsertEndpoint<Env, M>;
+    BatchCreate: typeof DrizzleBatchCreateEndpoint<Env, M>;
+    BatchUpdate: typeof DrizzleBatchUpdateEndpoint<Env, M>;
+    BatchDelete: typeof DrizzleBatchDeleteEndpoint<Env, M>;
+    BatchRestore: typeof DrizzleBatchRestoreEndpoint<Env, M>;
+    BatchUpsert: typeof DrizzleBatchUpsertEndpoint<Env, M>;
+}
+/**
+ * Creates a set of Drizzle CRUD endpoint base classes with db and meta pre-configured.
+ * This is the cleanest pattern - no need to set `_meta` or `db` in your classes.
+ *
+ * @param db - Your Drizzle database instance
+ * @param meta - The meta object (from defineMeta)
+ * @returns Object with Create, Read, Update, Delete, List base classes
+ *
+ * @example
+ * ```ts
+ * import { createDrizzleCrud } from 'hono-crud/adapters/drizzle';
+ *
+ * const projectMeta = defineMeta({ model: ProjectModel, fields: projectSchemas.insert });
+ * const Project = createDrizzleCrud(db, projectMeta);
+ *
+ * // Now define endpoints with minimal boilerplate:
+ * class ProjectCreate extends Project.Create {
+ *   schema = { tags: ["Projects"], summary: "Create a new project" };
+ * }
+ *
+ * class ProjectList extends Project.List {
+ *   schema = { tags: ["Projects"], summary: "List all projects" };
+ *   protected searchFields = ["name", "clientName"];
+ *   protected filterFields = ["status"];
+ * }
+ * ```
+ */
+declare function createDrizzleCrud<M extends MetaInput>(db: DrizzleDatabaseConstraint, meta: M): DrizzleCrudClasses<M>;
+/**
+ * Drizzle adapter bundle for use with defineEndpoints.
+ *
+ * Note: When using DrizzleAdapters with defineEndpoints, you need to provide
+ * your own base classes that extend the Drizzle endpoint classes and include
+ * the `db` property. The config-based API cannot inject the database instance.
+ *
+ * @example
+ * ```ts
+ * import { defineEndpoints } from 'hono-crud';
+ * import { DrizzleAdapters } from 'hono-crud/adapters/drizzle';
+ *
+ * // Create custom adapters with db injected
+ * const MyDrizzleAdapters = {
+ *   CreateEndpoint: class extends DrizzleCreateEndpoint { db = myDb; },
+ *   ListEndpoint: class extends DrizzleListEndpoint { db = myDb; },
+ *   ReadEndpoint: class extends DrizzleReadEndpoint { db = myDb; },
+ *   UpdateEndpoint: class extends DrizzleUpdateEndpoint { db = myDb; },
+ *   DeleteEndpoint: class extends DrizzleDeleteEndpoint { db = myDb; },
+ * };
+ *
+ * const userEndpoints = defineEndpoints({ meta: userMeta, ... }, MyDrizzleAdapters);
+ * ```
+ */
+declare const DrizzleAdapters: AdapterBundle;
+
+/**
+ * Drizzle-Zod schema utilities.
+ *
+ * This module provides helpers for generating Zod schemas from Drizzle tables
+ * using drizzle-zod. This allows automatic schema generation for CRUD operations.
+ *
+ * Note: drizzle-zod is an optional peer dependency. These utilities will only
+ * work if drizzle-zod is installed.
+ *
+ * @example
+ * ```ts
+ * import { pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+ * import { createDrizzleSchemas } from 'hono-crud/adapters/drizzle';
+ *
+ * const users = pgTable('users', {
+ *   id: uuid('id').primaryKey().defaultRandom(),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ *   createdAt: timestamp('created_at').defaultNow(),
+ * });
+ *
+ * const { select: UserSchema, insert: CreateUserSchema } = createDrizzleSchemas(users);
+ * ```
+ */
+
+/**
+ * Duck-typed interface for Drizzle tables.
+ * This allows compatibility across different drizzle-orm versions and package installations.
+ */
+type DrizzleTable = {
+    _: {
+        name: string;
+        columns: Record<string, any>;
+    };
+};
+/**
+ * Re-export createSelectSchema from drizzle-zod.
+ * Creates a Zod schema for SELECT queries (all columns as required/optional based on table definition).
+ *
+ * @param table - Drizzle table definition
+ * @param refine - Optional refinements for specific columns
+ * @returns Zod schema for the table's select type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createSelectSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const UserSchema = createSelectSchema(users);
+ * type User = z.infer<typeof UserSchema>;
+ * ```
+ */
+declare function createSelectSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Re-export createInsertSchema from drizzle-zod.
+ * Creates a Zod schema for INSERT queries (columns with defaults become optional).
+ *
+ * @param table - Drizzle table definition
+ * @param refine - Optional refinements for specific columns
+ * @returns Zod schema for the table's insert type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createInsertSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const CreateUserSchema = createInsertSchema(users);
+ * type CreateUser = z.infer<typeof CreateUserSchema>;
+ * ```
+ */
+declare function createInsertSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Re-export createUpdateSchema from drizzle-zod (if available).
+ * Creates a Zod schema for UPDATE queries (all columns become optional).
+ *
+ * Note: createUpdateSchema may not be available in older versions of drizzle-zod.
+ * Use createInsertSchema(table).partial() as an alternative.
+ *
+ * @param table - Drizzle table definition
+ * @param refine - Optional refinements for specific columns
+ * @returns Zod schema for the table's update type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createUpdateSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const UpdateUserSchema = createUpdateSchema(users);
+ * type UpdateUser = z.infer<typeof UpdateUserSchema>;
+ * ```
+ */
+declare function createUpdateSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Result of createDrizzleSchemas helper.
+ */
+interface DrizzleSchemas {
+    /** Schema for SELECT queries (full record) */
+    select: z.ZodObject<Record<string, z.ZodTypeAny>>;
+    /** Schema for INSERT queries (required fields only) */
+    insert: z.ZodObject<Record<string, z.ZodTypeAny>>;
+    /** Schema for UPDATE queries (all fields optional) */
+    update: z.ZodObject<Record<string, z.ZodTypeAny>>;
+}
+/**
+ * Creates all three common schemas (select, insert, update) for a Drizzle table.
+ *
+ * This is a convenience helper that generates:
+ * - `select`: Full record schema for reading data
+ * - `insert`: Schema for creating new records (with date coercion for JSON input)
+ * - `update`: Partial schema for updating records (with date coercion for JSON input)
+ *
+ * Date coercion is automatically applied to timestamp/date columns, allowing
+ * both Date objects and ISO 8601 date strings as input values.
+ *
+ * @param table - Drizzle table definition
+ * @param options - Optional configuration
+ * @param options.insertRefine - Refinements for insert schema
+ * @param options.selectRefine - Refinements for select schema
+ * @param options.updateRefine - Refinements for update schema
+ * @param options.coerceDates - Whether to coerce date strings to Date objects (default: true)
+ * @returns Object containing select, insert, and update schemas
+ *
+ * @example
+ * ```ts
+ * import { pgTable, text, uuid } from 'drizzle-orm/pg-core';
+ * import { createDrizzleSchemas, defineModel, defineMeta } from 'hono-crud/adapters/drizzle';
+ * import { z } from 'zod';
+ *
+ * const users = pgTable('users', {
+ *   id: uuid('id').primaryKey().defaultRandom(),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ * });
+ *
+ * // Generate schemas from table
+ * const schemas = createDrizzleSchemas(users, {
+ *   insertRefine: {
+ *     email: z.string().email(), // Add email validation
+ *   },
+ * });
+ *
+ * // Use with hono-crud model
+ * const UserModel = defineModel({
+ *   tableName: 'users',
+ *   schema: schemas.select,
+ *   primaryKeys: ['id'],
+ *   table: users,
+ * });
+ * ```
+ */
+declare function createDrizzleSchemas<T extends DrizzleTable>(table: T, options?: {
+    insertRefine?: Record<string, z.ZodTypeAny>;
+    selectRefine?: Record<string, z.ZodTypeAny>;
+    updateRefine?: Record<string, z.ZodTypeAny>;
+    /** Whether to coerce date strings to Date objects. Default: true */
+    coerceDates?: boolean;
+}): DrizzleSchemas;
+/**
+ * Async version of createDrizzleSchemas that handles lazy loading.
+ * Use this if you're not sure drizzle-zod is already loaded.
+ *
+ * @param table - Drizzle table definition
+ * @param options - Optional configuration
+ * @returns Promise resolving to schemas object
+ */
+declare function createDrizzleSchemasAsync<T extends DrizzleTable>(table: T, options?: {
+    insertRefine?: Record<string, z.ZodTypeAny>;
+    selectRefine?: Record<string, z.ZodTypeAny>;
+    updateRefine?: Record<string, z.ZodTypeAny>;
+}): Promise<DrizzleSchemas>;
+/**
+ * Checks if drizzle-zod is available.
+ * @returns true if drizzle-zod can be imported
+ */
+declare function isDrizzleZodAvailable(): boolean;
+
+export { type Database, DrizzleAdapters, DrizzleAggregateEndpoint, DrizzleBatchCreateEndpoint, DrizzleBatchDeleteEndpoint, DrizzleBatchRestoreEndpoint, DrizzleBatchUpdateEndpoint, DrizzleBatchUpsertEndpoint, DrizzleCreateEndpoint, type DrizzleCrudClasses, type DrizzleDB, type DrizzleDatabase, type DrizzleDatabaseConstraint, DrizzleDeleteEndpoint, type DrizzleEnv, DrizzleExportEndpoint, DrizzleImportEndpoint, DrizzleListEndpoint, DrizzleReadEndpoint, DrizzleRestoreEndpoint, type DrizzleSchemas, DrizzleSearchEndpoint, DrizzleUpdateEndpoint, DrizzleUpsertEndpoint, DrizzleVersionCompareEndpoint, DrizzleVersionHistoryEndpoint, DrizzleVersionReadEndpoint, DrizzleVersionRollbackEndpoint, type QueryBuilder, batchLoadDrizzleRelations, buildWhereCondition, cast, createDrizzleCrud, createDrizzleSchemas, createDrizzleSchemasAsync, createInsertSchema, createSelectSchema, createUpdateSchema, getColumn, getTable, isDrizzleZodAvailable, loadDrizzleRelation, loadDrizzleRelations };