@hono-crud/drizzle 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kauan Guesser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @hono-crud/drizzle
+
+Drizzle ORM CRUD adapter for [hono-crud](https://github.com/kshdotdev/hono-crud).
+
+## Install
+
+```bash
+npm install @hono-crud/drizzle hono-crud hono zod drizzle-orm drizzle-zod
+```
+
+## Usage
+
+```ts
+import { fromHono, registerCrud, defineModel, defineMeta } from 'hono-crud';
+import {
+  DrizzleCreateEndpoint,
+  DrizzleReadEndpoint,
+  DrizzleListEndpoint,
+  type DrizzleDatabase,
+} from '@hono-crud/drizzle';
+
+const app = fromHono(new Hono());
+registerCrud(app, '/users', {
+  model,
+  meta,
+  endpoints: { create: DrizzleCreateEndpoint, read: DrizzleReadEndpoint, list: DrizzleListEndpoint },
+});
+```
+
+Exports `DrizzleAdapters`, the `Drizzle*Endpoint` classes, `createDrizzleCrud`, `createDrizzleSchemas`, and the `DrizzleDatabase` type.

package/dist/index.d.ts

@@ -0,0 +1,991 @@
+import { Table, SQL, Column } from 'drizzle-orm';
+import { MetaInput, IncludeOptions, FilterCondition, RelationConfig, CreateEndpoint, ModelObject, ReadEndpoint, UpdateEndpoint, NestedUpdateInput, NestedWriteResult, DeleteEndpoint, ListEndpoint, ListFilters, PaginatedResult, RestoreEndpoint, BatchCreateEndpoint, BatchDeleteEndpoint, BatchRestoreEndpoint, BatchUpdateEndpoint, BatchUpdateItem, AggregateEndpoint, AggregateOptions, AggregateResult, BatchUpsertEndpoint, CloneEndpoint, UpsertEndpoint, SearchEndpoint, SearchOptions, SearchResult, ExportEndpoint, ImportEndpoint, VersionCompareEndpoint, VersionHistoryEndpoint, VersionReadEndpoint, VersionRollbackEndpoint, AdapterBundle } from 'hono-crud/internal';
+import { Env } from 'hono';
+import { z } from 'zod';
+
+/**
+ * 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>;
+}
+/**
+ * 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 cast<T>(instance: T): Database;
+/**
+ * Base constraint for Drizzle database types.
+ * Your database type must have select, insert, update, delete, and transaction methods.
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/postgres-js';
+ * import * as schema from './schema';
+ *
+ * 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!
+ * }
+ * ```
+ */
+interface DrizzleDatabaseConstraint {
+    select: unknown;
+    insert: unknown;
+    update: unknown;
+    delete: unknown;
+    transaction: unknown;
+}
+/**
+ * @deprecated Pass your database type as a generic parameter instead
+ */
+type DrizzleDatabase = DrizzleDatabaseConstraint;
+/**
+ * @deprecated Pass your database type as a generic parameter instead
+ */
+type DrizzleDB = DrizzleDatabaseConstraint;
+/**
+ * Drizzle SQL dialect identifier used to branch dialect-specific behavior
+ * (e.g. native upsert syntax: `ON CONFLICT DO UPDATE` for sqlite/pg vs
+ * `ON DUPLICATE KEY UPDATE` for mysql).
+ *
+ * The default for {@link createDrizzleCrud} is `'sqlite'` (preserves
+ * pre-existing portable behavior). Set explicitly when targeting PostgreSQL
+ * or MySQL to enable the appropriate code paths.
+ */
+type DrizzleDialect = 'sqlite' | 'pg' | 'mysql';
+/**
+ * Type helper for defining Hono Env with database in Variables.
+ * Use this when injecting the database via middleware.
+ *
+ * @example
+ * ```ts
+ * import { DrizzleEnv } from 'hono-crud/adapters/drizzle';
+ *
+ * type AppEnv = DrizzleEnv<typeof db>;
+ *
+ * const app = new Hono<AppEnv>();
+ *
+ * app.use('*', async (c, next) => {
+ *   c.set('db', db);
+ *   await next();
+ * });
+ *
+ * // Endpoints can now access db from context automatically
+ * class ProjectCreate extends DrizzleCreateEndpoint<AppEnv, typeof projectMeta> {
+ *   _meta = projectMeta;
+ *   // No db property needed - comes from context!
+ * }
+ * ```
+ */
+type DrizzleEnv<DB = DrizzleDatabaseConstraint> = {
+    Variables: {
+        db: DB;
+    };
+};
+/**
+ * Gets the Drizzle table from the model.
+ */
+declare function getTable<M extends MetaInput>(meta: M): Table;
+/**
+ * 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
+ */
+declare function getColumn(table: Table, field: string): Column;
+/**
+ * Loads related records for a given item using Drizzle queries.
+ */
+declare function loadDrizzleRelation<T extends Record<string, unknown>>(db: DrizzleDatabase, item: T, relationName: string, relationConfig: RelationConfig<Table>): Promise<T>;
+/**
+ * Loads all requested relations for an item.
+ * Note: For multiple items, use `batchLoadDrizzleRelations` to avoid N+1 queries.
+ */
+declare function loadDrizzleRelations<T extends Record<string, unknown>, M extends MetaInput>(db: DrizzleDatabase, item: T, meta: M, includeOptions?: IncludeOptions): Promise<T>;
+/**
+ * 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().
+ */
+declare function batchLoadDrizzleRelations<T extends Record<string, unknown>, M extends MetaInput>(db: DrizzleDatabase, items: T[], meta: M, includeOptions?: IncludeOptions): Promise<T[]>;
+/**
+ * Builds a where condition from filter conditions.
+ */
+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;
+ * }
+ *
+ * // 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.
+     * 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.
+     * @default false
+     */
+    protected useTransaction: boolean;
+    /** Current transaction context (set during transaction execution) */
+    protected _tx?: DrizzleDatabase;
+    /**
+     * 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;
+    /**
+     * Gets a related table from the relation config.
+     */
+    protected getRelatedTable(relationConfig: RelationConfig): Table | undefined;
+    create(data: ModelObject<M['model']>, tx?: unknown): Promise<ModelObject<M['model']>>;
+    /**
+     * Creates nested related records.
+     */
+    protected createNested(parentId: string | number, relationName: string, relationConfig: RelationConfig, data: unknown, tx?: unknown): Promise<unknown[]>;
+    /**
+     * Override handle to wrap in transaction when useTransaction is true.
+     */
+    handle(): Promise<Response>;
+}
+/**
+ * Drizzle Read endpoint.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Supports soft delete filtering when the model has `softDelete` configured.
+ * Soft-deleted records are excluded by default.
+ *
+ * Supports relation includes via `?include=relation1,relation2`.
+ */
+declare abstract class DrizzleReadEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ReadEndpoint<E, M> {
+    /** Drizzle database instance */
+    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>;
+}
+/**
+ * Drizzle Update endpoint.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Supports soft delete filtering when the model has `softDelete` configured.
+ * Soft-deleted records cannot be updated.
+ */
+declare abstract class DrizzleUpdateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends UpdateEndpoint<E, M> {
+    /** Drizzle database instance */
+    db?: DrizzleDatabase;
+    /**
+     * Whether to wrap update and nested operations in a transaction.
+     * When true, the entire update operation (including nested writes) will be atomic.
+     * @default false
+     */
+    protected useTransaction: boolean;
+    /** Current transaction context (set during transaction execution) */
+    protected _tx?: DrizzleDatabase;
+    /** Gets the database instance from property, transaction, or context */
+    protected getDb(): DrizzleDatabase;
+    protected getTable(): Table;
+    protected getColumn(field: string): Column;
+    /**
+     * Gets a related table from the relation config.
+     */
+    protected getRelatedTable(relationConfig: RelationConfig): Table | undefined;
+    /**
+     * Finds an existing record for audit logging.
+     */
+    protected findExisting(lookupValue: string, additionalFilters?: Record<string, string>, tx?: unknown): Promise<ModelObject<M['model']> | null>;
+    update(lookupValue: string, data: Partial<ModelObject<M['model']>>, additionalFilters?: Record<string, string>, tx?: unknown): Promise<ModelObject<M['model']> | null>;
+    /**
+     * Processes nested write operations.
+     */
+    protected processNestedWrites(parentId: string | number, relationName: string, relationConfig: RelationConfig, operations: NestedUpdateInput, tx?: unknown): Promise<NestedWriteResult>;
+    /**
+     * Override handle to wrap in transaction when useTransaction is true.
+     */
+    handle(): Promise<Response>;
+}
+/**
+ * Drizzle Delete endpoint.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Supports soft delete when the model has `softDelete` configured.
+ * When soft delete is enabled, sets the deletion timestamp instead of removing the record.
+ */
+declare abstract class DrizzleDeleteEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends DeleteEndpoint<E, M> {
+    /** Drizzle database instance */
+    db?: DrizzleDatabase;
+    /**
+     * Whether to wrap delete and cascade operations in a transaction.
+     * When true, the entire delete operation (including cascade deletes) will be atomic.
+     * @default false
+     */
+    protected useTransaction: boolean;
+    /** Current transaction context (set during transaction execution) */
+    protected _tx?: DrizzleDatabase;
+    /** Gets the database instance from property, transaction, or context */
+    protected getDb(): DrizzleDatabase;
+    protected getTable(): Table;
+    protected getColumn(field: string): Column;
+    /**
+     * Gets a related table from the relation config.
+     */
+    protected getRelatedTable(relationConfig: RelationConfig): Table | undefined;
+    /**
+     * Finds a record without deleting it (for constraint checks).
+     */
+    findForDelete(lookupValue: string, additionalFilters?: Record<string, string>, tx?: unknown): Promise<ModelObject<M['model']> | null>;
+    delete(lookupValue: string, additionalFilters?: Record<string, string>, tx?: unknown): Promise<ModelObject<M['model']> | null>;
+    /**
+     * Counts related records for restrict check.
+     */
+    protected countRelated(parentId: string | number, _relationName: string, relationConfig: RelationConfig, tx?: unknown): Promise<number>;
+    /**
+     * Deletes related records for cascade delete.
+     */
+    protected deleteRelated(parentId: string | number, _relationName: string, relationConfig: RelationConfig, tx?: unknown): Promise<number>;
+    /**
+     * Sets foreign key to null for related records.
+     */
+    protected nullifyRelated(parentId: string | number, _relationName: string, relationConfig: RelationConfig, tx?: unknown): Promise<number>;
+    /**
+     * Override handle to wrap in transaction when useTransaction is true.
+     */
+    handle(): Promise<Response>;
+}
+/**
+ * Drizzle List endpoint with filtering, sorting, and pagination.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Supports soft delete filtering when the model has `softDelete` configured:
+ * - By default, soft-deleted records are excluded
+ * - Use `?withDeleted=true` to include deleted records
+ * - Use `?onlyDeleted=true` to show only deleted records
+ */
+declare abstract class DrizzleListEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends ListEndpoint<E, M> {
+    /** Drizzle database instance */
+    db?: DrizzleDatabase;
+    /**
+     * SQL dialect of the underlying Drizzle database.
+     *
+     * Drives the substring-match function emitted on the `?search=` path:
+     * `INSTR` for sqlite, `POSITION` for pg, `LOCATE` for mysql — matching
+     * how the dedicated search endpoint (`DrizzleSearchEndpoint`) and the
+     * export endpoint (`DrizzleExportEndpoint`) emit search SQL. Set via
+     * {@link createDrizzleCrud}'s `options.dialect`, or override in your
+     * subclass. Defaults to `'sqlite'` for backward compatibility with
+     * pre-existing portable behavior.
+     *
+     * See {@link DrizzleUpsertEndpoint.dialect} for full semantics.
+     */
+    protected dialect: DrizzleDialect;
+    /** 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']>>>;
+}
+/**
+ * Drizzle Restore endpoint for un-deleting soft-deleted records.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Only works with models that have `softDelete` enabled.
+ * Sets the deletion timestamp back to null.
+ */
+declare abstract class DrizzleRestoreEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends RestoreEndpoint<E, M> {
+    /** Drizzle database instance */
+    db?: DrizzleDatabase;
+    /**
+     * Whether to wrap restore operation in a transaction.
+     * Useful when combined with hooks that perform additional operations.
+     * @default false
+     */
+    protected useTransaction: boolean;
+    /** Current transaction context (set during transaction execution) */
+    protected _tx?: DrizzleDatabase;
+    /** Gets the database instance from property, transaction, or context */
+    protected getDb(): DrizzleDatabase;
+    protected getTable(): Table;
+    protected getColumn(field: string): Column;
+    restore(lookupValue: string, additionalFilters?: Record<string, string>, tx?: unknown): Promise<ModelObject<M['model']> | null>;
+    /**
+     * Override handle to wrap in transaction when useTransaction is true.
+     */
+    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 */
+    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']>[]>;
+}
+/**
+ * Drizzle Batch Update endpoint.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * Supports soft delete filtering (cannot update deleted records).
+ */
+declare abstract class DrizzleBatchUpdateEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchUpdateEndpoint<E, M> {
+    /** Drizzle database instance */
+    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<{
+        updated: ModelObject<M['model']>[];
+        notFound: string[];
+    }>;
+}
+/**
+ * Drizzle Batch Delete endpoint.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * 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. 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<{
+        deleted: ModelObject<M['model']>[];
+        notFound: string[];
+    }>;
+}
+/**
+ * Drizzle Batch Restore endpoint for un-deleting soft-deleted records.
+ * Works with any Drizzle dialect (PostgreSQL, MySQL, SQLite).
+ *
+ * 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. 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<{
+        restored: ModelObject<M['model']>[];
+        notFound: string[];
+    }>;
+}
+
+/**
+ * Emit a dialect-correct case-insensitive substring-match SQL expression.
+ *
+ * Replaces the previous `LOWER(col) LIKE LOWER('%needle%') ESCAPE '\\'`
+ * approach: by using the native substring-position function for each
+ * dialect, the needle is never injected into a pattern, so LIKE
+ * wildcards (`%`, `_`) and the LIKE escape character lose their
+ * special meaning entirely — no wildcard surface means no escape
+ * needed.
+ *
+ * Dialect mapping:
+ *   - `'sqlite'` → `INSTR(LOWER(col), LOWER(needle)) > 0`
+ *   - `'pg'`     → `POSITION(LOWER(needle) IN LOWER(col)) > 0`
+ *   - `'mysql'`  → `LOCATE(LOWER(needle), LOWER(col)) > 0`
+ *
+ * All three return a 1-based position (or 0 for "not found"), so
+ * `> 0` is the dialect-agnostic predicate that means "needle is a
+ * substring of col".
+ */
+declare function substringMatch(col: Column | SQL, needle: string, dialect: DrizzleDialect): SQL;
+/**
+ * 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. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /**
+     * SQL dialect of the underlying Drizzle database.
+     *
+     * Used to branch dialect-specific behavior — currently the native upsert
+     * path (`ON CONFLICT DO UPDATE` for sqlite/pg vs `ON DUPLICATE KEY UPDATE`
+     * for mysql). Set via {@link createDrizzleCrud}'s `options.dialect`, or
+     * override in your subclass. Defaults to `'sqlite'` for backward
+     * compatibility with pre-existing portable behavior.
+     */
+    protected dialect: DrizzleDialect;
+    /** 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>;
+    create(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+    update(existing: ModelObject<M['model']>, data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+    /**
+     * Performs a native database upsert using ON CONFLICT DO UPDATE (PostgreSQL/SQLite)
+     * or ON DUPLICATE KEY UPDATE (MySQL).
+     *
+     * Note: This method cannot accurately determine if the record was created or updated.
+     * The `created` flag is set to `false` by default. If you need accurate create/update
+     * tracking, use the standard upsert pattern (useNativeUpsert = false).
+     */
+    protected nativeUpsert(data: Partial<ModelObject<M['model']>>, _tx?: unknown): Promise<{
+        data: ModelObject<M['model']>;
+        created: boolean;
+    }>;
+}
+/**
+ * Drizzle Batch Upsert endpoint.
+ */
+declare abstract class DrizzleBatchUpsertEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends BatchUpsertEndpoint<E, M> {
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /**
+     * SQL dialect of the underlying Drizzle database. See
+     * {@link DrizzleUpsertEndpoint.dialect} for full semantics.
+     */
+    protected dialect: DrizzleDialect;
+    /** 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>;
+    create(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+    update(existing: ModelObject<M['model']>, data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+    /**
+     * Performs a native database batch upsert using ON CONFLICT DO UPDATE (PostgreSQL/SQLite)
+     * or ON DUPLICATE KEY UPDATE (MySQL).
+     *
+     * Note: This method cannot accurately determine which records were created vs updated.
+     * All records are marked as `created: false`. If you need accurate tracking,
+     * use the standard batch upsert pattern (useNativeUpsert = false).
+     */
+    protected nativeBatchUpsert(items: Partial<ModelObject<M['model']>>[], _tx?: unknown): Promise<{
+        items: Array<{
+            data: ModelObject<M['model']>;
+            created: boolean;
+            index: number;
+        }>;
+        createdCount: number;
+        updatedCount: number;
+        totalCount: number;
+        errors?: Array<{
+            index: number;
+            error: string;
+        }>;
+    }>;
+}
+/**
+ * Drizzle Version History endpoint.
+ * 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. 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>;
+}
+/**
+ * Drizzle Version Read endpoint.
+ * Gets a specific version of a record.
+ */
+declare abstract class DrizzleVersionReadEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends VersionReadEndpoint<E, M> {
+}
+/**
+ * Drizzle Version Compare endpoint.
+ * Compares two versions of a record.
+ */
+declare abstract class DrizzleVersionCompareEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends VersionCompareEndpoint<E, M> {
+}
+/**
+ * Drizzle Version Rollback endpoint.
+ * 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. 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']>>;
+}
+/**
+ * Drizzle Aggregate endpoint.
+ * 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. 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>;
+}
+/**
+ * Drizzle Search endpoint.
+ * Provides full-text search with relevance scoring and highlighting.
+ *
+ * For PostgreSQL, this can leverage native tsvector/tsquery for better performance.
+ * For SQLite/MySQL/PostgreSQL non-vector mode, it falls back to dialect-native
+ * substring-position search (INSTR/POSITION/LOCATE) with in-memory scoring.
+ *
+ * Features:
+ * - PostgreSQL: Uses to_tsvector() and plainto_tsquery() for native full-text search
+ * - Fallback: dialect-native substring match with in-memory scoring
+ * - Configurable field weights
+ * - Search modes: 'any' (OR), 'all' (AND), 'phrase' (exact)
+ * - Highlighted snippets
+ * - Combined with standard list filters
+ *
+ * @example
+ * ```ts
+ * class ArticleSearch extends DrizzleSearchEndpoint<Env, typeof articleMeta> {
+ *   _meta = articleMeta;
+ *   db = db;
+ *   schema = { tags: ['Articles'], summary: 'Search articles' };
+ *
+ *   protected searchFields = ['title', 'content', 'tags'];
+ *   protected fieldWeights = { title: 2.0, content: 1.0, tags: 1.5 };
+ *   protected filterFields = ['status', 'categoryId'];
+ * }
+ * ```
+ */
+declare abstract class DrizzleSearchEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends SearchEndpoint<E, M> {
+    /** Drizzle database instance. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /**
+     * SQL dialect of the underlying Drizzle database.
+     *
+     * Drives the substring-match function emitted on the fallback search path:
+     * `INSTR` for sqlite, `POSITION` for pg, `LOCATE` for mysql. Set via
+     * {@link createDrizzleCrud}'s `options.dialect`, or override in your
+     * subclass. Defaults to `'sqlite'` for backward compatibility with
+     * pre-existing portable behavior.
+     *
+     * See {@link DrizzleUpsertEndpoint.dialect} for full semantics.
+     */
+    protected dialect: DrizzleDialect;
+    /** 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.
+     * When false, uses substring-position-based search with in-memory scoring.
+     */
+    protected useNativeSearch: boolean;
+    /**
+     * PostgreSQL tsvector column name for native full-text search.
+     * If set and useNativeSearch is true, searches against this column.
+     */
+    protected vectorColumn?: string;
+    /**
+     * PostgreSQL text search configuration (e.g., 'english', 'simple').
+     */
+    protected vectorConfig: string;
+    protected getTable(): Table;
+    protected getColumn(field: string): Column;
+    /**
+     * Performs search on database.
+     */
+    search(options: SearchOptions, filters: ListFilters): Promise<SearchResult<ModelObject<M['model']>>>;
+}
+/**
+ * Drizzle Export endpoint.
+ * 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. Can be undefined if using context injection. */
+    db?: DrizzleDatabase;
+    /**
+     * SQL dialect of the underlying Drizzle database. Drives the
+     * substring-match function emitted on the `?search=` path. See
+     * {@link DrizzleUpsertEndpoint.dialect} for full semantics.
+     */
+    protected dialect: DrizzleDialect;
+    /** 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']>>>;
+}
+/**
+ * Drizzle Import endpoint.
+ * 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. 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;
+    /**
+     * Finds an existing record by upsert keys.
+     */
+    findExisting(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']> | null>;
+    /**
+     * Creates a new record.
+     */
+    create(data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+    /**
+     * Updates an existing record.
+     */
+    update(existing: ModelObject<M['model']>, data: Partial<ModelObject<M['model']>>): Promise<ModelObject<M['model']>>;
+}
+/**
+ * Drizzle Clone endpoint.
+ *
+ * Reads the source row by `lookupField`, lets the base `CloneEndpoint`
+ * strip primary keys + `excludeFromClone` fields and apply body overrides,
+ * then inserts the result with a freshly-generated primary key.
+ *
+ * Soft-deleted source rows are not cloneable — the SELECT predicate adds
+ * `IS NULL` on the soft-delete column when the model has soft-delete
+ * configured.
+ *
+ * Composite-PK note: the base class strips ALL primary keys but this
+ * implementation only fills `primaryKeys[0]` via `generateId()`. Models with
+ * composite primary keys must subclass and override `createClone` to fill the
+ * remaining columns.
+ *
+ * Override `generateId()` to swap UUIDv4 for ULID/snowflake/etc.
+ */
+declare abstract class DrizzleCloneEndpoint<E extends Env = Env, M extends MetaInput = MetaInput> extends CloneEndpoint<E, M> {
+    /** 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;
+    /** Generates the primary-key value for the cloned row. Defaults to UUIDv4. */
+    protected generateId(): string;
+    findSource(lookupValue: string, additionalFilters?: Record<string, string>): Promise<ModelObject<M['model']> | null>;
+    createClone(data: ModelObject<M['model']>): Promise<ModelObject<M['model']>>;
+}
+
+/**
+ * Return type of createDrizzleCrud factory function.
+ * Provides type-safe base classes for all CRUD operations.
+ */
+type ConfiguredDrizzleEndpoint<TEndpoint, M extends MetaInput> = new () => TEndpoint & {
+    _meta: M;
+    db: DrizzleDatabaseConstraint;
+};
+interface DrizzleCrudClasses<M extends MetaInput, E extends Env = Env> {
+    Create: ConfiguredDrizzleEndpoint<DrizzleCreateEndpoint<E, M>, M>;
+    Read: ConfiguredDrizzleEndpoint<DrizzleReadEndpoint<E, M>, M>;
+    Update: ConfiguredDrizzleEndpoint<DrizzleUpdateEndpoint<E, M>, M>;
+    Delete: ConfiguredDrizzleEndpoint<DrizzleDeleteEndpoint<E, M>, M>;
+    List: ConfiguredDrizzleEndpoint<DrizzleListEndpoint<E, M>, M>;
+    Restore: ConfiguredDrizzleEndpoint<DrizzleRestoreEndpoint<E, M>, M>;
+    Upsert: ConfiguredDrizzleEndpoint<DrizzleUpsertEndpoint<E, M>, M>;
+    Search: ConfiguredDrizzleEndpoint<DrizzleSearchEndpoint<E, M>, M>;
+    BatchCreate: ConfiguredDrizzleEndpoint<DrizzleBatchCreateEndpoint<E, M>, M>;
+    BatchUpdate: ConfiguredDrizzleEndpoint<DrizzleBatchUpdateEndpoint<E, M>, M>;
+    BatchDelete: ConfiguredDrizzleEndpoint<DrizzleBatchDeleteEndpoint<E, M>, M>;
+    BatchRestore: ConfiguredDrizzleEndpoint<DrizzleBatchRestoreEndpoint<E, M>, M>;
+    BatchUpsert: ConfiguredDrizzleEndpoint<DrizzleBatchUpsertEndpoint<E, M>, M>;
+}
+/**
+ * Options accepted by {@link createDrizzleCrud}.
+ */
+interface CreateDrizzleCrudOptions {
+    /**
+     * SQL dialect of the Drizzle database. Used to branch dialect-specific
+     * behavior such as native upsert syntax (`ON CONFLICT DO UPDATE` for
+     * `'sqlite'`/`'pg'` vs `ON DUPLICATE KEY UPDATE` for `'mysql'`).
+     *
+     * Defaults to `'sqlite'`, which preserves the pre-existing portable
+     * behavior for callers that don't specify a dialect.
+     *
+     * @default 'sqlite'
+     */
+    dialect?: DrizzleDialect;
+}
+/**
+ * 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)
+ * @param options - Optional factory options. Pass `{ dialect: 'pg' | 'mysql' | 'sqlite' }`
+ *                  to enable dialect-specific code paths (e.g. native upsert syntax).
+ *                  Defaults to `{ dialect: 'sqlite' }`.
+ * @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, { dialect: 'pg' });
+ *
+ * // 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, E extends Env = Env>(db: DrizzleDatabaseConstraint, meta: M, options?: CreateDrizzleCrudOptions): DrizzleCrudClasses<M, E>;
+
+/**
+ * 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 } = await 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, unknown>;
+    };
+};
+/**
+ * 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 Promise resolving to a Zod schema for the table's select type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createSelectSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const UserSchema = await createSelectSchema(users);
+ * type User = z.infer<typeof UserSchema>;
+ * ```
+ */
+declare function createSelectSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): Promise<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 Promise resolving to a Zod schema for the table's insert type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createInsertSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const CreateUserSchema = await createInsertSchema(users);
+ * type CreateUser = z.infer<typeof CreateUserSchema>;
+ * ```
+ */
+declare function createInsertSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): Promise<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 Promise resolving to a Zod schema for the table's update type
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema';
+ * import { createUpdateSchema } from 'hono-crud/adapters/drizzle';
+ *
+ * const UpdateUserSchema = await createUpdateSchema(users);
+ * type UpdateUser = z.infer<typeof UpdateUserSchema>;
+ * ```
+ */
+declare function createUpdateSchema<T extends DrizzleTable>(table: T, refine?: Record<string, z.ZodTypeAny>): Promise<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 Promise resolving to 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 = await 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;
+}): Promise<DrizzleSchemas>;
+/**
+ * Checks if drizzle-zod is available (from cache only).
+ * Returns true only if drizzle-zod has been successfully loaded before.
+ * @returns true if drizzle-zod has been loaded
+ */
+declare function isDrizzleZodAvailable(): boolean;
+
+/**
+ * Drizzle adapter bundle for use with `defineEndpoints`.
+ *
+ * Populates the 11 verbs Drizzle implements natively plus a stub
+ * `CloneEndpoint` (throws on request — subclass to implement).
+ *
+ * @example
+ * ```ts
+ * const endpoints = defineEndpoints({ meta, create: {}, search: { fields: ['name'] } }, DrizzleAdapters);
+ * ```
+ */
+declare const DrizzleAdapters: AdapterBundle;
+
+export { type CreateDrizzleCrudOptions, type Database, DrizzleAdapters, DrizzleAggregateEndpoint, DrizzleBatchCreateEndpoint, DrizzleBatchDeleteEndpoint, DrizzleBatchRestoreEndpoint, DrizzleBatchUpdateEndpoint, DrizzleBatchUpsertEndpoint, DrizzleCloneEndpoint, DrizzleCreateEndpoint, type DrizzleCrudClasses, type DrizzleDB, type DrizzleDatabase, type DrizzleDatabaseConstraint, DrizzleDeleteEndpoint, type DrizzleDialect, type DrizzleEnv, DrizzleExportEndpoint, DrizzleImportEndpoint, DrizzleListEndpoint, DrizzleReadEndpoint, DrizzleRestoreEndpoint, type DrizzleSchemas, DrizzleSearchEndpoint, DrizzleUpdateEndpoint, DrizzleUpsertEndpoint, DrizzleVersionCompareEndpoint, DrizzleVersionHistoryEndpoint, DrizzleVersionReadEndpoint, DrizzleVersionRollbackEndpoint, type QueryBuilder, batchLoadDrizzleRelations, buildWhereCondition, cast, createDrizzleCrud, createDrizzleSchemas, createInsertSchema, createSelectSchema, createUpdateSchema, getColumn, getTable, isDrizzleZodAvailable, loadDrizzleRelation, loadDrizzleRelations, substringMatch };

