@forinda/kickjs-drizzle 1.5.0 → 1.7.0

package/dist/drizzle.adapter.d.ts

@@ -1,4 +1,4 @@
-import { type AppAdapter, type Container } from '@forinda/kickjs-core';
+import { type AppAdapter, type AdapterContext } from '@forinda/kickjs-core';
 import { type DrizzleAdapterOptions } from './types';
 /**
  * Drizzle ORM adapter — registers a Drizzle database instance in the DI
@@ -44,7 +44,7 @@ export declare class DrizzleAdapter<TDb = unknown> implements AppAdapter {
     private onShutdown?;
     constructor(options: DrizzleAdapterOptions<TDb>);
     /** Register the Drizzle db instance in the DI container */
-    beforeStart(_app: unknown, container: Container): void;
+    beforeStart({ container }: AdapterContext): void;
     /** Close the underlying connection on shutdown */
     shutdown(): Promise<void>;
 }

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

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

@@ -6,8 +6,8 @@ var u = /* @__PURE__ */ Symbol("DrizzleDB"), h = l.for("DrizzleAdapter"), d = cl
   constructor(e) {
     this.options = e, this.db = e.db, this.onShutdown = e.onShutdown;
   }
-  beforeStart(e, t) {
-    this.options.logging && h.info("Query logging enabled"), t.registerFactory(u, () => this.db, c.SINGLETON), h.info("Drizzle database registered in DI container");
+  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"));
@@ -17,7 +17,7 @@ function b(e) {
   return {
     filterable: Object.keys(e.columns),
     sortable: e.sortable ? Object.keys(e.sortable) : [],
-    searchable: e.searchColumns ? e.searchColumns.map((t) => t.name ?? "").filter(Boolean) : []
+    searchable: e.searchColumns ? e.searchColumns.map((s) => s.name ?? "").filter(Boolean) : []
   };
 }
 var m = class {
@@ -25,135 +25,135 @@ var m = class {
   constructor(e) {
     this.ops = e;
   }
-  build(e, t = {}) {
-    const s = {
+  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(t.table, o);
+      const i = this.buildFilter(s.table, o);
       i && r.push(i);
     }
-    if (e.search && t.searchColumns && t.searchColumns.length > 0) {
-      const o = t.searchColumns.filter((i) => t.table[i]).map((i) => this.ops.ilike(t.table[i], `%${e.search}%`));
+    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 ? s.where = r[0] : r.length > 1 && (s.where = this.ops.and(...r)), s.orderBy = this.buildSort(t.table, e.sort), s;
+    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, t) {
-    const s = {
+  buildFromColumns(e, s) {
+    const t = {
       orderBy: [],
       limit: e.pagination.limit,
       offset: e.pagination.offset
     }, r = [];
-    t.baseCondition && r.push(t.baseCondition);
+    s.baseCondition && r.push(s.baseCondition);
     for (const i of e.filters) {
-      const n = t.columns[i.field];
+      const n = s.columns[i.field];
       if (!n) continue;
       const a = this.buildColumnFilter(n, i);
       a && r.push(a);
     }
-    if (e.search && t.searchColumns && t.searchColumns.length > 0) {
-      const i = t.searchColumns.map((n) => this.ops.ilike(n, `%${e.search}%`));
+    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 ? s.where = r[0] : r.length > 1 && (s.where = this.ops.and(...r));
-    const o = t.sortable ?? t.columns;
-    return s.orderBy = e.sort.filter((i) => o[i.field]).map((i) => i.direction === "desc" ? this.ops.desc(o[i.field]) : this.ops.asc(o[i.field])), s;
+    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, t) {
-    const s = e[t.field];
-    if (!s) return null;
-    const r = this.coerce(t.value);
-    switch (t.operator) {
+  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(s, r);
+        return this.ops.eq(t, r);
       case "neq":
-        return this.ops.ne(s, r);
+        return this.ops.ne(t, r);
       case "gt":
-        return this.ops.gt(s, r);
+        return this.ops.gt(t, r);
       case "gte":
-        return this.ops.gte(s, r);
+        return this.ops.gte(t, r);
       case "lt":
-        return this.ops.lt(s, r);
+        return this.ops.lt(t, r);
       case "lte":
-        return this.ops.lte(s, r);
+        return this.ops.lte(t, r);
       case "contains":
-        return this.ops.ilike(s, `%${t.value}%`);
+        return this.ops.ilike(t, `%${s.value}%`);
       case "starts":
-        return this.ops.ilike(s, `${t.value}%`);
+        return this.ops.ilike(t, `${s.value}%`);
       case "ends":
-        return this.ops.ilike(s, `%${t.value}`);
+        return this.ops.ilike(t, `%${s.value}`);
       case "in": {
-        const o = t.value.split(",").map((i) => this.coerce(i.trim()));
-        return this.ops.inArray(s, o);
+        const o = s.value.split(",").map((i) => this.coerce(i.trim()));
+        return this.ops.inArray(t, o);
       }
       case "between": {
-        const [o, i] = t.value.split(",").map((n) => this.coerce(n.trim()));
-        return this.ops.and(this.ops.gte(s, o), this.ops.lte(s, i));
+        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(s, r);
+        return this.ops.eq(t, r);
     }
   }
-  buildColumnFilter(e, t) {
-    const s = this.coerceByDataType(t.value, e.dataType);
-    switch (t.operator) {
+  buildColumnFilter(e, s) {
+    const t = this.coerceByDataType(s.value, e.dataType);
+    switch (s.operator) {
       case "eq":
-        return this.ops.eq(e, s);
+        return this.ops.eq(e, t);
       case "neq":
-        return this.ops.ne(e, s);
+        return this.ops.ne(e, t);
       case "gt":
-        return this.ops.gt(e, s);
+        return this.ops.gt(e, t);
       case "gte":
-        return this.ops.gte(e, s);
+        return this.ops.gte(e, t);
       case "lt":
-        return this.ops.lt(e, s);
+        return this.ops.lt(e, t);
       case "lte":
-        return this.ops.lte(e, s);
+        return this.ops.lte(e, t);
       case "contains":
-        return this.ops.ilike(e, `%${t.value}%`);
+        return this.ops.ilike(e, `%${s.value}%`);
       case "starts":
-        return this.ops.ilike(e, `${t.value}%`);
+        return this.ops.ilike(e, `${s.value}%`);
       case "ends":
-        return this.ops.ilike(e, `%${t.value}`);
+        return this.ops.ilike(e, `%${s.value}`);
       case "in": {
-        const r = t.value.split(",").map((o) => this.coerceByDataType(o.trim(), e.dataType));
+        const r = s.value.split(",").map((o) => this.coerceByDataType(o.trim(), e.dataType));
         return this.ops.inArray(e, r);
       }
       case "between": {
-        const [r, o] = t.value.split(",").map((a) => a.trim()), i = this.coerceByDataType(r, e.dataType), n = this.coerceByDataType(o, e.dataType);
+        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, s);
+        return this.ops.eq(e, t);
     }
   }
-  buildSort(e, t) {
-    return t.filter((s) => e[s.field]).map((s) => s.direction === "desc" ? this.ops.desc(e[s.field]) : this.ops.asc(e[s.field]));
+  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 t = Number(e);
-    return !Number.isNaN(t) && e.trim() !== "" ? t : e;
+    const s = Number(e);
+    return !Number.isNaN(s) && e.trim() !== "" ? s : e;
   }
-  coerceByDataType(e, t) {
-    if (!t) return this.coerce(e);
-    switch (t) {
+  coerceByDataType(e, s) {
+    if (!s) return this.coerce(e);
+    switch (s) {
       case "boolean":
         return e === "true" || e === "1";
       case "number":
       case "bigint": {
-        const s = Number(e);
-        return Number.isNaN(s) ? e : s;
+        const t = Number(e);
+        return Number.isNaN(t) ? e : t;
       }
       case "date":
       case "localDate":
       case "localDateTime": {
-        const s = new Date(e);
-        return Number.isNaN(s.getTime()) ? e : s;
+        const t = new Date(e);
+        return Number.isNaN(t.getTime()) ? e : t;
       }
       default:
         return e;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forinda/kickjs-drizzle",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Drizzle ORM adapter with DI integration, transaction support, and query building for KickJS",
   "keywords": [
     "kickjs",
@@ -54,14 +54,14 @@
   ],
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@forinda/kickjs-core": "1.5.0",
-    "@forinda/kickjs-http": "1.5.0"
+    "@forinda/kickjs-core": "1.7.0",
+    "@forinda/kickjs-http": "1.7.0"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.30.0"
   },
   "devDependencies": {
-    "@types/node": "^24.5.2",
+    "@types/node": "^25.0.0",
     "typescript": "^5.9.2"
   },
   "publishConfig": {