hono-crud 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 %b
 %b
 %b
+%b
+%b
 ## [0.1.0] - 2025-01-29
 
 ### Added
@@ -36,3 +38,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [0.1.3]: https://github.com/ksh-us/hono-crud/compare/v0.1.2...v0.1.3
 [0.1.4]: https://github.com/kshdotdev/hono-crud/compare/v0.1.3...v0.1.4
 [0.2.0]: https://github.com/kshdotdev/hono-crud/compare/v0.1.4...v0.2.0
+[0.3.0]: https://github.com/kshdotdev/hono-crud/compare/v0.2.0...v0.3.0
+[0.3.1]: https://github.com/kshdotdev/hono-crud/compare/v0.3.0...v0.3.1

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

@@ -1,187 +1,56 @@
+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 { 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 { Table, Column } from 'drizzle-orm';
-import { M as MetaInput, e as AggregateEndpoint, h as AggregateOptions, i as AggregateResult, B as BatchCreateEndpoint, c as ModelObject, o as BatchDeleteEndpoint, q as BatchRestoreEndpoint, s as BatchUpdateEndpoint, t as BatchUpdateItem, v as BatchUpsertEndpoint, G as CreateEndpoint, aA as RelationConfig, az as ReadEndpoint, aa as IncludeOptions, aP as UpdateEndpoint, ap as NestedUpdateInput, ar as NestedWriteResult, P as DeleteEndpoint, ae as ListEndpoint, ag as ListFilters, ax as PaginatedResult, aE as RestoreEndpoint, aR as UpsertEndpoint, R as ExportEndpoint, a3 as ImportEndpoint, aI as SearchEndpoint, aJ as SearchOptions, aK as SearchResult, aU as VersionCompareEndpoint, aV as VersionHistoryEndpoint, aY as VersionReadEndpoint, aZ as VersionRollbackEndpoint } from '../../import-Cm5-75Os.js';
-import { A as AdapterBundle } from '../../index-CH2mY76l.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;
+}
 /**
- * Duck-typed interface for Drizzle tables.
- * This allows compatibility across different drizzle-orm versions and package installations.
+ * Internal database interface used for type-safe method calls.
+ * All Drizzle databases (PostgreSQL, MySQL, SQLite) satisfy this interface at runtime.
  */
-type DrizzleTable = {
-    _: {
-        name: string;
-        columns: Record<string, any>;
+interface Database {
+    select(fields?: Record<string, unknown>): {
+        from(table: Table): QueryBuilder;
     };
-};
-/**
- * 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>>;
+    insert(table: Table): QueryBuilder;
+    update(table: Table): QueryBuilder;
+    delete(table: Table): QueryBuilder;
+    transaction<T>(fn: (tx: Database) => Promise<T>): Promise<T>;
 }
 /**
- * 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,
- * });
- * ```
+ * 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 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;
-
+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.
@@ -243,6 +112,39 @@ type DrizzleEnv<DB = DrizzleDatabaseConstraint> = {
         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).
@@ -461,6 +363,7 @@ 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).
@@ -527,6 +430,7 @@ 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.
@@ -733,6 +637,7 @@ 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']>>;
 }
+
 /**
  * Return type of createDrizzleCrud factory function.
  * Provides type-safe base classes for all CRUD operations.
@@ -779,7 +684,6 @@ interface DrizzleCrudClasses<M extends MetaInput> {
  * ```
  */
 declare function createDrizzleCrud<M extends MetaInput>(db: DrizzleDatabaseConstraint, meta: M): DrizzleCrudClasses<M>;
-
 /**
  * Drizzle adapter bundle for use with defineEndpoints.
  *
@@ -806,4 +710,180 @@ declare function createDrizzleCrud<M extends MetaInput>(db: DrizzleDatabaseConst
  */
 declare const DrizzleAdapters: AdapterBundle;
 
-export { 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, createDrizzleCrud, createDrizzleSchemas, createDrizzleSchemasAsync, createInsertSchema, createSelectSchema, createUpdateSchema, isDrizzleZodAvailable };
+/**
+ * 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 };