@forinda/kickjs-prisma 2.0.1 → 2.2.0

package/dist/index.d.mts

@@ -0,0 +1,172 @@
+
+import { AdapterContext, AppAdapter, ParsedQuery, QueryBuilderAdapter } from "@forinda/kickjs";
+
+//#region src/types.d.ts
+interface PrismaAdapterOptions {
+  /**
+   * PrismaClient instance — typed as `any` to avoid version coupling.
+   *
+   * Prisma 5/6: `new PrismaClient()` from `@prisma/client`
+   * Prisma 7+:  `new PrismaClient({ adapter })` from your generated output path
+   */
+  client: any;
+  /**
+   * Enable query logging (default: false).
+   * Uses `$on('query', ...)` for Prisma 5/6 and `$extends` for Prisma 7+.
+   */
+  logging?: boolean;
+}
+/** DI token for resolving the PrismaClient from the container */
+declare const PRISMA_CLIENT: unique symbol;
+/**
+ * Common Prisma model delegate operations.
+ * Use this to type-narrow the injected PrismaClient to a specific model
+ * without needing `as any` casts in repositories.
+ *
+ * @example
+ * ```ts
+ * @Repository()
+ * export class PrismaUserRepository {
+ *   @Inject(PRISMA_CLIENT) private prisma!: { user: PrismaModelDelegate }
+ *
+ *   async findById(id: string) {
+ *     return this.prisma.user.findUnique({ where: { id } })
+ *   }
+ * }
+ * ```
+ */
+interface PrismaModelDelegate {
+  findUnique(args: {
+    where: Record<string, unknown>;
+    include?: Record<string, unknown>;
+  }): Promise<unknown>;
+  findFirst?(args?: Record<string, unknown>): Promise<unknown>;
+  findMany(args?: Record<string, unknown>): Promise<unknown[]>;
+  create(args: {
+    data: Record<string, unknown>;
+  }): Promise<unknown>;
+  update(args: {
+    where: Record<string, unknown>;
+    data: Record<string, unknown>;
+  }): Promise<unknown>;
+  delete(args: {
+    where: Record<string, unknown>;
+  }): Promise<unknown>;
+  deleteMany(args?: {
+    where?: Record<string, unknown>;
+  }): Promise<{
+    count: number;
+  }>;
+  count(args?: {
+    where?: Record<string, unknown>;
+  }): Promise<number>;
+}
+//#endregion
+//#region src/prisma.adapter.d.ts
+/**
+ * Prisma adapter — registers a PrismaClient in the DI container and manages
+ * its lifecycle (connection setup and teardown).
+ *
+ * Works with Prisma 5, 6, and 7+.
+ *
+ * @example Prisma 5/6
+ * ```ts
+ * import { PrismaClient } from '@prisma/client'
+ *
+ * new PrismaAdapter({ client: new PrismaClient(), logging: true })
+ * ```
+ *
+ * @example Prisma 7+ (driver adapters)
+ * ```ts
+ * import { PrismaClient } from './generated/prisma'
+ * import { PrismaPg } from '@prisma/adapter-pg'
+ * import pg from 'pg'
+ *
+ * const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })
+ * const client = new PrismaClient({ adapter: new PrismaPg(pool) })
+ * new PrismaAdapter({ client, logging: true })
+ * ```
+ *
+ * Inject the client in services:
+ * ```ts
+ * @Service()
+ * class UserService {
+ *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
+ * }
+ * ```
+ */
+declare class PrismaAdapter implements AppAdapter {
+  private options;
+  name: string;
+  private client;
+  constructor(options: PrismaAdapterOptions);
+  /** Register the PrismaClient in the DI container */
+  beforeStart({
+    container
+  }: AdapterContext): void;
+  /** Disconnect the PrismaClient on shutdown */
+  shutdown(): Promise<void>;
+}
+//#endregion
+//#region src/query-adapter.d.ts
+/**
+ * Configuration for the Prisma query builder adapter.
+ *
+ * Use the generic parameter to constrain `searchColumns` to actual model field names:
+ *
+ * @example
+ * ```ts
+ * import type { User } from '@prisma/client'
+ *
+ * // Type-safe — only User field names are accepted
+ * const config: PrismaQueryConfig<User> = {
+ *   searchColumns: ['name', 'email'],  // ✓ valid User fields
+ * }
+ *
+ * // Without generic — accepts any string (backward compatible)
+ * const config: PrismaQueryConfig = {
+ *   searchColumns: ['name', 'email'],
+ * }
+ * ```
+ */
+interface PrismaQueryConfig<TModel = Record<string, any>> {
+  /** Columns to search across when a search string is provided */
+  searchColumns?: (keyof TModel & string)[];
+}
+/** Result shape matching Prisma's findMany arguments */
+interface PrismaQueryResult {
+  where?: Record<string, any>;
+  orderBy?: Record<string, 'asc' | 'desc'>[];
+  skip?: number;
+  take?: number;
+}
+/**
+ * Translates a ParsedQuery into Prisma-compatible `findMany` arguments.
+ *
+ * @example
+ * ```ts
+ * import type { User } from '@prisma/client'
+ *
+ * const adapter = new PrismaQueryAdapter()
+ * const parsed = parseQuery(req.query)
+ *
+ * // Type-safe — only User fields allowed in searchColumns
+ * const args = adapter.build(parsed, { searchColumns: ['name', 'email'] } satisfies PrismaQueryConfig<User>)
+ * const users = await prisma.user.findMany(args)
+ * ```
+ */
+declare class PrismaQueryAdapter implements QueryBuilderAdapter<PrismaQueryResult, PrismaQueryConfig<any>> {
+  readonly name = "PrismaQueryAdapter";
+  build<TModel = Record<string, any>>(parsed: ParsedQuery, config?: PrismaQueryConfig<TModel>): PrismaQueryResult;
+  /** Map FilterItem[] to Prisma where conditions */
+  private buildFilters;
+  /** Build Prisma orderBy from SortItem[] */
+  private buildSort;
+  /** Build a search condition using OR + contains across multiple columns */
+  private buildSearch;
+  /** Attempt to coerce a string value to a number or boolean if appropriate */
+  private coerce;
+}
+//#endregion
+export { PRISMA_CLIENT, PrismaAdapter, type PrismaAdapterOptions, type PrismaModelDelegate, PrismaQueryAdapter, type PrismaQueryConfig, type PrismaQueryResult };
+//# 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/prisma.adapter.ts","../src/query-adapter.ts"],"mappings":";;;;UAAiB,oBAAA;;;AAAjB;;;;EAOE,MAAA;EASW;;;;EAJX,OAAA;AAAA;;cAIW,aAAA;;;;;;;;;;;;;;;;;;UAmBI,mBAAA;EACf,UAAA,CAAW,IAAA;IACT,KAAA,EAAO,MAAA;IACP,OAAA,GAAU,MAAA;EAAA,IACR,OAAA;EACJ,SAAA,EAAW,IAAA,GAAO,MAAA,oBAA0B,OAAA;EAC5C,QAAA,CAAS,IAAA,GAAO,MAAA,oBAA0B,OAAA;EAC1C,MAAA,CAAO,IAAA;IAAQ,IAAA,EAAM,MAAA;EAAA,IAA4B,OAAA;EACjD,MAAA,CAAO,IAAA;IAAQ,KAAA,EAAO,MAAA;IAAyB,IAAA,EAAM,MAAA;EAAA,IAA4B,OAAA;EACjF,MAAA,CAAO,IAAA;IAAQ,KAAA,EAAO,MAAA;EAAA,IAA4B,OAAA;EAClD,UAAA,CAAW,IAAA;IAAS,KAAA,GAAQ,MAAA;EAAA,IAA4B,OAAA;IAAU,KAAA;EAAA;EAClE,KAAA,CAAM,IAAA;IAAS,KAAA,GAAQ,MAAA;EAAA,IAA4B,OAAA;AAAA;;;;AA9CrD;;;;;AAgBA;;;;;AAmBA;;;;;;;;;;;;;;;;;;;;;cCEa,aAAA,YAAyB,UAAA;EAAA,QAIhB,OAAA;EAHpB,IAAA;EAAA,QACQ,MAAA;cAEY,OAAA,EAAS,oBAAA;EDH3B;ECQF,WAAA,CAAA;IAAc;EAAA,GAAa,cAAA;EDVhB;EC4CL,QAAA,CAAA,GAAY,OAAA;AAAA;;;;;ADhFpB;;;;;AAgBA;;;;;AAmBA;;;;;;;;UEbiB,iBAAA,UAA2B,MAAA;EFmBA;EEjB1C,aAAA,UAAuB,MAAA;AAAA;;UAIR,iBAAA;EACf,KAAA,GAAQ,MAAA;EACR,OAAA,GAAU,MAAA;EACV,IAAA;EACA,IAAA;AAAA;;;;;;;;;;;;;;;;cAkBW,kBAAA,YAA8B,mBAAA,CACzC,iBAAA,EACA,iBAAA;EAAA,SAES,IAAA;EAET,KAAA,UAAe,MAAA,cAAA,CACb,MAAA,EAAQ,WAAA,EACR,MAAA,GAAQ,iBAAA,CAAkB,MAAA,IACzB,iBAAA;EFlBuC;EAAA,QEoDlC,YAAA;EFnDO;EAAA,QEyFP,SAAA;EFzFD;EAAA,QE8FC,WAAA;EF7FR;EAAA,QE0GQ,MAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,182 @@
+/**
+ * @forinda/kickjs-prisma 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 PrismaClient from the container */
+const PRISMA_CLIENT = Symbol("PrismaClient");
+//#endregion
+//#region src/prisma.adapter.ts
+const log = Logger.for("PrismaAdapter");
+/**
+* Prisma adapter — registers a PrismaClient in the DI container and manages
+* its lifecycle (connection setup and teardown).
+*
+* Works with Prisma 5, 6, and 7+.
+*
+* @example Prisma 5/6
+* ```ts
+* import { PrismaClient } from '@prisma/client'
+*
+* new PrismaAdapter({ client: new PrismaClient(), logging: true })
+* ```
+*
+* @example Prisma 7+ (driver adapters)
+* ```ts
+* import { PrismaClient } from './generated/prisma'
+* import { PrismaPg } from '@prisma/adapter-pg'
+* import pg from 'pg'
+*
+* const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })
+* const client = new PrismaClient({ adapter: new PrismaPg(pool) })
+* new PrismaAdapter({ client, logging: true })
+* ```
+*
+* Inject the client in services:
+* ```ts
+* @Service()
+* class UserService {
+*   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
+* }
+* ```
+*/
+var PrismaAdapter = class {
+	name = "PrismaAdapter";
+	client;
+	constructor(options) {
+		this.options = options;
+		this.client = options.client;
+	}
+	/** Register the PrismaClient in the DI container */
+	beforeStart({ container }) {
+		if (this.options.logging) {
+			if (typeof this.client.$on === "function") this.client.$on("query", (event) => {
+				log.debug(`Query: ${event.query}`);
+				log.debug(`Params: ${event.params}`);
+				log.debug(`Duration: ${event.duration}ms`);
+			});
+			else if (typeof this.client.$extends === "function") this.client = this.client.$extends({ query: { $allOperations({ operation, model, args, query }) {
+				const start = performance.now();
+				return query(args).then((result) => {
+					const duration = Math.round(performance.now() - start);
+					log.debug(`${model}.${operation} — ${duration}ms`);
+					return result;
+				});
+			} } });
+		}
+		container.registerFactory(PRISMA_CLIENT, () => this.client, Scope.SINGLETON);
+		log.info("PrismaClient registered in DI container");
+	}
+	/** Disconnect the PrismaClient on shutdown */
+	async shutdown() {
+		if (typeof this.client.$disconnect === "function") {
+			await this.client.$disconnect();
+			log.info("PrismaClient disconnected");
+		}
+	}
+};
+//#endregion
+//#region src/query-adapter.ts
+/**
+* Translates a ParsedQuery into Prisma-compatible `findMany` arguments.
+*
+* @example
+* ```ts
+* import type { User } from '@prisma/client'
+*
+* const adapter = new PrismaQueryAdapter()
+* const parsed = parseQuery(req.query)
+*
+* // Type-safe — only User fields allowed in searchColumns
+* const args = adapter.build(parsed, { searchColumns: ['name', 'email'] } satisfies PrismaQueryConfig<User>)
+* const users = await prisma.user.findMany(args)
+* ```
+*/
+var PrismaQueryAdapter = class {
+	name = "PrismaQueryAdapter";
+	build(parsed, config = {}) {
+		const result = {};
+		const whereConditions = this.buildFilters(parsed.filters);
+		const searchCondition = this.buildSearch(parsed.search, config.searchColumns);
+		if (whereConditions.length > 0 || searchCondition) {
+			const andClauses = [];
+			if (whereConditions.length > 0) andClauses.push(...whereConditions);
+			if (searchCondition) andClauses.push(searchCondition);
+			result.where = andClauses.length === 1 ? andClauses[0] : { AND: andClauses };
+		}
+		const orderBy = this.buildSort(parsed.sort);
+		if (orderBy.length > 0) result.orderBy = orderBy;
+		result.skip = parsed.pagination.offset;
+		result.take = parsed.pagination.limit;
+		return result;
+	}
+	/** Map FilterItem[] to Prisma where conditions */
+	buildFilters(filters) {
+		return filters.map((filter) => {
+			const { field, operator, value } = filter;
+			switch (operator) {
+				case "eq": return { [field]: { equals: this.coerce(value) } };
+				case "neq": return { [field]: { not: this.coerce(value) } };
+				case "gt": return { [field]: { gt: this.coerce(value) } };
+				case "gte": return { [field]: { gte: this.coerce(value) } };
+				case "lt": return { [field]: { lt: this.coerce(value) } };
+				case "lte": return { [field]: { lte: this.coerce(value) } };
+				case "contains": return { [field]: {
+					contains: value,
+					mode: "insensitive"
+				} };
+				case "starts": return { [field]: {
+					startsWith: value,
+					mode: "insensitive"
+				} };
+				case "ends": return { [field]: {
+					endsWith: value,
+					mode: "insensitive"
+				} };
+				case "in": {
+					const values = value.split(",").map((v) => this.coerce(v.trim()));
+					return { [field]: { in: values } };
+				}
+				case "between": {
+					const [min, max] = value.split(",").map((v) => this.coerce(v.trim()));
+					return { [field]: {
+						gte: min,
+						lte: max
+					} };
+				}
+				default: return { [field]: { equals: this.coerce(value) } };
+			}
+		});
+	}
+	/** Build Prisma orderBy from SortItem[] */
+	buildSort(sort) {
+		return sort.map((item) => ({ [item.field]: item.direction }));
+	}
+	/** Build a search condition using OR + contains across multiple columns */
+	buildSearch(search, searchColumns) {
+		if (!search || !searchColumns || searchColumns.length === 0) return null;
+		return { OR: searchColumns.map((column) => ({ [column]: {
+			contains: search,
+			mode: "insensitive"
+		} })) };
+	}
+	/** 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;
+	}
+};
+//#endregion
+export { PRISMA_CLIENT, PrismaAdapter, PrismaQueryAdapter };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/types.ts","../src/prisma.adapter.ts","../src/query-adapter.ts"],"sourcesContent":["export interface PrismaAdapterOptions {\n  /**\n   * PrismaClient instance — typed as `any` to avoid version coupling.\n   *\n   * Prisma 5/6: `new PrismaClient()` from `@prisma/client`\n   * Prisma 7+:  `new PrismaClient({ adapter })` from your generated output path\n   */\n  client: any\n  /**\n   * Enable query logging (default: false).\n   * Uses `$on('query', ...)` for Prisma 5/6 and `$extends` for Prisma 7+.\n   */\n  logging?: boolean\n}\n\n/** DI token for resolving the PrismaClient from the container */\nexport const PRISMA_CLIENT = Symbol('PrismaClient')\n\n/**\n * Common Prisma model delegate operations.\n * Use this to type-narrow the injected PrismaClient to a specific model\n * without needing `as any` casts in repositories.\n *\n * @example\n * ```ts\n * @Repository()\n * export class PrismaUserRepository {\n *   @Inject(PRISMA_CLIENT) private prisma!: { user: PrismaModelDelegate }\n *\n *   async findById(id: string) {\n *     return this.prisma.user.findUnique({ where: { id } })\n *   }\n * }\n * ```\n */\nexport interface PrismaModelDelegate {\n  findUnique(args: {\n    where: Record<string, unknown>\n    include?: Record<string, unknown>\n  }): Promise<unknown>\n  findFirst?(args?: Record<string, unknown>): Promise<unknown>\n  findMany(args?: Record<string, unknown>): Promise<unknown[]>\n  create(args: { data: Record<string, unknown> }): Promise<unknown>\n  update(args: { where: Record<string, unknown>; data: Record<string, unknown> }): Promise<unknown>\n  delete(args: { where: Record<string, unknown> }): Promise<unknown>\n  deleteMany(args?: { where?: Record<string, unknown> }): Promise<{ count: number }>\n  count(args?: { where?: Record<string, unknown> }): Promise<number>\n}\n","import { Logger, type AppAdapter, type AdapterContext, Scope } from '@forinda/kickjs'\nimport { PRISMA_CLIENT, type PrismaAdapterOptions } from './types'\n\nconst log = Logger.for('PrismaAdapter')\n\n/**\n * Prisma adapter — registers a PrismaClient in the DI container and manages\n * its lifecycle (connection setup and teardown).\n *\n * Works with Prisma 5, 6, and 7+.\n *\n * @example Prisma 5/6\n * ```ts\n * import { PrismaClient } from '@prisma/client'\n *\n * new PrismaAdapter({ client: new PrismaClient(), logging: true })\n * ```\n *\n * @example Prisma 7+ (driver adapters)\n * ```ts\n * import { PrismaClient } from './generated/prisma'\n * import { PrismaPg } from '@prisma/adapter-pg'\n * import pg from 'pg'\n *\n * const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })\n * const client = new PrismaClient({ adapter: new PrismaPg(pool) })\n * new PrismaAdapter({ client, logging: true })\n * ```\n *\n * Inject the client in services:\n * ```ts\n * @Service()\n * class UserService {\n *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient\n * }\n * ```\n */\nexport class PrismaAdapter implements AppAdapter {\n  name = 'PrismaAdapter'\n  private client: any\n\n  constructor(private options: PrismaAdapterOptions) {\n    this.client = options.client\n  }\n\n  /** Register the PrismaClient in the DI container */\n  beforeStart({ container }: AdapterContext): void {\n    // Set up query logging if requested\n    if (this.options.logging) {\n      if (typeof this.client.$on === 'function') {\n        // Prisma 5/6: event-based logging\n        this.client.$on('query', (event: any) => {\n          log.debug(`Query: ${event.query}`)\n          log.debug(`Params: ${event.params}`)\n          log.debug(`Duration: ${event.duration}ms`)\n        })\n      } else if (typeof this.client.$extends === 'function') {\n        // Prisma 7+: Client Extensions for logging ($on removed)\n        this.client = this.client.$extends({\n          query: {\n            $allOperations({ operation, model, args, query }: any) {\n              const start = performance.now()\n              return query(args).then((result: any) => {\n                const duration = Math.round(performance.now() - start)\n                log.debug(`${model}.${operation} — ${duration}ms`)\n                return result\n              })\n            },\n          },\n        })\n      }\n    }\n\n    // Register the client instance as a singleton factory in the container\n    container.registerFactory(PRISMA_CLIENT, () => this.client, Scope.SINGLETON)\n\n    log.info('PrismaClient registered in DI container')\n  }\n\n  /** Disconnect the PrismaClient on shutdown */\n  async shutdown(): Promise<void> {\n    if (typeof this.client.$disconnect === 'function') {\n      await this.client.$disconnect()\n      log.info('PrismaClient disconnected')\n    }\n  }\n}\n","import type { QueryBuilderAdapter, ParsedQuery, FilterItem, SortItem } from '@forinda/kickjs'\n\n/**\n * Configuration for the Prisma query builder adapter.\n *\n * Use the generic parameter to constrain `searchColumns` to actual model field names:\n *\n * @example\n * ```ts\n * import type { User } from '@prisma/client'\n *\n * // Type-safe — only User field names are accepted\n * const config: PrismaQueryConfig<User> = {\n *   searchColumns: ['name', 'email'],  // ✓ valid User fields\n * }\n *\n * // Without generic — accepts any string (backward compatible)\n * const config: PrismaQueryConfig = {\n *   searchColumns: ['name', 'email'],\n * }\n * ```\n */\nexport interface PrismaQueryConfig<TModel = Record<string, any>> {\n  /** Columns to search across when a search string is provided */\n  searchColumns?: (keyof TModel & string)[]\n}\n\n/** Result shape matching Prisma's findMany arguments */\nexport interface PrismaQueryResult {\n  where?: Record<string, any>\n  orderBy?: Record<string, 'asc' | 'desc'>[]\n  skip?: number\n  take?: number\n}\n\n/**\n * Translates a ParsedQuery into Prisma-compatible `findMany` arguments.\n *\n * @example\n * ```ts\n * import type { User } from '@prisma/client'\n *\n * const adapter = new PrismaQueryAdapter()\n * const parsed = parseQuery(req.query)\n *\n * // Type-safe — only User fields allowed in searchColumns\n * const args = adapter.build(parsed, { searchColumns: ['name', 'email'] } satisfies PrismaQueryConfig<User>)\n * const users = await prisma.user.findMany(args)\n * ```\n */\nexport class PrismaQueryAdapter implements QueryBuilderAdapter<\n  PrismaQueryResult,\n  PrismaQueryConfig<any>\n> {\n  readonly name = 'PrismaQueryAdapter'\n\n  build<TModel = Record<string, any>>(\n    parsed: ParsedQuery,\n    config: PrismaQueryConfig<TModel> = {},\n  ): PrismaQueryResult {\n    const result: PrismaQueryResult = {}\n\n    // Build where clause from filters and search\n    const whereConditions = this.buildFilters(parsed.filters)\n    const searchCondition = this.buildSearch(parsed.search, config.searchColumns)\n\n    if (whereConditions.length > 0 || searchCondition) {\n      const andClauses: any[] = []\n\n      if (whereConditions.length > 0) {\n        andClauses.push(...whereConditions)\n      }\n      if (searchCondition) {\n        andClauses.push(searchCondition)\n      }\n\n      result.where = andClauses.length === 1 ? andClauses[0] : { AND: andClauses }\n    }\n\n    // Build orderBy\n    const orderBy = this.buildSort(parsed.sort)\n    if (orderBy.length > 0) {\n      result.orderBy = orderBy\n    }\n\n    // Build pagination\n    result.skip = parsed.pagination.offset\n    result.take = parsed.pagination.limit\n\n    return result\n  }\n\n  /** Map FilterItem[] to Prisma where conditions */\n  private buildFilters(filters: FilterItem[]): Record<string, any>[] {\n    return filters.map((filter) => {\n      const { field, operator, value } = filter\n\n      switch (operator) {\n        case 'eq':\n          return { [field]: { equals: this.coerce(value) } }\n        case 'neq':\n          return { [field]: { not: this.coerce(value) } }\n        case 'gt':\n          return { [field]: { gt: this.coerce(value) } }\n        case 'gte':\n          return { [field]: { gte: this.coerce(value) } }\n        case 'lt':\n          return { [field]: { lt: this.coerce(value) } }\n        case 'lte':\n          return { [field]: { lte: this.coerce(value) } }\n        case 'contains':\n          return { [field]: { contains: value, mode: 'insensitive' } }\n        case 'starts':\n          return { [field]: { startsWith: value, mode: 'insensitive' } }\n        case 'ends':\n          return { [field]: { endsWith: value, mode: 'insensitive' } }\n        case 'in': {\n          const values = value.split(',').map((v) => this.coerce(v.trim()))\n          return { [field]: { in: values } }\n        }\n        case 'between': {\n          const [min, max] = value.split(',').map((v) => this.coerce(v.trim()))\n          return { [field]: { gte: min, lte: max } }\n        }\n        default:\n          return { [field]: { equals: this.coerce(value) } }\n      }\n    })\n  }\n\n  /** Build Prisma orderBy from SortItem[] */\n  private buildSort(sort: SortItem[]): Record<string, 'asc' | 'desc'>[] {\n    return sort.map((item) => ({ [item.field]: item.direction }))\n  }\n\n  /** Build a search condition using OR + contains across multiple columns */\n  private buildSearch(search: string, searchColumns?: string[]): Record<string, any> | null {\n    if (!search || !searchColumns || searchColumns.length === 0) {\n      return null\n    }\n\n    return {\n      OR: searchColumns.map((column) => ({\n        [column]: { contains: search, mode: 'insensitive' },\n      })),\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"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forinda/kickjs-prisma",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "Prisma ORM adapter with DI integration, transaction support, and query building for KickJS",
   "keywords": [
     "kickjs",
@@ -40,20 +40,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": {
     "@prisma/client": ">=5.0.0"
@@ -85,11 +102,10 @@
     "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",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist .turbo",
+    "clean": "rm -rf dist .wireit",
     "lint": "tsc --noEmit"
   }
 }

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export { PrismaAdapter } from './prisma.adapter';
-export { PrismaQueryAdapter } from './query-adapter';
-export { PRISMA_CLIENT } from './types';
-export type { PrismaAdapterOptions, PrismaModelDelegate } from './types';
-export type { PrismaQueryConfig, PrismaQueryResult } 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,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AACxE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -1,100 +0,0 @@
-import { Logger as u, Scope as l } from "@forinda/kickjs";
-var h = /* @__PURE__ */ Symbol("PrismaClient"), c = u.for("PrismaAdapter"), m = class {
-  name = "PrismaAdapter";
-  client;
-  constructor(e) {
-    this.options = e, this.client = e.client;
-  }
-  beforeStart({ container: e }) {
-    this.options.logging && (typeof this.client.$on == "function" ? this.client.$on("query", (r) => {
-      c.debug(`Query: ${r.query}`), c.debug(`Params: ${r.params}`), c.debug(`Duration: ${r.duration}ms`);
-    }) : typeof this.client.$extends == "function" && (this.client = this.client.$extends({ query: { $allOperations({ operation: r, model: t, args: o, query: i }) {
-      const s = performance.now();
-      return i(o).then((n) => {
-        const a = Math.round(performance.now() - s);
-        return c.debug(`${t}.${r} — ${a}ms`), n;
-      });
-    } } }))), e.registerFactory(h, () => this.client, l.SINGLETON), c.info("PrismaClient registered in DI container");
-  }
-  async shutdown() {
-    typeof this.client.$disconnect == "function" && (await this.client.$disconnect(), c.info("PrismaClient disconnected"));
-  }
-}, f = class {
-  name = "PrismaQueryAdapter";
-  build(e, r = {}) {
-    const t = {}, o = this.buildFilters(e.filters), i = this.buildSearch(e.search, r.searchColumns);
-    if (o.length > 0 || i) {
-      const n = [];
-      o.length > 0 && n.push(...o), i && n.push(i), t.where = n.length === 1 ? n[0] : { AND: n };
-    }
-    const s = this.buildSort(e.sort);
-    return s.length > 0 && (t.orderBy = s), t.skip = e.pagination.offset, t.take = e.pagination.limit, t;
-  }
-  buildFilters(e) {
-    return e.map((r) => {
-      const { field: t, operator: o, value: i } = r;
-      switch (o) {
-        case "eq":
-          return { [t]: { equals: this.coerce(i) } };
-        case "neq":
-          return { [t]: { not: this.coerce(i) } };
-        case "gt":
-          return { [t]: { gt: this.coerce(i) } };
-        case "gte":
-          return { [t]: { gte: this.coerce(i) } };
-        case "lt":
-          return { [t]: { lt: this.coerce(i) } };
-        case "lte":
-          return { [t]: { lte: this.coerce(i) } };
-        case "contains":
-          return { [t]: {
-            contains: i,
-            mode: "insensitive"
-          } };
-        case "starts":
-          return { [t]: {
-            startsWith: i,
-            mode: "insensitive"
-          } };
-        case "ends":
-          return { [t]: {
-            endsWith: i,
-            mode: "insensitive"
-          } };
-        case "in": {
-          const s = i.split(",").map((n) => this.coerce(n.trim()));
-          return { [t]: { in: s } };
-        }
-        case "between": {
-          const [s, n] = i.split(",").map((a) => this.coerce(a.trim()));
-          return { [t]: {
-            gte: s,
-            lte: n
-          } };
-        }
-        default:
-          return { [t]: { equals: this.coerce(i) } };
-      }
-    });
-  }
-  buildSort(e) {
-    return e.map((r) => ({ [r.field]: r.direction }));
-  }
-  buildSearch(e, r) {
-    return !e || !r || r.length === 0 ? null : { OR: r.map((t) => ({ [t]: {
-      contains: e,
-      mode: "insensitive"
-    } })) };
-  }
-  coerce(e) {
-    if (e === "true") return !0;
-    if (e === "false") return !1;
-    const r = Number(e);
-    return !Number.isNaN(r) && e.trim() !== "" ? r : e;
-  }
-};
-export {
-  h as PRISMA_CLIENT,
-  m as PrismaAdapter,
-  f as PrismaQueryAdapter
-};

package/dist/prisma.adapter.d.ts

@@ -1,45 +0,0 @@
-import { type AppAdapter, type AdapterContext } from '@forinda/kickjs';
-import { type PrismaAdapterOptions } from './types';
-/**
- * Prisma adapter — registers a PrismaClient in the DI container and manages
- * its lifecycle (connection setup and teardown).
- *
- * Works with Prisma 5, 6, and 7+.
- *
- * @example Prisma 5/6
- * ```ts
- * import { PrismaClient } from '@prisma/client'
- *
- * new PrismaAdapter({ client: new PrismaClient(), logging: true })
- * ```
- *
- * @example Prisma 7+ (driver adapters)
- * ```ts
- * import { PrismaClient } from './generated/prisma'
- * import { PrismaPg } from '@prisma/adapter-pg'
- * import pg from 'pg'
- *
- * const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })
- * const client = new PrismaClient({ adapter: new PrismaPg(pool) })
- * new PrismaAdapter({ client, logging: true })
- * ```
- *
- * Inject the client in services:
- * ```ts
- * @Service()
- * class UserService {
- *   @Inject(PRISMA_CLIENT) private prisma!: PrismaClient
- * }
- * ```
- */
-export declare class PrismaAdapter implements AppAdapter {
-    private options;
-    name: string;
-    private client;
-    constructor(options: PrismaAdapterOptions);
-    /** Register the PrismaClient in the DI container */
-    beforeStart({ container }: AdapterContext): void;
-    /** Disconnect the PrismaClient on shutdown */
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=prisma.adapter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prisma.adapter.d.ts","sourceRoot":"","sources":["../src/prisma.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,UAAU,EAAE,KAAK,cAAc,EAAS,MAAM,iBAAiB,CAAA;AACrF,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAIlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,aAAc,YAAW,UAAU;IAIlC,OAAO,CAAC,OAAO;IAH3B,IAAI,SAAkB;IACtB,OAAO,CAAC,MAAM,CAAK;gBAEC,OAAO,EAAE,oBAAoB;IAIjD,oDAAoD;IACpD,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,cAAc,GAAG,IAAI;IAiChD,8CAA8C;IACxC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAMhC"}

package/dist/query-adapter.d.ts

@@ -1,60 +0,0 @@
-import type { QueryBuilderAdapter, ParsedQuery } from '@forinda/kickjs';
-/**
- * Configuration for the Prisma query builder adapter.
- *
- * Use the generic parameter to constrain `searchColumns` to actual model field names:
- *
- * @example
- * ```ts
- * import type { User } from '@prisma/client'
- *
- * // Type-safe — only User field names are accepted
- * const config: PrismaQueryConfig<User> = {
- *   searchColumns: ['name', 'email'],  // ✓ valid User fields
- * }
- *
- * // Without generic — accepts any string (backward compatible)
- * const config: PrismaQueryConfig = {
- *   searchColumns: ['name', 'email'],
- * }
- * ```
- */
-export interface PrismaQueryConfig<TModel = Record<string, any>> {
-    /** Columns to search across when a search string is provided */
-    searchColumns?: (keyof TModel & string)[];
-}
-/** Result shape matching Prisma's findMany arguments */
-export interface PrismaQueryResult {
-    where?: Record<string, any>;
-    orderBy?: Record<string, 'asc' | 'desc'>[];
-    skip?: number;
-    take?: number;
-}
-/**
- * Translates a ParsedQuery into Prisma-compatible `findMany` arguments.
- *
- * @example
- * ```ts
- * import type { User } from '@prisma/client'
- *
- * const adapter = new PrismaQueryAdapter()
- * const parsed = parseQuery(req.query)
- *
- * // Type-safe — only User fields allowed in searchColumns
- * const args = adapter.build(parsed, { searchColumns: ['name', 'email'] } satisfies PrismaQueryConfig<User>)
- * const users = await prisma.user.findMany(args)
- * ```
- */
-export declare class PrismaQueryAdapter implements QueryBuilderAdapter<PrismaQueryResult, PrismaQueryConfig<any>> {
-    readonly name = "PrismaQueryAdapter";
-    build<TModel = Record<string, any>>(parsed: ParsedQuery, config?: PrismaQueryConfig<TModel>): PrismaQueryResult;
-    /** Map FilterItem[] to Prisma where conditions */
-    private buildFilters;
-    /** Build Prisma orderBy from SortItem[] */
-    private buildSort;
-    /** Build a search condition using OR + contains across multiple columns */
-    private buildSearch;
-    /** Attempt to coerce a string value to a number or boolean if appropriate */
-    private coerce;
-}
-//# 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":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAwB,MAAM,iBAAiB,CAAA;AAE7F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,iBAAiB,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC7D,gEAAgE;IAChE,aAAa,CAAC,EAAE,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;CAC1C;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC,EAAE,CAAA;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAmB,YAAW,mBAAmB,CAC5D,iBAAiB,EACjB,iBAAiB,CAAC,GAAG,CAAC,CACvB;IACC,QAAQ,CAAC,IAAI,wBAAuB;IAEpC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,MAAM,EAAE,WAAW,EACnB,MAAM,GAAE,iBAAiB,CAAC,MAAM,CAAM,GACrC,iBAAiB;IAiCpB,kDAAkD;IAClD,OAAO,CAAC,YAAY;IAqCpB,2CAA2C;IAC3C,OAAO,CAAC,SAAS;IAIjB,2EAA2E;IAC3E,OAAO,CAAC,WAAW;IAYnB,6EAA6E;IAC7E,OAAO,CAAC,MAAM;CAOf"}

package/dist/types.d.ts

@@ -1,60 +0,0 @@
-export interface PrismaAdapterOptions {
-    /**
-     * PrismaClient instance — typed as `any` to avoid version coupling.
-     *
-     * Prisma 5/6: `new PrismaClient()` from `@prisma/client`
-     * Prisma 7+:  `new PrismaClient({ adapter })` from your generated output path
-     */
-    client: any;
-    /**
-     * Enable query logging (default: false).
-     * Uses `$on('query', ...)` for Prisma 5/6 and `$extends` for Prisma 7+.
-     */
-    logging?: boolean;
-}
-/** DI token for resolving the PrismaClient from the container */
-export declare const PRISMA_CLIENT: unique symbol;
-/**
- * Common Prisma model delegate operations.
- * Use this to type-narrow the injected PrismaClient to a specific model
- * without needing `as any` casts in repositories.
- *
- * @example
- * ```ts
- * @Repository()
- * export class PrismaUserRepository {
- *   @Inject(PRISMA_CLIENT) private prisma!: { user: PrismaModelDelegate }
- *
- *   async findById(id: string) {
- *     return this.prisma.user.findUnique({ where: { id } })
- *   }
- * }
- * ```
- */
-export interface PrismaModelDelegate {
-    findUnique(args: {
-        where: Record<string, unknown>;
-        include?: Record<string, unknown>;
-    }): Promise<unknown>;
-    findFirst?(args?: Record<string, unknown>): Promise<unknown>;
-    findMany(args?: Record<string, unknown>): Promise<unknown[]>;
-    create(args: {
-        data: Record<string, unknown>;
-    }): Promise<unknown>;
-    update(args: {
-        where: Record<string, unknown>;
-        data: Record<string, unknown>;
-    }): Promise<unknown>;
-    delete(args: {
-        where: Record<string, unknown>;
-    }): Promise<unknown>;
-    deleteMany(args?: {
-        where?: Record<string, unknown>;
-    }): Promise<{
-        count: number;
-    }>;
-    count(args?: {
-        where?: Record<string, unknown>;
-    }): Promise<number>;
-}
-//# 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,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,MAAM,EAAE,GAAG,CAAA;IACX;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,iEAAiE;AACjE,eAAO,MAAM,aAAa,eAAyB,CAAA;AAEnD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,IAAI,EAAE;QACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAClC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACpB,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;IAC5D,MAAM,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjE,MAAM,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjG,MAAM,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAClE,UAAU,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClF,KAAK,CAAC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACnE"}