@forinda/kickjs-drizzle 2.0.1 → 2.2.0

package/dist/index.d.mts

@@ -0,0 +1,340 @@
+
+import { AdapterContext, AppAdapter, MaybePromise, ParsedQuery, QueryBuilderAdapter } from "@forinda/kickjs";
+
+//#region src/types.d.ts
+/** 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>;
+}
+//#endregion
+//#region src/drizzle.adapter.d.ts
+/**
+ * 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({
+    container
+  }: AdapterContext): void;
+  /** Close the underlying connection on shutdown */
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/query-adapter.d.ts
+/**
+ * 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;
+}
+//#endregion
+export { DRIZZLE_DB, DrizzleAdapter, type DrizzleAdapterOptions, type DrizzleColumnQueryConfig, type DrizzleOps, DrizzleQueryAdapter, type DrizzleQueryConfig, type DrizzleQueryParamsConfig, type DrizzleQueryResult, toQueryFieldConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/drizzle.adapter.ts","../src/query-adapter.ts"],"mappings":";;;;;cAGa,UAAA;AAAA,UAEI,qBAAA;EAF4B;;;;AAE7C;;;;;;;;;;;;EAiBE,EAAA,EAAI,GAAA;;EAGJ,OAAA;ECiBW;;;;;;;;;;;;;;;;EDCX,UAAA,SAAmB,YAAA;AAAA;;;;AAxCrB;;;;;AAEA;;;;;;;;;;;;;;;ACqCA;;;;;;;;;;;;;;;;cAAa,cAAA,2BAAyC,UAAA;EAAA,QAKhC,OAAA;EAJpB,IAAA;EAAA,QACQ,EAAA;EAAA,QACA,UAAA;cAEY,OAAA,EAAS,qBAAA,CAAsB,GAAA;EAMrC;EAAd,WAAA,CAAA;IAAc;EAAA,GAAa,cAAA;EAAA;EAWrB,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;AD7DpB;;;;;UEMiB,kBAAA;EFJqB;EEMpC,KAAA,EAAO,MAAA;EFgCwB;EE9B/B,aAAA;AAAA;;;;;;;;;;AD6BF;;;;;;;;;;;;;;;;;;UCCiB,wBAAA;EDIoC;;;;;ECEnD,OAAA,EAAS,MAAA;EDeH;;;;ECTN,QAAA,GAAW,MAAA;;;AA9Cb;;EAoDE,aAAA;EAlDa;;;;;;AAgCf;;;EA6BE,aAAA;AAAA;;;;;;;;AA2BF;;;;;;;;;;;;AAuBA;;;;;UAvBiB,wBAAA;EAwBf;EAtBA,OAAA,EAAS,MAAA;EAwBT;EAtBA,QAAA,GAAW,MAAA;EAsBD;EApBV,aAAA;EAmCiC;EAjCjC,aAAA;AAAA;;;;;;;AAyDF;;;;;;iBA1CgB,kBAAA,CAAmB,MAAA,EAAQ,wBAAA;EACzC,UAAA;EACA,QAAA;EACA,UAAA;AAAA;;;;;UAee,kBAAA;EA6Bf;EA3BA,KAAA;EA2BkB;EAzBlB,OAAA;EA0BM;EAxBN,KAAA;EAyBA;EAvBA,MAAA;AAAA;;;;;;;;;;;;;;UAgBe,UAAA;EACf,EAAA,GAAK,MAAA,OAAa,KAAA;EAClB,EAAA,GAAK,MAAA,OAAa,KAAA;EAClB,EAAA,GAAK,MAAA,OAAa,KAAA;EAClB,GAAA,GAAM,MAAA,OAAa,KAAA;EACnB,EAAA,GAAK,MAAA,OAAa,KAAA;EAClB,GAAA,GAAM,MAAA,OAAa,KAAA;EACnB,KAAA,GAAQ,MAAA,OAAa,KAAA;EACrB,OAAA,GAAU,MAAA,OAAa,MAAA;EACvB,OAAA,IAAW,MAAA,OAAa,GAAA,OAAU,GAAA;EAClC,GAAA,MAAS,UAAA;EACT,EAAA,MAAQ,UAAA;EACR,GAAA,GAAM,MAAA;EACN,IAAA,GAAO,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BI,mBAAA,YAA+B,mBAAA,CAC1C,kBAAA,EACA,kBAAA;EAAA,QAIoB,GAAA;EAAA,SAFX,IAAA;cAEW,GAAA,EAAK,UAAA;;;;;EAMzB,KAAA,CACE,MAAA,EAAQ,WAAA,EACR,MAAA,GAAQ,kBAAA,GACP,kBAAA;;;;;;;;;;;;;;;;;;;;;EA4DH,gBAAA,CAAiB,MAAA,EAAQ,WAAA,EAAa,MAAA,EAAQ,wBAAA,GAA2B,kBAAA;;UAqDjE,WAAA;;;;;UA0CA,iBAAA;;UA2CA,SAAA;;UAWA,MAAA;;;;;;;;;UAgBA,gBAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,297 @@
+/**
+ * @forinda/kickjs-drizzle v2.2.0
+ *
+ * Copyright (c) Felix Orinda
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { Logger, Scope } from "@forinda/kickjs";
+//#region src/types.ts
+/** DI token for resolving the Drizzle database instance from the container */
+const DRIZZLE_DB = Symbol("DrizzleDB");
+//#endregion
+//#region src/drizzle.adapter.ts
+const log = Logger.for("DrizzleAdapter");
+/**
+* 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>) {}
+* }
+* ```
+*/
+var DrizzleAdapter = class {
+	name = "DrizzleAdapter";
+	db;
+	onShutdown;
+	constructor(options) {
+		this.options = options;
+		this.db = options.db;
+		this.onShutdown = options.onShutdown;
+	}
+	/** Register the Drizzle db instance in the DI container */
+	beforeStart({ container }) {
+		if (this.options.logging) log.info("Query logging enabled");
+		container.registerFactory(DRIZZLE_DB, () => this.db, Scope.SINGLETON);
+		log.info("Drizzle database registered in DI container");
+	}
+	/** Close the underlying connection on shutdown */
+	async shutdown() {
+		if (this.onShutdown) {
+			await this.onShutdown();
+			log.info("Drizzle connection closed");
+		}
+	}
+};
+//#endregion
+//#region src/query-adapter.ts
+/**
+* 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: [] }
+* ```
+*/
+function toQueryFieldConfig(config) {
+	return {
+		filterable: Object.keys(config.columns),
+		sortable: config.sortable ? Object.keys(config.sortable) : [],
+		searchable: config.searchColumns ? config.searchColumns.map((col) => col.name ?? "").filter(Boolean) : []
+	};
+}
+/**
+* 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)
+* ```
+*/
+var DrizzleQueryAdapter = class {
+	name = "DrizzleQueryAdapter";
+	constructor(ops) {
+		this.ops = ops;
+	}
+	/**
+	* Build query from string-based config (legacy API).
+	* Prefer `buildFromColumns()` for type safety.
+	*/
+	build(parsed, config = {}) {
+		const result = {
+			orderBy: [],
+			limit: parsed.pagination.limit,
+			offset: parsed.pagination.offset
+		};
+		const conditions = [];
+		for (const filter of parsed.filters) {
+			const condition = this.buildFilter(config.table, filter);
+			if (condition) conditions.push(condition);
+		}
+		if (parsed.search && config.searchColumns && config.searchColumns.length > 0) {
+			const searchConditions = config.searchColumns.filter((col) => config.table[col]).map((col) => this.ops.ilike(config.table[col], `%${parsed.search}%`));
+			if (searchConditions.length > 0) conditions.push(this.ops.or(...searchConditions));
+		}
+		if (conditions.length === 1) result.where = conditions[0];
+		else if (conditions.length > 1) result.where = this.ops.and(...conditions);
+		result.orderBy = this.buildSort(config.table, parsed.sort);
+		return result;
+	}
+	/**
+	* 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, config) {
+		const result = {
+			orderBy: [],
+			limit: parsed.pagination.limit,
+			offset: parsed.pagination.offset
+		};
+		const conditions = [];
+		if (config.baseCondition) conditions.push(config.baseCondition);
+		for (const filter of parsed.filters) {
+			const column = config.columns[filter.field];
+			if (!column) continue;
+			const condition = this.buildColumnFilter(column, filter);
+			if (condition) conditions.push(condition);
+		}
+		if (parsed.search && config.searchColumns && config.searchColumns.length > 0) {
+			const searchConditions = config.searchColumns.map((col) => this.ops.ilike(col, `%${parsed.search}%`));
+			if (searchConditions.length > 0) conditions.push(this.ops.or(...searchConditions));
+		}
+		if (conditions.length === 1) result.where = conditions[0];
+		else if (conditions.length > 1) result.where = this.ops.and(...conditions);
+		const sortMap = config.sortable ?? config.columns;
+		result.orderBy = parsed.sort.filter((item) => sortMap[item.field]).map((item) => item.direction === "desc" ? this.ops.desc(sortMap[item.field]) : this.ops.asc(sortMap[item.field]));
+		return result;
+	}
+	/** Map a single FilterItem to a Drizzle condition using string-based table lookup */
+	buildFilter(table, filter) {
+		const column = table[filter.field];
+		if (!column) return null;
+		const value = this.coerce(filter.value);
+		switch (filter.operator) {
+			case "eq": return this.ops.eq(column, value);
+			case "neq": return this.ops.ne(column, value);
+			case "gt": return this.ops.gt(column, value);
+			case "gte": return this.ops.gte(column, value);
+			case "lt": return this.ops.lt(column, value);
+			case "lte": return this.ops.lte(column, value);
+			case "contains": return this.ops.ilike(column, `%${filter.value}%`);
+			case "starts": return this.ops.ilike(column, `${filter.value}%`);
+			case "ends": return this.ops.ilike(column, `%${filter.value}`);
+			case "in": {
+				const values = filter.value.split(",").map((v) => this.coerce(v.trim()));
+				return this.ops.inArray(column, values);
+			}
+			case "between": {
+				const [min, max] = filter.value.split(",").map((v) => this.coerce(v.trim()));
+				return this.ops.and(this.ops.gte(column, min), this.ops.lte(column, max));
+			}
+			default: return this.ops.eq(column, value);
+		}
+	}
+	/**
+	* Map a FilterItem to a Drizzle condition using a Column object.
+	* Coerces values based on `column.dataType` for type-safe filtering.
+	*/
+	buildColumnFilter(column, filter) {
+		const value = this.coerceByDataType(filter.value, column.dataType);
+		switch (filter.operator) {
+			case "eq": return this.ops.eq(column, value);
+			case "neq": return this.ops.ne(column, value);
+			case "gt": return this.ops.gt(column, value);
+			case "gte": return this.ops.gte(column, value);
+			case "lt": return this.ops.lt(column, value);
+			case "lte": return this.ops.lte(column, value);
+			case "contains": return this.ops.ilike(column, `%${filter.value}%`);
+			case "starts": return this.ops.ilike(column, `${filter.value}%`);
+			case "ends": return this.ops.ilike(column, `%${filter.value}`);
+			case "in": {
+				const values = filter.value.split(",").map((v) => this.coerceByDataType(v.trim(), column.dataType));
+				return this.ops.inArray(column, values);
+			}
+			case "between": {
+				const [minStr, maxStr] = filter.value.split(",").map((v) => v.trim());
+				const min = this.coerceByDataType(minStr, column.dataType);
+				const max = this.coerceByDataType(maxStr, column.dataType);
+				if (this.ops.between) return this.ops.between(column, min, max);
+				return this.ops.and(this.ops.gte(column, min), this.ops.lte(column, max));
+			}
+			default: return this.ops.eq(column, value);
+		}
+	}
+	/** Build Drizzle orderBy from SortItem[] */
+	buildSort(table, sort) {
+		return sort.filter((item) => table[item.field]).map((item) => item.direction === "desc" ? this.ops.desc(table[item.field]) : this.ops.asc(table[item.field]));
+	}
+	/** Attempt to coerce a string value to a number or boolean if appropriate */
+	coerce(value) {
+		if (value === "true") return true;
+		if (value === "false") return false;
+		const num = Number(value);
+		if (!Number.isNaN(num) && value.trim() !== "") return num;
+		return value;
+	}
+	/**
+	* 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
+	*/
+	coerceByDataType(value, dataType) {
+		if (!dataType) return this.coerce(value);
+		switch (dataType) {
+			case "boolean": return value === "true" || value === "1";
+			case "number":
+			case "bigint": {
+				const num = Number(value);
+				return Number.isNaN(num) ? value : num;
+			}
+			case "date":
+			case "localDate":
+			case "localDateTime": {
+				const date = new Date(value);
+				return Number.isNaN(date.getTime()) ? value : date;
+			}
+			default: return value;
+		}
+	}
+};
+//#endregion
+export { DRIZZLE_DB, DrizzleAdapter, DrizzleQueryAdapter, toQueryFieldConfig };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forinda/kickjs-drizzle",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "Drizzle ORM adapter with DI integration, transaction support, and query building for KickJS",
   "keywords": [
     "kickjs",
@@ -41,20 +41,37 @@
     "vite"
   ],
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
     }
   },
   "files": [
     "dist"
   ],
