@forinda/kickjs-drizzle 1.3.2 → 1.4.1-alpha.0

package/dist/drizzle.adapter.d.ts

@@ -0,0 +1,51 @@
+import { type AppAdapter, type Container } from '@forinda/kickjs-core';
+import { type DrizzleAdapterOptions } from './types';
+/**
+ * Drizzle ORM adapter — registers a Drizzle database instance in the DI
+ * container and manages its lifecycle.
+ *
+ * Works with any Drizzle driver: `drizzle-orm/postgres-js`, `drizzle-orm/node-postgres`,
+ * `drizzle-orm/mysql2`, `drizzle-orm/better-sqlite3`, `drizzle-orm/libsql`, etc.
+ *
+ * The adapter is generic — the db type is inferred from what you pass in,
+ * so services can inject the fully-typed database instance.
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/better-sqlite3'
+ * import * as schema from './schema'
+ * import { DrizzleAdapter } from '@forinda/kickjs-drizzle'
+ *
+ * const db = drizzle({ client: sqlite, schema })
+ *
+ * bootstrap({
+ *   modules,
+ *   adapters: [
+ *     new DrizzleAdapter({ db, onShutdown: () => sqlite.close() }),
+ *   ],
+ * })
+ * ```
+ *
+ * Inject the typed db instance in services:
+ * ```ts
+ * import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
+ * import * as schema from './schema'
+ *
+ * @Service()
+ * class UserService {
+ *   constructor(@Inject(DRIZZLE_DB) private db: BetterSQLite3Database<typeof schema>) {}
+ * }
+ * ```
+ */
+export declare class DrizzleAdapter<TDb = unknown> implements AppAdapter {
+    private options;
+    name: string;
+    private db;
+    private onShutdown?;
+    constructor(options: DrizzleAdapterOptions<TDb>);
+    /** Register the Drizzle db instance in the DI container */
+    beforeStart(_app: unknown, container: Container): void;
+    /** Close the underlying connection on shutdown */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=drizzle.adapter.d.ts.map

package/dist/drizzle.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.adapter.d.ts","sourceRoot":"","sources":["../src/drizzle.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,UAAU,EAAE,KAAK,SAAS,EAAS,MAAM,sBAAsB,CAAA;AACrF,OAAO,EAAc,KAAK,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,cAAc,CAAC,GAAG,GAAG,OAAO,CAAE,YAAW,UAAU;IAKlD,OAAO,CAAC,OAAO;IAJ3B,IAAI,SAAmB;IACvB,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,UAAU,CAAC,CAA4B;gBAE3B,OAAO,EAAE,qBAAqB,CAAC,GAAG,CAAC;IAKvD,2DAA2D;IAC3D,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAUtD,kDAAkD;IAC5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAMhC"}

package/dist/index.d.ts

@@ -1,334 +1,6 @@
-import { MaybePromise, AppAdapter, Container } from '@forinda/kickjs-core';
-import { QueryBuilderAdapter, ParsedQuery } from '@forinda/kickjs-http';
-
-/** DI token for resolving the Drizzle database instance from the container */
-declare const DRIZZLE_DB: unique symbol;
-interface DrizzleAdapterOptions<TDb = unknown> {
-    /**
-     * Drizzle database instance — the return value of `drizzle()`.
-     * Preserves the full type so services can inject it type-safely.
-     *
-     * @example
-     * ```ts
-     * import { drizzle } from 'drizzle-orm/better-sqlite3'
-     * import * as schema from './schema'
-     *
-     * const db = drizzle({ client: sqlite, schema })
-     * // db is BetterSQLite3Database<typeof schema>
-     *
-     * new DrizzleAdapter({ db })
-     * // TDb is inferred as BetterSQLite3Database<typeof schema>
-     * ```
-     */
-    db: TDb;
-    /** Enable query logging (default: false) */
-    logging?: boolean;
-    /**
-     * Optional shutdown function to close the underlying connection pool.
-     * Drizzle doesn't expose a universal disconnect — this lets you pass your
-     * driver's cleanup (e.g., `pool.end()` for postgres, `client.close()` for libsql).
-     *
-     * @example
-     * ```ts
-     * const pool = new Pool({ connectionString: '...' })
-     * const db = drizzle(pool)
-     *
-     * new DrizzleAdapter({
-     *   db,
-     *   onShutdown: () => pool.end(),
-     * })
-     * ```
-     */
-    onShutdown?: () => MaybePromise<any>;
-}
-
-/**
- * Drizzle ORM adapter — registers a Drizzle database instance in the DI
- * container and manages its lifecycle.
- *
- * Works with any Drizzle driver: `drizzle-orm/postgres-js`, `drizzle-orm/node-postgres`,
- * `drizzle-orm/mysql2`, `drizzle-orm/better-sqlite3`, `drizzle-orm/libsql`, etc.
- *
- * The adapter is generic — the db type is inferred from what you pass in,
- * so services can inject the fully-typed database instance.
- *
- * @example
- * ```ts
- * import { drizzle } from 'drizzle-orm/better-sqlite3'
- * import * as schema from './schema'
- * import { DrizzleAdapter } from '@forinda/kickjs-drizzle'
- *
- * const db = drizzle({ client: sqlite, schema })
- *
- * bootstrap({
- *   modules,
- *   adapters: [
- *     new DrizzleAdapter({ db, onShutdown: () => sqlite.close() }),
- *   ],
- * })
- * ```
- *
- * Inject the typed db instance in services:
- * ```ts
- * import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
- * import * as schema from './schema'
- *
- * @Service()
- * class UserService {
- *   constructor(@Inject(DRIZZLE_DB) private db: BetterSQLite3Database<typeof schema>) {}
- * }
- * ```
- */
-declare class DrizzleAdapter<TDb = unknown> implements AppAdapter {
-    private options;
-    name: string;
-    private db;
-    private onShutdown?;
-    constructor(options: DrizzleAdapterOptions<TDb>);
-    /** Register the Drizzle db instance in the DI container */
-    beforeStart(_app: unknown, container: Container): void;
-    /** Close the underlying connection on shutdown */
-    shutdown(): Promise<void>;
-}
-
-/**
- * Configuration for the Drizzle query builder adapter.
- *
- * Unlike Prisma which uses its own query builder API, Drizzle uses SQL-like
- * operators (`eq`, `gt`, `like`, etc.) from `drizzle-orm`. This adapter
- * produces a config object that can be spread into Drizzle's `select().from().where()`.
- */
-interface DrizzleQueryConfig {
-    /** The Drizzle table schema object (e.g., `users` from your schema) */
-    table: Record<string, any>;
-    /** Columns to search across when a search string is provided */
-    searchColumns?: string[];
-}
-/**
- * Type-safe Drizzle query configuration using Column objects.
- *
- * Use this instead of `DrizzleQueryConfig` for type-safe column references
- * that are validated at compile time. Column objects carry `dataType` metadata
- * enabling automatic type coercion of filter values.
- *
- * @example
- * ```ts
- * import { users } from './schema'
- * import type { DrizzleColumnQueryConfig } from '@forinda/kickjs-drizzle'
- *
- * const config: DrizzleColumnQueryConfig = {
- *   columns: {
- *     status: users.status,
- *     isActive: users.isActive,
- *     createdAt: users.createdAt,
- *   },
- *   sortable: {
- *     name: users.name,
- *     createdAt: users.createdAt,
- *   },
- *   searchColumns: [users.firstName, users.lastName, users.email],
- *   baseCondition: eq(users.tenantId, tenantId),
- * }
- * ```
- */
-interface DrizzleColumnQueryConfig {
-    /**
-     * Map of filterable field names to Drizzle Column objects.
-     * Keys are the query parameter names, values are the actual schema columns.
-     * The column's `dataType` is used for automatic type coercion.
-     */
-    columns: Record<string, any>;
-    /**
-     * Map of sortable field names to Drizzle Column objects.
-     * If not provided, falls back to `columns` for sort lookups.
-     */
-    sortable?: Record<string, any>;
-    /**
-     * Column objects to search across when a search string is provided.
-     * Each entry should be a Drizzle Column (not a string).
-     */
-    searchColumns?: any[];
-    /**
-     * A pre-built SQL condition that is always prepended to the WHERE clause.
-     * Use for scoping queries by tenant, workspace, or other invariants.
-     *
-     * @example
-     * ```ts
-     * baseCondition: and(eq(tasks.tenantId, tid), eq(tasks.workspaceId, wid))
-     * ```
-     */
-    baseCondition?: any;
-}
-/**
- * Configuration type for defining query param schemas with Drizzle Column objects.
- *
- * Used in constants files to define which columns are filterable, sortable, and searchable.
- * This type is consumed by both `DrizzleQueryAdapter.buildFromColumns()` and `@ApiQueryParams()`.
- *
- * @example
- * ```ts
- * import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
- * import { tasks } from '@/db/schema'
- *
- * export const TASK_QUERY_CONFIG: DrizzleQueryParamsConfig = {
- *   columns: {
- *     status: tasks.status,
- *     priority: tasks.priority,
- *   },
- *   sortable: {
- *     title: tasks.title,
- *     createdAt: tasks.createdAt,
- *   },
- *   searchColumns: [tasks.title, tasks.key],
- * }
- * ```
- */
-interface DrizzleQueryParamsConfig {
-    /** Filterable columns: keys are query param names, values are Drizzle Column objects */
-    columns: Record<string, any>;
-    /** Sortable columns: keys are query param names, values are Drizzle Column objects */
-    sortable?: Record<string, any>;
-    /** Columns for text search */
-    searchColumns?: any[];
-    /** Optional base condition for scoping (tenant, workspace, etc.) */
-    baseCondition?: any;
-}
-/**
- * Convert a DrizzleQueryParamsConfig into a string-based QueryFieldConfig.
- * Useful for passing to `@ApiQueryParams()` or other APIs that expect string arrays.
- *
- * @example
- * ```ts
- * import { toQueryFieldConfig } from '@forinda/kickjs-drizzle'
- *
- * const fieldConfig = toQueryFieldConfig(TASK_QUERY_CONFIG)
- * // → { filterable: ['status', 'priority'], sortable: ['title', 'createdAt'], searchable: [] }
- * ```
- */
-declare function toQueryFieldConfig(config: DrizzleQueryParamsConfig): {
-    filterable: string[];
-    sortable: string[];
-    searchable: string[];
-};
-/**
- * Result shape compatible with Drizzle's query builder.
- * Use with `db.select().from(table).where(result.where).orderBy(...result.orderBy).limit(result.limit).offset(result.offset)`
- */
-interface DrizzleQueryResult {
-    /** SQL condition — pass to `.where()` */
-    where?: any;
-    /** Array of order expressions — spread into `.orderBy()` */
-    orderBy: any[];
-    /** Row limit — pass to `.limit()` */
-    limit: number;
-    /** Row offset — pass to `.offset()` */
-    offset: number;
-}
-/**
- * Drizzle operator functions required by the query adapter.
- * Pass these from your `drizzle-orm` import to avoid version coupling.
- *
- * @example
- * ```ts
- * import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc } from 'drizzle-orm'
- *
- * const adapter = new DrizzleQueryAdapter({
- *   eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
- * })
- * ```
- */
-interface DrizzleOps {
-    eq: (column: any, value: any) => any;
-    ne: (column: any, value: any) => any;
-    gt: (column: any, value: any) => any;
-    gte: (column: any, value: any) => any;
-    lt: (column: any, value: any) => any;
-    lte: (column: any, value: any) => any;
-    ilike: (column: any, value: string) => any;
-    inArray: (column: any, values: any[]) => any;
-    between?: (column: any, min: any, max: any) => any;
-    and: (...conditions: any[]) => any;
-    or: (...conditions: any[]) => any;
-    asc: (column: any) => any;
-    desc: (column: any) => any;
-}
-/**
- * Translates a ParsedQuery into Drizzle-compatible query parts.
- *
- * Supports two modes:
- * 1. **String-based** (legacy): `build(parsed, { table, searchColumns })` — looks up columns by string name
- * 2. **Column-based** (recommended): `buildFromColumns(parsed, config)` — uses actual Column objects for type safety
- *
- * @example
- * ```ts
- * // String-based (legacy)
- * const query = adapter.build(parsed, { table: users, searchColumns: ['name', 'email'] })
- *
- * // Column-based (recommended)
- * const query = adapter.buildFromColumns(parsed, {
- *   columns: { status: users.status, isActive: users.isActive },
- *   searchColumns: [users.name, users.email],
- *   baseCondition: eq(users.tenantId, tid),
- * })
- *
- * const results = await db
- *   .select().from(users)
- *   .where(query.where)
- *   .orderBy(...query.orderBy)
- *   .limit(query.limit)
- *   .offset(query.offset)
- * ```
- */
-declare class DrizzleQueryAdapter implements QueryBuilderAdapter<DrizzleQueryResult, DrizzleQueryConfig> {
-    private ops;
-    readonly name = "DrizzleQueryAdapter";
-    constructor(ops: DrizzleOps);
-    /**
-     * Build query from string-based config (legacy API).
-     * Prefer `buildFromColumns()` for type safety.
-     */
-    build(parsed: ParsedQuery, config?: DrizzleQueryConfig): DrizzleQueryResult;
-    /**
-     * Build query using Column objects for type-safe filtering, sorting, and search.
-     *
-     * Features over `build()`:
-     * - Column references validated at compile time
-     * - Automatic type coercion based on `column.dataType` (boolean, number, date)
-     * - `baseCondition` support for tenant/workspace scoping
-     * - Native `between` operator support
-     * - Separate `sortable` map so filterable and sortable columns can differ
-     *
-     * @example
-     * ```ts
-     * const query = adapter.buildFromColumns(parsed, {
-     *   columns: { status: tasks.status, priority: tasks.priority },
-     *   sortable: { title: tasks.title, createdAt: tasks.createdAt },
-     *   searchColumns: [tasks.title, tasks.key],
-     *   baseCondition: eq(tasks.workspaceId, wid),
-     * })
-     * ```
-     */
-    buildFromColumns(parsed: ParsedQuery, config: DrizzleColumnQueryConfig): DrizzleQueryResult;
-    /** Map a single FilterItem to a Drizzle condition using string-based table lookup */
-    private buildFilter;
-    /**
-     * Map a FilterItem to a Drizzle condition using a Column object.
-     * Coerces values based on `column.dataType` for type-safe filtering.
-     */
-    private buildColumnFilter;
-    /** Build Drizzle orderBy from SortItem[] */
-    private buildSort;
-    /** Attempt to coerce a string value to a number or boolean if appropriate */
-    private coerce;
-    /**
-     * Coerce a string value based on the column's dataType.
-     *
-     * - `'boolean'` → `true`/`false`
-     * - `'number'` / `'bigint'` → `Number(value)`
-     * - `'date'` → `new Date(value)` (ISO 8601 strings)
-     * - Everything else → original string
-     */
-    private coerceByDataType;
-}
-
-export { DRIZZLE_DB, DrizzleAdapter, type DrizzleAdapterOptions, type DrizzleColumnQueryConfig, type DrizzleOps, DrizzleQueryAdapter, type DrizzleQueryConfig, type DrizzleQueryParamsConfig, type DrizzleQueryResult, toQueryFieldConfig };
+export { DrizzleAdapter } from './drizzle.adapter';
+export { DrizzleQueryAdapter, toQueryFieldConfig } from './query-adapter';
+export { DRIZZLE_DB } from './types';
+export type { DrizzleAdapterOptions } from './types';
+export type { DrizzleQueryConfig, DrizzleColumnQueryConfig, DrizzleQueryParamsConfig, DrizzleQueryResult, DrizzleOps, } from './query-adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,YAAY,EACV,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,UAAU,GACX,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -1 +1,168 @@
-var m=Object.defineProperty;var h=(n,e)=>m(n,"name",{value:e,configurable:!0});import{Logger as b,Scope as f}from"@forinda/kickjs-core";var l=Symbol("DrizzleDB");var u=b.for("DrizzleAdapter"),p=class{static{h(this,"DrizzleAdapter")}options;name="DrizzleAdapter";db;onShutdown;constructor(e){this.options=e,this.db=e.db,this.onShutdown=e.onShutdown}beforeStart(e,s){this.options.logging&&u.info("Query logging enabled"),s.registerFactory(l,()=>this.db,f.SINGLETON),u.info("Drizzle database registered in DI container")}async shutdown(){this.onShutdown&&(await this.onShutdown(),u.info("Drizzle connection closed"))}};function y(n){return{filterable:Object.keys(n.columns),sortable:n.sortable?Object.keys(n.sortable):[],searchable:n.searchColumns?n.searchColumns.map(e=>e.name??"").filter(Boolean):[]}}h(y,"toQueryFieldConfig");var d=class{static{h(this,"DrizzleQueryAdapter")}ops;name="DrizzleQueryAdapter";constructor(e){this.ops=e}build(e,s={}){let t={orderBy:[],limit:e.pagination.limit,offset:e.pagination.offset},r=[];for(let o of e.filters){let i=this.buildFilter(s.table,o);i&&r.push(i)}if(e.search&&s.searchColumns&&s.searchColumns.length>0){let o=s.searchColumns.filter(i=>s.table[i]).map(i=>this.ops.ilike(s.table[i],`%${e.search}%`));o.length>0&&r.push(this.ops.or(...o))}return r.length===1?t.where=r[0]:r.length>1&&(t.where=this.ops.and(...r)),t.orderBy=this.buildSort(s.table,e.sort),t}buildFromColumns(e,s){let t={orderBy:[],limit:e.pagination.limit,offset:e.pagination.offset},r=[];s.baseCondition&&r.push(s.baseCondition);for(let i of e.filters){let a=s.columns[i.field];if(!a)continue;let c=this.buildColumnFilter(a,i);c&&r.push(c)}if(e.search&&s.searchColumns&&s.searchColumns.length>0){let i=s.searchColumns.map(a=>this.ops.ilike(a,`%${e.search}%`));i.length>0&&r.push(this.ops.or(...i))}r.length===1?t.where=r[0]:r.length>1&&(t.where=this.ops.and(...r));let o=s.sortable??s.columns;return t.orderBy=e.sort.filter(i=>o[i.field]).map(i=>i.direction==="desc"?this.ops.desc(o[i.field]):this.ops.asc(o[i.field])),t}buildFilter(e,s){let t=e[s.field];if(!t)return null;let r=this.coerce(s.value);switch(s.operator){case"eq":return this.ops.eq(t,r);case"neq":return this.ops.ne(t,r);case"gt":return this.ops.gt(t,r);case"gte":return this.ops.gte(t,r);case"lt":return this.ops.lt(t,r);case"lte":return this.ops.lte(t,r);case"contains":return this.ops.ilike(t,`%${s.value}%`);case"starts":return this.ops.ilike(t,`${s.value}%`);case"ends":return this.ops.ilike(t,`%${s.value}`);case"in":{let o=s.value.split(",").map(i=>this.coerce(i.trim()));return this.ops.inArray(t,o)}case"between":{let[o,i]=s.value.split(",").map(a=>this.coerce(a.trim()));return this.ops.and(this.ops.gte(t,o),this.ops.lte(t,i))}default:return this.ops.eq(t,r)}}buildColumnFilter(e,s){let t=this.coerceByDataType(s.value,e.dataType);switch(s.operator){case"eq":return this.ops.eq(e,t);case"neq":return this.ops.ne(e,t);case"gt":return this.ops.gt(e,t);case"gte":return this.ops.gte(e,t);case"lt":return this.ops.lt(e,t);case"lte":return this.ops.lte(e,t);case"contains":return this.ops.ilike(e,`%${s.value}%`);case"starts":return this.ops.ilike(e,`${s.value}%`);case"ends":return this.ops.ilike(e,`%${s.value}`);case"in":{let r=s.value.split(",").map(o=>this.coerceByDataType(o.trim(),e.dataType));return this.ops.inArray(e,r)}case"between":{let[r,o]=s.value.split(",").map(c=>c.trim()),i=this.coerceByDataType(r,e.dataType),a=this.coerceByDataType(o,e.dataType);return this.ops.between?this.ops.between(e,i,a):this.ops.and(this.ops.gte(e,i),this.ops.lte(e,a))}default:return this.ops.eq(e,t)}}buildSort(e,s){return s.filter(t=>e[t.field]).map(t=>t.direction==="desc"?this.ops.desc(e[t.field]):this.ops.asc(e[t.field]))}coerce(e){if(e==="true")return!0;if(e==="false")return!1;let s=Number(e);return!Number.isNaN(s)&&e.trim()!==""?s:e}coerceByDataType(e,s){if(!s)return this.coerce(e);switch(s){case"boolean":return e==="true"||e==="1";case"number":case"bigint":{let t=Number(e);return Number.isNaN(t)?e:t}case"date":case"localDate":case"localDateTime":{let t=new Date(e);return Number.isNaN(t.getTime())?e:t}default:return e}}};export{l as DRIZZLE_DB,p as DrizzleAdapter,d as DrizzleQueryAdapter,y as toQueryFieldConfig};
+import { Logger as l, Scope as c } from "@forinda/kickjs-core";
+var u = /* @__PURE__ */ Symbol("DrizzleDB"), h = l.for("DrizzleAdapter"), d = class {
+  name = "DrizzleAdapter";
+  db;
+  onShutdown;
+  constructor(e) {
+    this.options = e, this.db = e.db, this.onShutdown = e.onShutdown;
+  }
+  beforeStart(e, t) {
+    this.options.logging && h.info("Query logging enabled"), t.registerFactory(u, () => this.db, c.SINGLETON), h.info("Drizzle database registered in DI container");
+  }
+  async shutdown() {
+    this.onShutdown && (await this.onShutdown(), h.info("Drizzle connection closed"));
+  }
+};
+function b(e) {
+  return {
+    filterable: Object.keys(e.columns),
+    sortable: e.sortable ? Object.keys(e.sortable) : [],
+    searchable: e.searchColumns ? e.searchColumns.map((t) => t.name ?? "").filter(Boolean) : []
+  };
+}
+var m = class {
+  name = "DrizzleQueryAdapter";
+  constructor(e) {
+    this.ops = e;
+  }
+  build(e, t = {}) {
+    const s = {
+      orderBy: [],
+      limit: e.pagination.limit,
+      offset: e.pagination.offset
+    }, r = [];
+    for (const o of e.filters) {
+      const i = this.buildFilter(t.table, o);
+      i && r.push(i);
+    }
+    if (e.search && t.searchColumns && t.searchColumns.length > 0) {
+      const o = t.searchColumns.filter((i) => t.table[i]).map((i) => this.ops.ilike(t.table[i], `%${e.search}%`));
+      o.length > 0 && r.push(this.ops.or(...o));
+    }
+    return r.length === 1 ? s.where = r[0] : r.length > 1 && (s.where = this.ops.and(...r)), s.orderBy = this.buildSort(t.table, e.sort), s;
+  }
+  buildFromColumns(e, t) {
+    const s = {
+      orderBy: [],
+      limit: e.pagination.limit,
+      offset: e.pagination.offset
+    }, r = [];
+    t.baseCondition && r.push(t.baseCondition);
+    for (const i of e.filters) {
+      const n = t.columns[i.field];
+      if (!n) continue;
+      const a = this.buildColumnFilter(n, i);
+      a && r.push(a);
+    }
+    if (e.search && t.searchColumns && t.searchColumns.length > 0) {
+      const i = t.searchColumns.map((n) => this.ops.ilike(n, `%${e.search}%`));
+      i.length > 0 && r.push(this.ops.or(...i));
+    }
+    r.length === 1 ? s.where = r[0] : r.length > 1 && (s.where = this.ops.and(...r));
+    const o = t.sortable ?? t.columns;
+    return s.orderBy = e.sort.filter((i) => o[i.field]).map((i) => i.direction === "desc" ? this.ops.desc(o[i.field]) : this.ops.asc(o[i.field])), s;
+  }
+  buildFilter(e, t) {
+    const s = e[t.field];
+    if (!s) return null;
+    const r = this.coerce(t.value);
+    switch (t.operator) {
+      case "eq":
+        return this.ops.eq(s, r);
+      case "neq":
+        return this.ops.ne(s, r);
+      case "gt":
+        return this.ops.gt(s, r);
+      case "gte":
+        return this.ops.gte(s, r);
+      case "lt":
+        return this.ops.lt(s, r);
+      case "lte":
+        return this.ops.lte(s, r);
+      case "contains":
+        return this.ops.ilike(s, `%${t.value}%`);
+      case "starts":
+        return this.ops.ilike(s, `${t.value}%`);
+      case "ends":
+        return this.ops.ilike(s, `%${t.value}`);
+      case "in": {
+        const o = t.value.split(",").map((i) => this.coerce(i.trim()));
+        return this.ops.inArray(s, o);
+      }
+      case "between": {
+        const [o, i] = t.value.split(",").map((n) => this.coerce(n.trim()));
+        return this.ops.and(this.ops.gte(s, o), this.ops.lte(s, i));
+      }
+      default:
+        return this.ops.eq(s, r);
+    }
+  }
+  buildColumnFilter(e, t) {
+    const s = this.coerceByDataType(t.value, e.dataType);
+    switch (t.operator) {
+      case "eq":
+        return this.ops.eq(e, s);
+      case "neq":
+        return this.ops.ne(e, s);
+      case "gt":
+        return this.ops.gt(e, s);
+      case "gte":
+        return this.ops.gte(e, s);
+      case "lt":
+        return this.ops.lt(e, s);
+      case "lte":
+        return this.ops.lte(e, s);
+      case "contains":
+        return this.ops.ilike(e, `%${t.value}%`);
+      case "starts":
+        return this.ops.ilike(e, `${t.value}%`);
+      case "ends":
+        return this.ops.ilike(e, `%${t.value}`);
+      case "in": {
+        const r = t.value.split(",").map((o) => this.coerceByDataType(o.trim(), e.dataType));
+        return this.ops.inArray(e, r);
+      }
+      case "between": {
+        const [r, o] = t.value.split(",").map((a) => a.trim()), i = this.coerceByDataType(r, e.dataType), n = this.coerceByDataType(o, e.dataType);
+        return this.ops.between ? this.ops.between(e, i, n) : this.ops.and(this.ops.gte(e, i), this.ops.lte(e, n));
+      }
+      default:
+        return this.ops.eq(e, s);
+    }
+  }
+  buildSort(e, t) {
+    return t.filter((s) => e[s.field]).map((s) => s.direction === "desc" ? this.ops.desc(e[s.field]) : this.ops.asc(e[s.field]));
+  }
+  coerce(e) {
+    if (e === "true") return !0;
+    if (e === "false") return !1;
+    const t = Number(e);
+    return !Number.isNaN(t) && e.trim() !== "" ? t : e;
+  }
+  coerceByDataType(e, t) {
+    if (!t) return this.coerce(e);
+    switch (t) {
+      case "boolean":
+        return e === "true" || e === "1";
+      case "number":
+      case "bigint": {
+        const s = Number(e);
+        return Number.isNaN(s) ? e : s;
+      }
+      case "date":
+      case "localDate":
+      case "localDateTime": {
+        const s = new Date(e);
+        return Number.isNaN(s.getTime()) ? e : s;
+      }
+      default:
+        return e;
+    }
+  }
+};
+export {
+  u as DRIZZLE_DB,
+  d as DrizzleAdapter,
+  m as DrizzleQueryAdapter,
+  b as toQueryFieldConfig
+};

package/dist/query-adapter.d.ts

@@ -0,0 +1,241 @@
+import type { QueryBuilderAdapter, ParsedQuery } from '@forinda/kickjs-http';
+/**
+ * Configuration for the Drizzle query builder adapter.
+ *
+ * Unlike Prisma which uses its own query builder API, Drizzle uses SQL-like
+ * operators (`eq`, `gt`, `like`, etc.) from `drizzle-orm`. This adapter
+ * produces a config object that can be spread into Drizzle's `select().from().where()`.
+ */
+export interface DrizzleQueryConfig {
+    /** The Drizzle table schema object (e.g., `users` from your schema) */
+    table: Record<string, any>;
+    /** Columns to search across when a search string is provided */
+    searchColumns?: string[];
+}
+/**
+ * Type-safe Drizzle query configuration using Column objects.
+ *
+ * Use this instead of `DrizzleQueryConfig` for type-safe column references
+ * that are validated at compile time. Column objects carry `dataType` metadata
+ * enabling automatic type coercion of filter values.
+ *
+ * @example
+ * ```ts
+ * import { users } from './schema'
+ * import type { DrizzleColumnQueryConfig } from '@forinda/kickjs-drizzle'
+ *
+ * const config: DrizzleColumnQueryConfig = {
+ *   columns: {
+ *     status: users.status,
+ *     isActive: users.isActive,
+ *     createdAt: users.createdAt,
+ *   },
+ *   sortable: {
+ *     name: users.name,
+ *     createdAt: users.createdAt,
+ *   },
+ *   searchColumns: [users.firstName, users.lastName, users.email],
+ *   baseCondition: eq(users.tenantId, tenantId),
+ * }
+ * ```
+ */
+export interface DrizzleColumnQueryConfig {
+    /**
+     * Map of filterable field names to Drizzle Column objects.
+     * Keys are the query parameter names, values are the actual schema columns.
+     * The column's `dataType` is used for automatic type coercion.
+     */
+    columns: Record<string, any>;
+    /**
+     * Map of sortable field names to Drizzle Column objects.
+     * If not provided, falls back to `columns` for sort lookups.
+     */
+    sortable?: Record<string, any>;
+    /**
+     * Column objects to search across when a search string is provided.
+     * Each entry should be a Drizzle Column (not a string).
+     */
+    searchColumns?: any[];
+    /**
+     * A pre-built SQL condition that is always prepended to the WHERE clause.
+     * Use for scoping queries by tenant, workspace, or other invariants.
+     *
+     * @example
+     * ```ts
+     * baseCondition: and(eq(tasks.tenantId, tid), eq(tasks.workspaceId, wid))
+     * ```
+     */
+    baseCondition?: any;
+}
+/**
+ * Configuration type for defining query param schemas with Drizzle Column objects.
+ *
+ * Used in constants files to define which columns are filterable, sortable, and searchable.
+ * This type is consumed by both `DrizzleQueryAdapter.buildFromColumns()` and `@ApiQueryParams()`.
+ *
+ * @example
+ * ```ts
+ * import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
+ * import { tasks } from '@/db/schema'
+ *
+ * export const TASK_QUERY_CONFIG: DrizzleQueryParamsConfig = {
+ *   columns: {
+ *     status: tasks.status,
+ *     priority: tasks.priority,
+ *   },
+ *   sortable: {
+ *     title: tasks.title,
+ *     createdAt: tasks.createdAt,
+ *   },
+ *   searchColumns: [tasks.title, tasks.key],
+ * }
+ * ```
+ */
+export interface DrizzleQueryParamsConfig {
+    /** Filterable columns: keys are query param names, values are Drizzle Column objects */
+    columns: Record<string, any>;
+    /** Sortable columns: keys are query param names, values are Drizzle Column objects */
+    sortable?: Record<string, any>;
+    /** Columns for text search */
+    searchColumns?: any[];
+    /** Optional base condition for scoping (tenant, workspace, etc.) */
+    baseCondition?: any;
+}
+/**
+ * Convert a DrizzleQueryParamsConfig into a string-based QueryFieldConfig.
+ * Useful for passing to `@ApiQueryParams()` or other APIs that expect string arrays.
+ *
+ * @example
+ * ```ts
+ * import { toQueryFieldConfig } from '@forinda/kickjs-drizzle'
+ *
+ * const fieldConfig = toQueryFieldConfig(TASK_QUERY_CONFIG)
+ * // → { filterable: ['status', 'priority'], sortable: ['title', 'createdAt'], searchable: [] }
+ * ```
+ */
+export declare function toQueryFieldConfig(config: DrizzleQueryParamsConfig): {
+    filterable: string[];
+    sortable: string[];
+    searchable: string[];
+};
+/**
+ * Result shape compatible with Drizzle's query builder.
+ * Use with `db.select().from(table).where(result.where).orderBy(...result.orderBy).limit(result.limit).offset(result.offset)`
+ */
+export interface DrizzleQueryResult {
+    /** SQL condition — pass to `.where()` */
+    where?: any;
+    /** Array of order expressions — spread into `.orderBy()` */
+    orderBy: any[];
+    /** Row limit — pass to `.limit()` */
+    limit: number;
+    /** Row offset — pass to `.offset()` */
+    offset: number;
+}
+/**
+ * Drizzle operator functions required by the query adapter.
+ * Pass these from your `drizzle-orm` import to avoid version coupling.
+ *
+ * @example
+ * ```ts
+ * import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc } from 'drizzle-orm'
+ *
+ * const adapter = new DrizzleQueryAdapter({
+ *   eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
+ * })
+ * ```
+ */
+export interface DrizzleOps {
+    eq: (column: any, value: any) => any;
+    ne: (column: any, value: any) => any;
+    gt: (column: any, value: any) => any;
+    gte: (column: any, value: any) => any;
+    lt: (column: any, value: any) => any;
+    lte: (column: any, value: any) => any;
+    ilike: (column: any, value: string) => any;
+    inArray: (column: any, values: any[]) => any;
+    between?: (column: any, min: any, max: any) => any;
+    and: (...conditions: any[]) => any;
+    or: (...conditions: any[]) => any;
+    asc: (column: any) => any;
+    desc: (column: any) => any;
+}
+/**
+ * Translates a ParsedQuery into Drizzle-compatible query parts.
+ *
+ * Supports two modes:
+ * 1. **String-based** (legacy): `build(parsed, { table, searchColumns })` — looks up columns by string name
+ * 2. **Column-based** (recommended): `buildFromColumns(parsed, config)` — uses actual Column objects for type safety
+ *
+ * @example
+ * ```ts
+ * // String-based (legacy)
+ * const query = adapter.build(parsed, { table: users, searchColumns: ['name', 'email'] })
+ *
+ * // Column-based (recommended)
+ * const query = adapter.buildFromColumns(parsed, {
+ *   columns: { status: users.status, isActive: users.isActive },
+ *   searchColumns: [users.name, users.email],
+ *   baseCondition: eq(users.tenantId, tid),
+ * })
+ *
+ * const results = await db
+ *   .select().from(users)
+ *   .where(query.where)
+ *   .orderBy(...query.orderBy)
+ *   .limit(query.limit)
+ *   .offset(query.offset)
+ * ```
+ */
+export declare class DrizzleQueryAdapter implements QueryBuilderAdapter<DrizzleQueryResult, DrizzleQueryConfig> {
+    private ops;
+    readonly name = "DrizzleQueryAdapter";
+    constructor(ops: DrizzleOps);
+    /**
+     * Build query from string-based config (legacy API).
+     * Prefer `buildFromColumns()` for type safety.
+     */
+    build(parsed: ParsedQuery, config?: DrizzleQueryConfig): DrizzleQueryResult;
+    /**
+     * Build query using Column objects for type-safe filtering, sorting, and search.
+     *
+     * Features over `build()`:
+     * - Column references validated at compile time
+     * - Automatic type coercion based on `column.dataType` (boolean, number, date)
+     * - `baseCondition` support for tenant/workspace scoping
+     * - Native `between` operator support
+     * - Separate `sortable` map so filterable and sortable columns can differ
+     *
+     * @example
+     * ```ts
+     * const query = adapter.buildFromColumns(parsed, {
+     *   columns: { status: tasks.status, priority: tasks.priority },
+     *   sortable: { title: tasks.title, createdAt: tasks.createdAt },
+     *   searchColumns: [tasks.title, tasks.key],
+     *   baseCondition: eq(tasks.workspaceId, wid),
+     * })
+     * ```
+     */
+    buildFromColumns(parsed: ParsedQuery, config: DrizzleColumnQueryConfig): DrizzleQueryResult;
+    /** Map a single FilterItem to a Drizzle condition using string-based table lookup */
+    private buildFilter;
+    /**
+     * Map a FilterItem to a Drizzle condition using a Column object.
+     * Coerces values based on `column.dataType` for type-safe filtering.
+     */
+    private buildColumnFilter;
+    /** Build Drizzle orderBy from SortItem[] */
+    private buildSort;
+    /** Attempt to coerce a string value to a number or boolean if appropriate */
+    private coerce;
+    /**
+     * Coerce a string value based on the column's dataType.
+     *
+     * - `'boolean'` → `true`/`false`
+     * - `'number'` / `'bigint'` → `Number(value)`
+     * - `'date'` → `new Date(value)` (ISO 8601 strings)
+     * - Everything else → original string
+     */
+    private coerceByDataType;
+}
+//# sourceMappingURL=query-adapter.d.ts.map

package/dist/query-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-adapter.d.ts","sourceRoot":"","sources":["../src/query-adapter.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+import type { MaybePromise } from '@forinda/kickjs-core';
+/** DI token for resolving the Drizzle database instance from the container */
+export declare const DRIZZLE_DB: unique symbol;
+export interface DrizzleAdapterOptions<TDb = unknown> {
+    /**
+     * Drizzle database instance — the return value of `drizzle()`.
+     * Preserves the full type so services can inject it type-safely.
+     *
+     * @example
+     * ```ts
+     * import { drizzle } from 'drizzle-orm/better-sqlite3'
+     * import * as schema from './schema'
+     *
+     * const db = drizzle({ client: sqlite, schema })
+     * // db is BetterSQLite3Database<typeof schema>
+     *
+     * new DrizzleAdapter({ db })
+     * // TDb is inferred as BetterSQLite3Database<typeof schema>
+     * ```
+     */
+    db: TDb;
+    /** Enable query logging (default: false) */
+    logging?: boolean;
+    /**
+     * Optional shutdown function to close the underlying connection pool.
+     * Drizzle doesn't expose a universal disconnect — this lets you pass your
+     * driver's cleanup (e.g., `pool.end()` for postgres, `client.close()` for libsql).
+     *
+     * @example
+     * ```ts
+     * const pool = new Pool({ connectionString: '...' })
+     * const db = drizzle(pool)
+     *
+     * new DrizzleAdapter({
+     *   db,
+     *   onShutdown: () => pool.end(),
+     * })
+     * ```
+     */
+    onShutdown?: () => MaybePromise<any>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,8EAA8E;AAC9E,eAAO,MAAM,UAAU,eAAsB,CAAA;AAE7C,MAAM,WAAW,qBAAqB,CAAC,GAAG,GAAG,OAAO;IAClD;;;;;;;;;;;;;;;OAeG;IACH,EAAE,EAAE,GAAG,CAAA;IAEP,4CAA4C;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,EAAE,MAAM,YAAY,CAAC,GAAG,CAAC,CAAA;CACrC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forinda/kickjs-drizzle",
-  "version": "1.3.2",
+  "version": "1.4.1-alpha.0",
   "description": "Drizzle ORM adapter with DI integration, transaction support, and query building for KickJS",
   "keywords": [
     "kickjs",
@@ -37,7 +37,8 @@
     "@forinda/kickjs-queue",
     "@forinda/kickjs-multi-tenant",
     "@forinda/kickjs-devtools",
-    "@forinda/kickjs-notifications"
+    "@forinda/kickjs-notifications",
+    "vite"
   ],
   "type": "module",
   "main": "dist/index.js",
@@ -53,15 +54,14 @@
   ],
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@forinda/kickjs-core": "1.3.2",
-    "@forinda/kickjs-http": "1.3.2"
+    "@forinda/kickjs-core": "1.4.1-alpha.0",
+    "@forinda/kickjs-http": "1.4.1-alpha.0"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.30.0"
   },
   "devDependencies": {
-    "@types/node": "^24.5.2",
-    "tsup": "^8.5.0",
+    "@types/node": "^25.0.0",
     "typescript": "^5.9.2"
   },
   "publishConfig": {
@@ -82,8 +82,9 @@
     "url": "https://github.com/forinda/kick-js/issues"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "vite build && pnpm build:types",
+    "build:types": "tsc -p tsconfig.build.json",
+    "dev": "vite build --watch",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist .turbo",
     "lint": "tsc --noEmit"