package/dist/index.js

@@ -0,0 +1,4 @@
+import {getTableColumns,eq,inArray,between,isNull,isNotNull,ilike,like,notInArray,lte,lt,gte,gt,ne as ne$1,sql,and,or,desc,asc}from'drizzle-orm';import {UpsertEndpoint,BatchUpsertEndpoint,VersionHistoryEndpoint,VersionReadEndpoint,VersionCompareEndpoint,VersionRollbackEndpoint,AggregateEndpoint,computeAggregations,SearchEndpoint,searchInMemory,ExportEndpoint,ImportEndpoint,CloneEndpoint,CreateEndpoint,getLogger,ReadEndpoint,UpdateEndpoint,DeleteEndpoint,ListEndpoint,RestoreEndpoint,BatchCreateEndpoint,BatchUpdateEndpoint,BatchDeleteEndpoint,BatchRestoreEndpoint}from'hono-crud/internal';import {z}from'zod';function X(a){return a}function f(a){if(!a.model.table)throw new Error(`Model ${a.model.tableName} does not have a table reference`);return a.model.table}function b(a,e){let t=getTableColumns(a),o=t[e];if(!o)throw new Error(`Column '${e}' not found in table. Available columns: ${Object.keys(t).join(", ")}`);return o}async function pe(a,e,t,o){if(!o.table)return e;let n=o.table;switch(o.type){case "hasOne":{let r=o.localKey||"id",s=e[r];if(s==null)return e;let i=b(n,o.foreignKey),l=await a.select().from(n).where(eq(i,s)).limit(1);return {...e,[t]:l[0]||null}}case "hasMany":{let r=o.localKey||"id",s=e[r];if(s==null)return {...e,[t]:[]};let i=b(n,o.foreignKey),l=await a.select().from(n).where(eq(i,s));return {...e,[t]:l}}case "belongsTo":{let r=e[o.foreignKey];if(r==null)return {...e,[t]:null};let s=b(n,o.localKey||"id"),i=await a.select().from(n).where(eq(s,r)).limit(1);return {...e,[t]:i[0]||null}}default:return e}}async function de(a,e,t,o){if(!o?.relations?.length||!t.model.relations)return e;let n={...e};for(let r of o.relations){let s=t.model.relations[r];s&&(n=await pe(a,n,r,s));}return n}async function S(a,e,t,o){if(!e.length||!o?.relations?.length||!t.model.relations)return e;let n=e.map(r=>({...r}));for(let r of o.relations){let s=t.model.relations[r];if(!s||!s.table)continue;let i=s.table;switch(s.type){case "hasOne":case "hasMany":{let l=s.localKey||"id",d=[...new Set(n.map(p=>p[l]).filter(p=>p!=null))];if(d.length===0){n=n.map(p=>({...p,[r]:s.type==="hasMany"?[]:null}));continue}let u=b(i,s.foreignKey),c=await a.select().from(i).where(inArray(u,d)),m=new Map;for(let p of c){let g=p[s.foreignKey];m.has(g)||m.set(g,[]),m.get(g).push(p);}n=n.map(p=>{let g=p[l],h=m.get(g)||[];return {...p,[r]:s.type==="hasMany"?h:h[0]||null}});break}case "belongsTo":{let l=s.localKey||"id",d=[...new Set(n.map(p=>p[s.foreignKey]).filter(p=>p!=null))];if(d.length===0){n=n.map(p=>({...p,[r]:null}));continue}let u=b(i,l),c=await a.select().from(i).where(inArray(u,d)),m=new Map;for(let p of c){let g=p[l];m.set(g,p);}n=n.map(p=>{let g=p[s.foreignKey];return {...p,[r]:m.get(g)||null}});break}}}return n}function O(a,e){let t=b(a,e.field);switch(e.operator){case "eq":return eq(t,e.value);case "ne":return ne$1(t,e.value);case "gt":return gt(t,e.value);case "gte":return gte(t,e.value);case "lt":return lt(t,e.value);case "lte":return lte(t,e.value);case "in":return inArray(t,e.value);case "nin":return notInArray(t,e.value);case "like":return like(t,e.value);case "ilike":return ilike(t,e.value);case "null":return e.value?isNull(t):isNotNull(t);case "between":{let[o,n]=e.value;return between(t,o,n)}default:return}}function D(a){let e=a;if(e._tx)return e._tx;if(e.db)return e.db;let t=e.context?.get?.("db");if(t)return t;throw new Error(`Database not configured. Either:
+1. Set db property: db = myDb;
+2. Use middleware: c.set("db", myDb);
+3. Use factory: createDrizzleCrud(db, meta)`)}function ee(a,e,t){switch(t){case "pg":return sql`POSITION(LOWER(${e}) IN LOWER(${a})) > 0`;case "mysql":return sql`LOCATE(LOWER(${e}), LOWER(${a})) > 0`;default:return sql`INSTR(LOWER(${a}), LOWER(${e})) > 0`}}function Je(a){return a.split(/\s+/).filter(e=>e.length>0)}var j=class extends UpsertEndpoint{db;dialect="sqlite";getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async findExisting(e){let t=this.getTable(),o=this.getUpsertKeys(),n=this.getSoftDeleteConfig(),r=[];for(let i of o){let l=e[i];l!==void 0&&r.push(eq(this.getColumn(i),l));}return n.enabled&&r.push(isNull(this.getColumn(n.field))),r.length===0?null:(await this.getDb().select().from(t).where(and(...r)).limit(1))[0]||null}async create(e){let t=this.getTable(),o=this.applyManagedInsertFields(e,"drizzle");return (await this.getDb().insert(t).values(o).returning())[0]}async update(e,t){let o=this.getTable(),n=this._meta.model.primaryKeys[0],r=e[n];return (await this.getDb().update(o).set(this.applyManagedUpdateFields(t)).where(eq(this.getColumn(n),r)).returning())[0]}async nativeUpsert(e,t){let o=this.getTable(),n=this.getUpsertKeys(),r=this._meta.model.primaryKeys[0],s=this.getSoftDeleteConfig(),i=this.getTimestampsConfig(),l=this.applyManagedInsertFields(e,"drizzle"),d={};for(let[h,y]of Object.entries(e))!n.includes(h)&&h!==r&&(this.createOnlyFields?.includes(h)||(d[h]=y));i.enabled&&(d[i.updatedAt]=Date.now());let u=n.map(h=>this.getColumn(h)),c;s.enabled&&(c=isNull(this.getColumn(s.field)));let m=Object.keys(d).length>0?d:{[r]:sql`${this.getColumn(r)}`},p=this.getDb().insert(o).values(l);return this.dialect==="mysql"?{data:(await p.onDuplicateKeyUpdate({set:m}).returning())[0],created:false}:{data:(await p.onConflictDoUpdate({target:u,set:m,where:c}).returning())[0],created:false}}},_=class extends BatchUpsertEndpoint{db;dialect="sqlite";getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async findExisting(e){let t=this.getTable(),o=this.getUpsertKeys(),n=[];for(let s of o){let i=e[s];i!==void 0&&n.push(eq(this.getColumn(s),i));}return n.length===0?null:(await this.getDb().select().from(t).where(and(...n)).limit(1))[0]||null}async create(e){let t=this.getTable(),o=this.applyManagedInsertFields(e,"drizzle");return (await this.getDb().insert(t).values(o).returning())[0]}async update(e,t){let o=this.getTable(),n=this._meta.model.primaryKeys[0],r=e[n];return (await this.getDb().update(o).set(this.applyManagedUpdateFields(t)).where(eq(this.getColumn(n),r)).returning())[0]}async nativeBatchUpsert(e,t){if(e.length===0)return {items:[],createdCount:0,updatedCount:0,totalCount:0};let o=this.getTable(),n=this.getUpsertKeys(),r=this._meta.model.primaryKeys[0],s=this.getTimestampsConfig(),i=e.map(g=>this.applyManagedInsertFields(g,"drizzle")),l={},d=e[0];for(let g of Object.keys(d))!n.includes(g)&&g!==r&&(this.createOnlyFields?.includes(g)||(l[g]=sql`excluded.${sql.identifier(g)}`));s.enabled&&(l[s.updatedAt]=Date.now());let u=n.map(g=>this.getColumn(g)),c=Object.keys(l).length>0?l:{[r]:sql`${this.getColumn(r)}`},m=this.getDb().insert(o).values(i),p=await(this.dialect==="mysql"?m.onDuplicateKeyUpdate({set:c}):m.onConflictDoUpdate({target:u,set:c})).returning();return {items:p.map((g,h)=>({data:g,created:false,index:h})),createdCount:0,updatedCount:p.length,totalCount:p.length}}},ge=class extends VersionHistoryEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async recordExists(e){let t=this.getTable(),o=await this.getDb().select({count:sql`count(*)`}).from(t).where(eq(this.getColumn("id"),e));return Number(o[0]?.count)>0}},me=class extends VersionReadEndpoint{},be=class extends VersionCompareEndpoint{},he=class extends VersionRollbackEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async rollback(e,t,o){let n=this.getTable(),r=this.getVersioningConfig().field;return (await this.getDb().update(n).set({...t,[r]:o}).where(eq(this.getColumn("id"),e)).returning())[0]}},G=class extends AggregateEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async aggregate(e){let t=this.getTable(),o=[],n=this.getSoftDeleteConfig();if(n.enabled){let{query:i}=await this.getValidatedData();i?.withDeleted===true||i?.withDeleted==="true"||o.push(isNull(this.getColumn(n.field)));}if(e.filters)for(let[i,l]of Object.entries(e.filters))if(typeof l=="object"&&l!==null)for(let[d,u]of Object.entries(l)){let c=O(t,{field:i,operator:d,value:u});c&&o.push(c);}else o.push(eq(this.getColumn(i),l));let r=o.length>0?and(...o):void 0,s=await this.getDb().select().from(t).where(r);return computeAggregations(s,e)}},I=class extends SearchEndpoint{db;dialect="sqlite";getDb(){return D(this)}useNativeSearch=false;vectorColumn;vectorConfig="english";getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async search(e,t){let o=this.getTable(),n=[],r=this.getSoftDeleteConfig();r.enabled&&(t.options.onlyDeleted?n.push(isNotNull(this.getColumn(r.field))):t.options.withDeleted||n.push(isNull(this.getColumn(r.field))));for(let w of t.filters){let M=O(o,w);M&&n.push(M);}let s=this.getSearchableFields(),i=e.fields||Object.keys(s);if(this.useNativeSearch&&this.vectorColumn){let w=this.getColumn(this.vectorColumn),M=e.mode==="phrase"?sql`phraseto_tsquery(${this.vectorConfig}, ${e.query})`:e.mode==="all"?sql`plainto_tsquery(${this.vectorConfig}, ${e.query})`:sql`to_tsquery(${this.vectorConfig}, ${e.query.split(/\s+/).join(" | ")})`;n.push(sql`${w} @@ ${M}`);}else {let w=(M,x)=>{try{let ie=this.getColumn(M);return ee(sql`CAST(${ie} AS TEXT)`,x,this.dialect)}catch{return}};if(e.mode==="all"){let M=Je(e.query);if(M.length>0){let x=[];for(let ie of M){let ue=i.map(ae=>w(ae,ie)).filter(ae=>ae!==void 0);ue.length>0&&x.push(or(...ue));}x.length>0&&n.push(and(...x));}}else {let M=i.map(x=>w(x,e.query)).filter(x=>x!==void 0);M.length>0&&n.push(or(...M));}}let l=n.length>0?and(...n):void 0,d=await this.getDb().select({count:sql`count(*)`}).from(o).where(l),u=Number(d[0]?.count)||0,c=this.getDb().select().from(o).where(l);if(t.options.order_by){let w=this.getColumn(t.options.order_by),M=t.options.order_by_direction==="desc"?desc:asc;c=c.orderBy(M(w));}let m=t.options.page||1,p=t.options.per_page||this.defaultPerPage;c=c.limit(p).offset((m-1)*p);let g=await c,h=e.mode==="all"?{...e,mode:"any"}:e,y=searchInMemory(g,h,s),R={relations:t.options.include||[]},$=y.map(w=>w.item),se=await S(this.getDb(),$,this._meta,R);return {items:y.map((w,M)=>({...w,item:se[M]})),totalCount:u}}},H=class extends ExportEndpoint{db;dialect="sqlite";getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async list(e){let t=this.getTable(),o=[],n=this.getSoftDeleteConfig();if(n.enabled){let h=this.getColumn(n.field);e.options.onlyDeleted?o.push(isNotNull(h)):e.options.withDeleted||o.push(isNull(h));}for(let h of e.filters){let y=O(t,h);y&&o.push(y);}if(e.options.search&&this.searchFields.length>0){let h=e.options.search,y=this.searchFields.map(R=>{let $=this.getColumn(R);return ee($,h,this.dialect)});o.push(or(...y));}let r=o.length>0?and(...o):void 0,s=await this.getDb().select({count:sql`count(*)`}).from(t).where(r),i=Number(s[0]?.count)||0,l=this.getDb().select().from(t).where(r);if(e.options.order_by){let h=this.getColumn(e.options.order_by),y=e.options.order_by_direction==="desc"?desc:asc;l=l.orderBy(y(h));}let d=e.options.page||1,u=e.options.per_page||this.defaultPerPage;l=l.limit(u).offset((d-1)*u);let c=await l,m={relations:e.options.include||[]},p=await S(this.getDb(),c,this._meta,m),g=Math.ceil(i/u);return {result:p,result_info:{page:d,per_page:u,total_count:i,total_pages:g,has_next_page:d<g,has_prev_page:d>1}}}},J=class extends ImportEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async findExisting(e){let t=this.getTable(),o=this.getUpsertKeys(),n=this.getSoftDeleteConfig(),r=[];for(let i of o){let l=e[i];l!==void 0&&r.push(eq(this.getColumn(i),l));}return n.enabled&&r.push(isNull(this.getColumn(n.field))),r.length===0?null:(await this.getDb().select().from(t).where(and(...r)).limit(1))[0]||null}async create(e){let t=this.getTable(),o=this.applyManagedInsertFields(e,"drizzle");return (await this.getDb().insert(t).values(o).returning())[0]}async update(e,t){let o=this.getTable(),n=this._meta.model.primaryKeys[0],r=e[n];return (await this.getDb().update(o).set(this.applyManagedUpdateFields(t)).where(eq(this.getColumn(n),r)).returning())[0]}},Y=class extends CloneEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}generateId(){return crypto.randomUUID()}async findSource(e,t){let o=this.getTable(),n=this.getColumn(this.lookupField),r=this.getSoftDeleteConfig(),s=[eq(n,e)];if(t)for(let[l,d]of Object.entries(t))s.push(eq(this.getColumn(l),d));r.enabled&&s.push(isNull(this.getColumn(r.field)));let i=await this.getDb().select().from(o).where(and(...s)).limit(1);return i[0]?i[0]:null}async createClone(e){let t=this.getTable(),o=this.applyManagedInsertFields(e,"drizzle",()=>this.generateId());return (await this.getDb().insert(t).values(o).returning())[0]}};var U=class extends CreateEndpoint{db;useTransaction=false;getDb(){return D(this)}getTable(){return f(this._meta)}getRelatedTable(e){return e.table}async create(e,t){let o=t??this.getDb(),n=this.getTable(),r=this.applyManagedInsertFields(e,"drizzle");return (await o.insert(n).values(r).returning())[0]}async createNested(e,t,o,n,r){let s=r??this.getDb(),i=this.getRelatedTable(o);if(!i)return getLogger().warn(`Related table not found for ${t}. Add 'table' to the relation config.`),[];let l=Array.isArray(n)?n:[n],d=[];for(let u of l){if(typeof u!="object"||u===null)continue;let c={...u,id:crypto.randomUUID(),[o.foreignKey]:e},m=await s.insert(i).values(c).returning();m[0]&&d.push(m[0]);}return d}async handle(){return this.useTransaction?this.getDb().transaction(async e=>{this._tx=e;try{return await super.handle()}finally{this._tx=void 0;}}):super.handle()}},B=class extends ReadEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async read(e,t,o){let n=this.getTable(),r=this.getColumn(this.lookupField),s=this.getSoftDeleteConfig(),i=[eq(r,e)];if(t)for(let[u,c]of Object.entries(t))i.push(eq(this.getColumn(u),c));s.enabled&&i.push(isNull(this.getColumn(s.field)));let l=await this.getDb().select().from(n).where(and(...i)).limit(1);return l[0]?await de(this.getDb(),l[0],this._meta,o):null}},A=class extends UpdateEndpoint{db;useTransaction=false;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}getRelatedTable(e){return e.table}async findExisting(e,t,o){let n=o??this.getDb(),r=this.getTable(),s=this.getColumn(this.lookupField),i=this.getSoftDeleteConfig(),l=[eq(s,e)];if(t)for(let[u,c]of Object.entries(t))l.push(eq(this.getColumn(u),c));return i.enabled&&l.push(isNull(this.getColumn(i.field))),(await n.select().from(r).where(and(...l)).limit(1))[0]||null}async update(e,t,o,n){let r=n??this.getDb(),s=this.getTable(),i=this.getColumn(this.lookupField),l=this.getSoftDeleteConfig(),d=[eq(i,e)];if(o)for(let[c,m]of Object.entries(o))d.push(eq(this.getColumn(c),m));return l.enabled&&d.push(isNull(this.getColumn(l.field))),(await r.update(s).set(this.applyManagedUpdateFields(t)).where(and(...d)).returning())[0]||null}async processNestedWrites(e,t,o,n,r){let s=r??this.getDb(),i=this.getRelatedTable(o);if(!i)return getLogger().warn(`Related table not found for ${t}. Add 'table' to the relation config.`),{created:[],updated:[],deleted:[],connected:[],disconnected:[]};let l={created:[],updated:[],deleted:[],connected:[],disconnected:[]},d=b(i,o.foreignKey),u=b(i,"id");if(n.create){let c=Array.isArray(n.create)?n.create:[n.create];for(let m of c){if(typeof m!="object"||m===null)continue;let p={...m,id:crypto.randomUUID(),[o.foreignKey]:e},g=await s.insert(i).values(p).returning();g[0]&&l.created.push(g[0]);}}if(n.update)for(let c of n.update){if(!c.id||!(await s.select().from(i).where(and(eq(u,c.id),eq(d,e))).limit(1))[0])continue;let{id:p,...g}=c,h=await s.update(i).set(g).where(eq(u,p)).returning();h[0]&&l.updated.push(h[0]);}if(n.delete)for(let c of n.delete)(await s.delete(i).where(and(eq(u,c),eq(d,e))).returning())[0]&&l.deleted.push(c);if(n.connect)for(let c of n.connect)(await s.update(i).set({[o.foreignKey]:e}).where(eq(u,c)).returning())[0]&&l.connected.push(c);if(n.disconnect)for(let c of n.disconnect)(await s.update(i).set({[o.foreignKey]:null}).where(and(eq(u,c),eq(d,e))).returning())[0]&&l.disconnected.push(c);return l}async handle(){return this.useTransaction?this.getDb().transaction(async e=>{this._tx=e;try{return await super.handle()}finally{this._tx=void 0;}}):super.handle()}},L=class extends DeleteEndpoint{db;useTransaction=false;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}getRelatedTable(e){return e.table}async findForDelete(e,t,o){let n=o??this.getDb(),r=this.getTable(),s=this.getColumn(this.lookupField),i=this.getSoftDeleteConfig(),l=[eq(s,e)];if(t)for(let[u,c]of Object.entries(t))l.push(eq(this.getColumn(u),c));return i.enabled&&l.push(isNull(this.getColumn(i.field))),(await n.select().from(r).where(and(...l)).limit(1))[0]||null}async delete(e,t,o){let n=o??this.getDb(),r=this.getTable(),s=this.getColumn(this.lookupField),i=this.getSoftDeleteConfig(),l=[eq(s,e)];if(t)for(let[d,u]of Object.entries(t))l.push(eq(this.getColumn(d),u));return i.enabled&&l.push(isNull(this.getColumn(i.field))),i.enabled?(await n.update(r).set({[i.field]:new Date}).where(and(...l)).returning())[0]||null:(await n.delete(r).where(and(...l)).returning())[0]||null}async countRelated(e,t,o,n){let r=n??this.getDb(),s=this.getRelatedTable(o);if(!s)return 0;let i=b(s,o.foreignKey),l=await r.select({count:sql`count(*)`}).from(s).where(eq(i,e));return Number(l[0]?.count)||0}async deleteRelated(e,t,o,n){let r=n??this.getDb(),s=this.getRelatedTable(o);if(!s)return 0;let i=b(s,o.foreignKey);return (await r.delete(s).where(eq(i,e)).returning()).length}async nullifyRelated(e,t,o,n){let r=n??this.getDb(),s=this.getRelatedTable(o);if(!s)return 0;let i=b(s,o.foreignKey);return (await r.update(s).set({[o.foreignKey]:null}).where(eq(i,e)).returning()).length}async handle(){return this.useTransaction?this.getDb().transaction(async e=>{this._tx=e;try{return await super.handle()}finally{this._tx=void 0;}}):super.handle()}},K=class extends ListEndpoint{db;dialect="sqlite";getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async list(e){let t=this.getTable(),o=[],n=this.getSoftDeleteConfig();if(n.enabled){let y=this.getColumn(n.field);e.options.onlyDeleted?o.push(isNotNull(y)):e.options.withDeleted||o.push(isNull(y));}for(let y of e.filters){let R=O(t,y);R&&o.push(R);}if(e.options.search&&this.searchFields.length>0){let y=e.options.search,R=this.searchFields.map($=>{let se=this.getColumn($);return ee(se,y,this.dialect)});o.push(or(...R));}let r=o.length>0?and(...o):void 0,s=this.getDb(),i=await s.select({count:sql`count(*)`}).from(t).where(r),l=Number(i[0]?.count)||0,d=s.select().from(t).where(r);if(e.options.order_by){let y=this.getColumn(e.options.order_by),R=e.options.order_by_direction==="desc"?desc:asc;d=d.orderBy(R(y));}let u=e.options.page||1,c=e.options.per_page||this.defaultPerPage;d=d.limit(c).offset((u-1)*c);let m=await d,p={relations:e.options.include||[]},g=await S(this.getDb(),m,this._meta,p),h=Math.ceil(l/c);return {result:g,result_info:{page:u,per_page:c,total_count:l,total_pages:h,has_next_page:u<h,has_prev_page:u>1}}}},Z=class extends RestoreEndpoint{db;useTransaction=false;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async restore(e,t,o){let n=o??this.getDb(),r=this.getTable(),s=this.getColumn(this.lookupField),i=this.getSoftDeleteConfig(),l=[eq(s,e)];if(t)for(let[u,c]of Object.entries(t))l.push(eq(this.getColumn(u),c));return l.push(isNotNull(this.getColumn(i.field))),(await n.update(r).set({[i.field]:null}).where(and(...l)).returning())[0]||null}async handle(){return this.useTransaction?this.getDb().transaction(async e=>{this._tx=e;try{return await super.handle()}finally{this._tx=void 0;}}):super.handle()}};var F=class extends BatchCreateEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}async batchCreate(e){let t=this.getTable(),o=e.map(r=>this.applyManagedInsertFields(r,"drizzle"));return await this.getDb().insert(t).values(o).returning()}},Q=class extends BatchUpdateEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async batchUpdate(e){let t=this.getTable(),o=this.getColumn(this.lookupField),n=this.getSoftDeleteConfig(),r=[],s=[];for(let i of e){let l=[eq(o,i.id)];n.enabled&&l.push(isNull(this.getColumn(n.field)));let d=await this.getDb().update(t).set(this.applyManagedUpdateFields(i.data)).where(and(...l)).returning();d[0]?r.push(d[0]):s.push(i.id);}return {updated:r,notFound:s}}},N=class extends BatchDeleteEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async batchDelete(e){let t=this.getTable(),o=this.getColumn(this.lookupField),n=this.getSoftDeleteConfig(),r=[inArray(o,e)];n.enabled&&r.push(isNull(this.getColumn(n.field)));let s;n.enabled?s=await this.getDb().update(t).set({[n.field]:new Date}).where(and(...r)).returning():s=await this.getDb().delete(t).where(and(...r)).returning();let i=s,l=new Set(i.map(u=>String(u[this.lookupField]))),d=e.filter(u=>!l.has(u));return {deleted:i,notFound:d}}},q=class extends BatchRestoreEndpoint{db;getDb(){return D(this)}getTable(){return f(this._meta)}getColumn(e){return b(this.getTable(),e)}async batchRestore(e){let t=this.getTable(),o=this.getColumn(this.lookupField),n=this.getSoftDeleteConfig(),r=[inArray(o,e),isNotNull(this.getColumn(n.field))],i=await this.getDb().update(t).set({[n.field]:null}).where(and(...r)).returning(),l=new Set(i.map(u=>String(u[this.lookupField]))),d=e.filter(u=>!l.has(u));return {restored:i,notFound:d}}};function ln(a,e,t){let o=t?.dialect??"sqlite";return {Create:class extends U{_meta=e;db=a},Read:class extends B{_meta=e;db=a},Update:class extends A{_meta=e;db=a},Delete:class extends L{_meta=e;db=a},List:class extends K{_meta=e;db=a;dialect=o},Restore:class extends Z{_meta=e;db=a},Upsert:class extends j{_meta=e;db=a;dialect=o},Search:class extends I{_meta=e;db=a;dialect=o},BatchCreate:class extends F{_meta=e;db=a},BatchUpdate:class extends Q{_meta=e;db=a},BatchDelete:class extends N{_meta=e;db=a},BatchRestore:class extends q{_meta=e;db=a},BatchUpsert:class extends _{_meta=e;db=a;dialect=o}}}var oe=null,Te=false,ne=null;async function re(){if(Te){if(ne)throw ne;return oe}Te=true;try{return oe=await import('drizzle-zod'),oe}catch{throw ne=new Error("drizzle-zod is not installed. Please install it: npm install drizzle-zod"),ne}}async function mt(a,e){return (await re()).createSelectSchema(a,e)}async function bt(a,e){return (await re()).createInsertSchema(a,e)}async function ht(a,e){let t=await re();return t.createUpdateSchema?t.createUpdateSchema(a,e):t.createInsertSchema(a,e).partial()}async function ft(a,e){let t=await re(),o=e?.coerceDates!==false,n=o?Mt(a):new Set,r=t.createSelectSchema(a,e?.selectRefine),s=t.createInsertSchema(a,e?.insertRefine),i;return t.createUpdateSchema?i=t.createUpdateSchema(a,e?.updateRefine):i=t.createInsertSchema(a,e?.updateRefine).partial(),o&&n.size>0&&(s=Re(s,n),i=Re(i,n)),{select:r,insert:s,update:i}}function zt(){return oe!==null}var Dt=z.preprocess(a=>{if(a instanceof Date)return a;if(typeof a=="string"){let e=new Date(a);if(!isNaN(e.getTime()))return e}return a},z.date()),yt=z.preprocess(a=>{if(a==null)return null;if(a instanceof Date)return a;if(typeof a=="string"){let e=new Date(a);if(!isNaN(e.getTime()))return e}return a},z.date().nullable());function Mt(a){let e=new Set,t=a;for(let[o,n]of Object.entries(t)){if(o==="_"||o==="$inferInsert"||o==="$inferSelect")continue;let r=n;if(!r||typeof r!="object")continue;let s=String(r.dataType??"").toLowerCase(),i=String(r.columnType??"").toLowerCase(),l=r.config,d=String(l?.dataType??"").toLowerCase();(s.includes("timestamp")||s.includes("date")||s.includes("datetime")||i.includes("pgtimestamp")||i.includes("pgdate")||i.includes("mysqltimestamp")||i.includes("mysqldate")||i.includes("sqlitetimestamp")||d.includes("timestamp")||d.includes("date"))&&e.add(o);}return e}function Re(a,e){if(e.size===0)return a;let t=a.shape,o={};for(let[n,r]of Object.entries(t))if(e.has(n)){let s=r.isOptional?.()??false,i=r.isNullable?.()??false,l=Dt;(i||s)&&(l=yt),s&&(l=l.optional()),o[n]=l;}else o[n]=r;return z.object(o)}var kn={CreateEndpoint:U,ListEndpoint:K,ReadEndpoint:B,UpdateEndpoint:A,DeleteEndpoint:L,RestoreEndpoint:Z,BatchCreateEndpoint:F,BatchUpdateEndpoint:Q,BatchDeleteEndpoint:N,BatchRestoreEndpoint:q,BatchUpsertEndpoint:_,SearchEndpoint:I,AggregateEndpoint:G,ExportEndpoint:H,ImportEndpoint:J,UpsertEndpoint:j,CloneEndpoint:Y};export{kn as DrizzleAdapters,G as DrizzleAggregateEndpoint,F as DrizzleBatchCreateEndpoint,N as DrizzleBatchDeleteEndpoint,q as DrizzleBatchRestoreEndpoint,Q as DrizzleBatchUpdateEndpoint,_ as DrizzleBatchUpsertEndpoint,Y as DrizzleCloneEndpoint,U as DrizzleCreateEndpoint,L as DrizzleDeleteEndpoint,H as DrizzleExportEndpoint,J as DrizzleImportEndpoint,K as DrizzleListEndpoint,B as DrizzleReadEndpoint,Z as DrizzleRestoreEndpoint,I as DrizzleSearchEndpoint,A as DrizzleUpdateEndpoint,j as DrizzleUpsertEndpoint,be as DrizzleVersionCompareEndpoint,ge as DrizzleVersionHistoryEndpoint,me as DrizzleVersionReadEndpoint,he as DrizzleVersionRollbackEndpoint,S as batchLoadDrizzleRelations,O as buildWhereCondition,X as cast,ln as createDrizzleCrud,ft as createDrizzleSchemas,bt as createInsertSchema,mt as createSelectSchema,ht as createUpdateSchema,b as getColumn,f as getTable,zt as isDrizzleZodAvailable,pe as loadDrizzleRelation,de as loadDrizzleRelations,ee as substringMatch};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@hono-crud/drizzle",
+  "version": "0.1.1",
+  "description": "Drizzle ORM CRUD adapter for hono-crud",
+  "author": "Kauan Guesser <contato@kauan.net>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshdotdev/hono-crud.git",
+    "directory": "packages/drizzle"
+  },
+  "homepage": "https://github.com/kshdotdev/hono-crud#readme",
+  "bugs": {
+    "url": "https://github.com/kshdotdev/hono-crud/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "hono",
+    "crud",
+    "drizzle",
+    "drizzle-orm",
+    "adapter"
+  ],
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "hono-crud": "0.13.4"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.30.0",
+    "drizzle-zod": ">=0.8.0",
+    "hono": ">=4.11.7 <5",
+    "zod": ">=4.0.0"
+  },
+  "devDependencies": {
+    "drizzle-orm": "^0.45.1",
+    "drizzle-zod": "^0.8.3",
+    "hono": "^4.11.4",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "zod": "^4.3.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .tsup"
+  }
+}