+  "wireit": {
+    "build": {
+      "command": "tsdown",
+      "files": [
+        "src/**/*.ts",
+        "tsdown.config.ts",
+        "tsconfig.json",
+        "package.json"
+      ],
+      "output": [
+        "dist/**"
+      ],
+      "dependencies": [
+        "../core:build"
+      ]
+    }
+  },
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@forinda/kickjs": "2.0.1"
+    "@forinda/kickjs": "2.2.0"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.30.0"
@@ -81,11 +98,11 @@
     "url": "https://github.com/forinda/kick-js/issues"
   },
   "scripts": {
-    "build": "vite build && pnpm build:types",
-    "build:types": "tsc -p tsconfig.build.json",
-    "dev": "vite build --watch",
+    "build": "wireit",
+    "dev": "tsdown --watch",
+    "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist .turbo",
+    "clean": "rm -rf dist .wireit",
     "lint": "tsc --noEmit"
   }
 }

package/dist/drizzle.adapter.d.ts

@@ -1,51 +0,0 @@
-import { type AppAdapter, type AdapterContext } from '@forinda/kickjs';
-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({ container }: AdapterContext): void;
-    /** Close the underlying connection on shutdown */
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=drizzle.adapter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drizzle.adapter.d.ts","sourceRoot":"","sources":["../src/drizzle.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,UAAU,EAAE,KAAK,cAAc,EAAS,MAAM,iBAAiB,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,EAAE,SAAS,EAAE,EAAE,cAAc,GAAG,IAAI;IAUhD,kDAAkD;IAC5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAMhC"}

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,168 +0,0 @@
-import { Logger as l, Scope as c } from "@forinda/kickjs";
-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({ container: e }) {
-    this.options.logging && h.info("Query logging enabled"), e.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((s) => s.name ?? "").filter(Boolean) : []
-  };
-}
-var m = class {
-  name = "DrizzleQueryAdapter";
-  constructor(e) {
-    this.ops = e;
-  }
-  build(e, s = {}) {
-    const t = {
-      orderBy: [],
-      limit: e.pagination.limit,
-      offset: e.pagination.offset
-    }, r = [];
-    for (const o of e.filters) {
-      const i = this.buildFilter(s.table, o);
-      i && r.push(i);
-    }
-    if (e.search && s.searchColumns && s.searchColumns.length > 0) {
-      const 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) {
-    const t = {
-      orderBy: [],
-      limit: e.pagination.limit,
-      offset: e.pagination.offset
-    }, r = [];
-    s.baseCondition && r.push(s.baseCondition);
-    for (const i of e.filters) {
-      const n = s.columns[i.field];
-      if (!n) continue;
-      const a = this.buildColumnFilter(n, i);
-      a && r.push(a);
-    }
-    if (e.search && s.searchColumns && s.searchColumns.length > 0) {
-      const i = s.searchColumns.map((n) => this.ops.ilike(n, `%${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));
-    const 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) {
-    const t = e[s.field];
-    if (!t) return null;
-    const 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": {
-        const o = s.value.split(",").map((i) => this.coerce(i.trim()));
-        return this.ops.inArray(t, o);
-      }
-      case "between": {
-        const [o, i] = s.value.split(",").map((n) => this.coerce(n.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) {
-    const 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": {
-        const r = s.value.split(",").map((o) => this.coerceByDataType(o.trim(), e.dataType));
-        return this.ops.inArray(e, r);
-      }
-      case "between": {
-        const [r, o] = s.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, 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;
-    const 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": {
-        const t = Number(e);
-        return Number.isNaN(t) ? e : t;
-      }
-      case "date":
-      case "localDate":
-      case "localDateTime": {
-        const t = new Date(e);
-        return Number.isNaN(t.getTime()) ? e : t;
-      }
-      default:
-        return e;
-    }
-  }
-};
-export {
-  u as DRIZZLE_DB,
-  d as DrizzleAdapter,
-  m as DrizzleQueryAdapter,
-  b as toQueryFieldConfig
-};

package/dist/query-adapter.d.ts

@@ -1,241 +0,0 @@
-import type { QueryBuilderAdapter, ParsedQuery } from '@forinda/kickjs';
-/**
- * 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

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

package/dist/types.d.ts

@@ -1,42 +0,0 @@
-import type { MaybePromise } from '@forinda/kickjs';
-/** 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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD,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"}