@forinda/kickjs-drizzle 2.3.3 → 3.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +47 -2
- package/dist/index.d.mts +105 -2
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +137 -7
- package/dist/index.mjs.map +1 -1
- package/package.json +12 -5
package/README.md
CHANGED
|
@@ -15,8 +15,10 @@ pnpm add @forinda/kickjs-drizzle drizzle-orm
|
|
|
15
15
|
## Features
|
|
16
16
|
|
|
17
17
|
- `DrizzleAdapter` — lifecycle adapter that manages the Drizzle connection
|
|
18
|
-
- `
|
|
19
|
-
- `
|
|
18
|
+
- `DrizzleTenantAdapter` — multi-tenant adapter with per-tenant connection caching
|
|
19
|
+
- `DRIZZLE_DB` token — singleton, provider/single-tenant database
|
|
20
|
+
- `DRIZZLE_TENANT_DB` token — transient, current tenant's database via AsyncLocalStorage
|
|
21
|
+
- `DrizzleQueryAdapter` — translates `ParsedQuery` from `@forinda/kickjs` into Drizzle queries
|
|
20
22
|
- `toQueryFieldConfig` helper for field mapping
|
|
21
23
|
|
|
22
24
|
## Quick Example
|
|
@@ -47,6 +49,49 @@ class UserService {
|
|
|
47
49
|
}
|
|
48
50
|
```
|
|
49
51
|
|
|
52
|
+
## Multi-Tenant
|
|
53
|
+
|
|
54
|
+
Use `DrizzleTenantAdapter` alongside `TenantAdapter` for database-per-tenant:
|
|
55
|
+
|
|
56
|
+
```typescript
|
|
57
|
+
import { DrizzleTenantAdapter, DRIZZLE_TENANT_DB } from '@forinda/kickjs-drizzle'
|
|
58
|
+
import { TenantAdapter } from '@forinda/kickjs-multi-tenant'
|
|
59
|
+
|
|
60
|
+
bootstrap({
|
|
61
|
+
modules,
|
|
62
|
+
adapters: [
|
|
63
|
+
new TenantAdapter({ strategy: 'subdomain' }),
|
|
64
|
+
new DrizzleTenantAdapter({
|
|
65
|
+
providerDb: drizzle(providerPool, { schema }),
|
|
66
|
+
tenantFactory: async (tenantId) => {
|
|
67
|
+
const url = await lookupTenantDbUrl(tenantId)
|
|
68
|
+
return drizzle(new Pool({ connectionString: url }), { schema })
|
|
69
|
+
},
|
|
70
|
+
onTenantShutdown: (db, tenantId) => {
|
|
71
|
+
// Close the pool when shutting down
|
|
72
|
+
},
|
|
73
|
+
}),
|
|
74
|
+
],
|
|
75
|
+
})
|
|
76
|
+
|
|
77
|
+
// In a service — resolves to the current tenant's typed DB
|
|
78
|
+
@Service()
|
|
79
|
+
class ProjectService {
|
|
80
|
+
@Inject(DRIZZLE_TENANT_DB) private db!: NodePgDatabase<typeof schema>
|
|
81
|
+
|
|
82
|
+
async findAll() {
|
|
83
|
+
return this.db.select().from(projects)
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
```
|
|
87
|
+
|
|
88
|
+
Use both adapters together for interop:
|
|
89
|
+
|
|
90
|
+
```typescript
|
|
91
|
+
@Inject(DRIZZLE_DB) private providerDb!: typeof db // always provider
|
|
92
|
+
@Inject(DRIZZLE_TENANT_DB) private tenantDb!: typeof db // current tenant
|
|
93
|
+
```
|
|
94
|
+
|
|
50
95
|
## Query Adapter
|
|
51
96
|
|
|
52
97
|
```typescript
|
package/dist/index.d.mts
CHANGED
|
@@ -2,8 +2,10 @@
|
|
|
2
2
|
import { AdapterContext, AppAdapter, MaybePromise, ParsedQuery, QueryBuilderAdapter } from "@forinda/kickjs";
|
|
3
3
|
|
|
4
4
|
//#region src/types.d.ts
|
|
5
|
-
/** DI token for resolving the Drizzle database instance from the container */
|
|
5
|
+
/** DI token for resolving the Drizzle database instance from the container (single-tenant) */
|
|
6
6
|
declare const DRIZZLE_DB: unique symbol;
|
|
7
|
+
/** DI token for resolving the current tenant's Drizzle database instance (multi-tenant) */
|
|
8
|
+
declare const DRIZZLE_TENANT_DB: unique symbol;
|
|
7
9
|
interface DrizzleAdapterOptions<TDb = unknown> {
|
|
8
10
|
/**
|
|
9
11
|
* Drizzle database instance — the return value of `drizzle()`.
|
|
@@ -42,6 +44,38 @@ interface DrizzleAdapterOptions<TDb = unknown> {
|
|
|
42
44
|
*/
|
|
43
45
|
onShutdown?: () => MaybePromise<any>;
|
|
44
46
|
}
|
|
47
|
+
interface DrizzleTenantAdapterOptions<TDb = unknown> {
|
|
48
|
+
/**
|
|
49
|
+
* The provider (default) database instance. Used when no tenant is
|
|
50
|
+
* resolved or when accessing the tenant registry.
|
|
51
|
+
*/
|
|
52
|
+
providerDb: TDb;
|
|
53
|
+
/**
|
|
54
|
+
* Factory that creates a typed Drizzle instance for a given tenant.
|
|
55
|
+
* Called once per tenant — the result is cached for subsequent requests.
|
|
56
|
+
*
|
|
57
|
+
* @example
|
|
58
|
+
* ```ts
|
|
59
|
+
* tenantFactory: async (tenantId) => {
|
|
60
|
+
* const url = await lookupTenantDbUrl(tenantId)
|
|
61
|
+
* return drizzle(new Pool({ connectionString: url }), { schema })
|
|
62
|
+
* }
|
|
63
|
+
* ```
|
|
64
|
+
*/
|
|
65
|
+
tenantFactory: (tenantId: string) => TDb | Promise<TDb>;
|
|
66
|
+
/**
|
|
67
|
+
* Optional function to close a tenant DB connection.
|
|
68
|
+
* Called for each cached connection during shutdown.
|
|
69
|
+
*/
|
|
70
|
+
onTenantShutdown?: (db: TDb, tenantId: string) => MaybePromise<any>;
|
|
71
|
+
/** Enable query logging (default: false) */
|
|
72
|
+
logging?: boolean;
|
|
73
|
+
/**
|
|
74
|
+
* Cache TTL in milliseconds. Tenant connections idle beyond this
|
|
75
|
+
* duration are evicted. Default: no eviction (connections live until shutdown).
|
|
76
|
+
*/
|
|
77
|
+
cacheTtl?: number;
|
|
78
|
+
}
|
|
45
79
|
//#endregion
|
|
46
80
|
//#region src/drizzle.adapter.d.ts
|
|
47
81
|
/**
|
|
@@ -95,6 +129,75 @@ declare class DrizzleAdapter<TDb = unknown> implements AppAdapter {
|
|
|
95
129
|
shutdown(): Promise<void>;
|
|
96
130
|
}
|
|
97
131
|
//#endregion
|
|
132
|
+
//#region src/drizzle-tenant.adapter.d.ts
|
|
133
|
+
/**
|
|
134
|
+
* Multi-tenant Drizzle adapter — manages per-tenant database connections
|
|
135
|
+
* with automatic caching and lifecycle management.
|
|
136
|
+
*
|
|
137
|
+
* Registers `DRIZZLE_TENANT_DB` as a TRANSIENT DI token that resolves
|
|
138
|
+
* to the current tenant's Drizzle instance using AsyncLocalStorage
|
|
139
|
+
* (requires `TenantAdapter` to be configured).
|
|
140
|
+
*
|
|
141
|
+
* Works alongside `DrizzleAdapter` — use `DRIZZLE_DB` for the provider
|
|
142
|
+
* database and `DRIZZLE_TENANT_DB` for the current tenant's database.
|
|
143
|
+
*
|
|
144
|
+
* @example
|
|
145
|
+
* ```ts
|
|
146
|
+
* import { drizzle } from 'drizzle-orm/node-postgres'
|
|
147
|
+
* import { Pool } from 'pg'
|
|
148
|
+
* import * as schema from './schema'
|
|
149
|
+
*
|
|
150
|
+
* const providerDb = drizzle(new Pool({ connectionString: PROVIDER_URL }), { schema })
|
|
151
|
+
*
|
|
152
|
+
* bootstrap({
|
|
153
|
+
* adapters: [
|
|
154
|
+
* new TenantAdapter({ strategy: 'subdomain' }),
|
|
155
|
+
* new DrizzleTenantAdapter({
|
|
156
|
+
* providerDb,
|
|
157
|
+
* tenantFactory: async (tenantId) => {
|
|
158
|
+
* const url = await lookupTenantDbUrl(tenantId)
|
|
159
|
+
* return drizzle(new Pool({ connectionString: url }), { schema })
|
|
160
|
+
* },
|
|
161
|
+
* }),
|
|
162
|
+
* ],
|
|
163
|
+
* })
|
|
164
|
+
* ```
|
|
165
|
+
*
|
|
166
|
+
* Inject in services:
|
|
167
|
+
* ```ts
|
|
168
|
+
* @Service()
|
|
169
|
+
* class ProjectService {
|
|
170
|
+
* constructor(@Inject(DRIZZLE_TENANT_DB) private db: NodePgDatabase<typeof schema>) {}
|
|
171
|
+
* }
|
|
172
|
+
* ```
|
|
173
|
+
*/
|
|
174
|
+
declare class DrizzleTenantAdapter<TDb = unknown> implements AppAdapter {
|
|
175
|
+
name: string;
|
|
176
|
+
private readonly providerDb;
|
|
177
|
+
private readonly tenantFactory;
|
|
178
|
+
private readonly connections;
|
|
179
|
+
private readonly lastAccessed;
|
|
180
|
+
private readonly options;
|
|
181
|
+
private readonly evictionTimer?;
|
|
182
|
+
constructor(options: DrizzleTenantAdapterOptions<TDb>);
|
|
183
|
+
/**
|
|
184
|
+
* Get the database for a specific tenant.
|
|
185
|
+
* Creates and caches the connection on first access.
|
|
186
|
+
* Returns the provider DB when tenantId is undefined/null.
|
|
187
|
+
*/
|
|
188
|
+
getDb(tenantId?: string | null): Promise<TDb>;
|
|
189
|
+
/** Register DRIZZLE_TENANT_DB as a transient factory in DI */
|
|
190
|
+
beforeStart({
|
|
191
|
+
container
|
|
192
|
+
}: AdapterContext): Promise<void>;
|
|
193
|
+
/** Evict connections that haven't been accessed within cacheTtl */
|
|
194
|
+
private evictStale;
|
|
195
|
+
/** Close all tenant connections on shutdown */
|
|
196
|
+
shutdown(): Promise<void>;
|
|
197
|
+
/** Number of cached tenant connections (useful for monitoring) */
|
|
198
|
+
get connectionCount(): number;
|
|
199
|
+
}
|
|
200
|
+
//#endregion
|
|
98
201
|
//#region src/query-adapter.d.ts
|
|
99
202
|
/**
|
|
100
203
|
* Configuration for the Drizzle query builder adapter.
|
|
@@ -336,5 +439,5 @@ declare class DrizzleQueryAdapter implements QueryBuilderAdapter<DrizzleQueryRes
|
|
|
336
439
|
private coerceByDataType;
|
|
337
440
|
}
|
|
338
441
|
//#endregion
|
|
339
|
-
export { DRIZZLE_DB, DrizzleAdapter, type DrizzleAdapterOptions, type DrizzleColumnQueryConfig, type DrizzleOps, DrizzleQueryAdapter, type DrizzleQueryConfig, type DrizzleQueryParamsConfig, type DrizzleQueryResult, toQueryFieldConfig };
|
|
442
|
+
export { DRIZZLE_DB, DRIZZLE_TENANT_DB, DrizzleAdapter, type DrizzleAdapterOptions, type DrizzleColumnQueryConfig, type DrizzleOps, DrizzleQueryAdapter, type DrizzleQueryConfig, type DrizzleQueryParamsConfig, type DrizzleQueryResult, DrizzleTenantAdapter, type DrizzleTenantAdapterOptions, toQueryFieldConfig };
|
|
340
443
|
//# sourceMappingURL=index.d.mts.map
|
package/dist/index.d.mts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
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;
|
|
1
|
+
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/drizzle.adapter.ts","../src/drizzle-tenant.adapter.ts","../src/query-adapter.ts"],"mappings":"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"}
|
package/dist/index.mjs
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* @forinda/kickjs-drizzle
|
|
2
|
+
* @forinda/kickjs-drizzle v3.0.2
|
|
3
3
|
*
|
|
4
4
|
* Copyright (c) Felix Orinda
|
|
5
5
|
*
|
|
@@ -10,11 +10,13 @@
|
|
|
10
10
|
*/
|
|
11
11
|
import { Logger, Scope } from "@forinda/kickjs";
|
|
12
12
|
//#region src/types.ts
|
|
13
|
-
/** DI token for resolving the Drizzle database instance from the container */
|
|
13
|
+
/** DI token for resolving the Drizzle database instance from the container (single-tenant) */
|
|
14
14
|
const DRIZZLE_DB = Symbol("DrizzleDB");
|
|
15
|
+
/** DI token for resolving the current tenant's Drizzle database instance (multi-tenant) */
|
|
16
|
+
const DRIZZLE_TENANT_DB = Symbol("DrizzleTenantDB");
|
|
15
17
|
//#endregion
|
|
16
18
|
//#region src/drizzle.adapter.ts
|
|
17
|
-
const log = Logger.for("DrizzleAdapter");
|
|
19
|
+
const log$1 = Logger.for("DrizzleAdapter");
|
|
18
20
|
/**
|
|
19
21
|
* Drizzle ORM adapter — registers a Drizzle database instance in the DI
|
|
20
22
|
* container and manages its lifecycle.
|
|
@@ -63,19 +65,147 @@ var DrizzleAdapter = class {
|
|
|
63
65
|
}
|
|
64
66
|
/** Register the Drizzle db instance in the DI container */
|
|
65
67
|
beforeStart({ container }) {
|
|
66
|
-
if (this.options.logging) log.info("Query logging enabled");
|
|
68
|
+
if (this.options.logging) log$1.info("Query logging enabled");
|
|
67
69
|
container.registerFactory(DRIZZLE_DB, () => this.db, Scope.SINGLETON);
|
|
68
|
-
log.info("Drizzle database registered in DI container");
|
|
70
|
+
log$1.info("Drizzle database registered in DI container");
|
|
69
71
|
}
|
|
70
72
|
/** Close the underlying connection on shutdown */
|
|
71
73
|
async shutdown() {
|
|
72
74
|
if (this.onShutdown) {
|
|
73
75
|
await this.onShutdown();
|
|
74
|
-
log.info("Drizzle connection closed");
|
|
76
|
+
log$1.info("Drizzle connection closed");
|
|
75
77
|
}
|
|
76
78
|
}
|
|
77
79
|
};
|
|
78
80
|
//#endregion
|
|
81
|
+
//#region src/drizzle-tenant.adapter.ts
|
|
82
|
+
const log = Logger.for("DrizzleTenantAdapter");
|
|
83
|
+
/**
|
|
84
|
+
* Multi-tenant Drizzle adapter — manages per-tenant database connections
|
|
85
|
+
* with automatic caching and lifecycle management.
|
|
86
|
+
*
|
|
87
|
+
* Registers `DRIZZLE_TENANT_DB` as a TRANSIENT DI token that resolves
|
|
88
|
+
* to the current tenant's Drizzle instance using AsyncLocalStorage
|
|
89
|
+
* (requires `TenantAdapter` to be configured).
|
|
90
|
+
*
|
|
91
|
+
* Works alongside `DrizzleAdapter` — use `DRIZZLE_DB` for the provider
|
|
92
|
+
* database and `DRIZZLE_TENANT_DB` for the current tenant's database.
|
|
93
|
+
*
|
|
94
|
+
* @example
|
|
95
|
+
* ```ts
|
|
96
|
+
* import { drizzle } from 'drizzle-orm/node-postgres'
|
|
97
|
+
* import { Pool } from 'pg'
|
|
98
|
+
* import * as schema from './schema'
|
|
99
|
+
*
|
|
100
|
+
* const providerDb = drizzle(new Pool({ connectionString: PROVIDER_URL }), { schema })
|
|
101
|
+
*
|
|
102
|
+
* bootstrap({
|
|
103
|
+
* adapters: [
|
|
104
|
+
* new TenantAdapter({ strategy: 'subdomain' }),
|
|
105
|
+
* new DrizzleTenantAdapter({
|
|
106
|
+
* providerDb,
|
|
107
|
+
* tenantFactory: async (tenantId) => {
|
|
108
|
+
* const url = await lookupTenantDbUrl(tenantId)
|
|
109
|
+
* return drizzle(new Pool({ connectionString: url }), { schema })
|
|
110
|
+
* },
|
|
111
|
+
* }),
|
|
112
|
+
* ],
|
|
113
|
+
* })
|
|
114
|
+
* ```
|
|
115
|
+
*
|
|
116
|
+
* Inject in services:
|
|
117
|
+
* ```ts
|
|
118
|
+
* @Service()
|
|
119
|
+
* class ProjectService {
|
|
120
|
+
* constructor(@Inject(DRIZZLE_TENANT_DB) private db: NodePgDatabase<typeof schema>) {}
|
|
121
|
+
* }
|
|
122
|
+
* ```
|
|
123
|
+
*/
|
|
124
|
+
var DrizzleTenantAdapter = class {
|
|
125
|
+
name = "DrizzleTenantAdapter";
|
|
126
|
+
providerDb;
|
|
127
|
+
tenantFactory;
|
|
128
|
+
connections = /* @__PURE__ */ new Map();
|
|
129
|
+
lastAccessed = /* @__PURE__ */ new Map();
|
|
130
|
+
options;
|
|
131
|
+
evictionTimer;
|
|
132
|
+
constructor(options) {
|
|
133
|
+
this.options = options;
|
|
134
|
+
this.providerDb = options.providerDb;
|
|
135
|
+
this.tenantFactory = options.tenantFactory;
|
|
136
|
+
if (options.cacheTtl && options.cacheTtl > 0) {
|
|
137
|
+
const interval = Math.min(options.cacheTtl, 6e4);
|
|
138
|
+
this.evictionTimer = setInterval(() => this.evictStale(), interval);
|
|
139
|
+
this.evictionTimer.unref();
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
/**
|
|
143
|
+
* Get the database for a specific tenant.
|
|
144
|
+
* Creates and caches the connection on first access.
|
|
145
|
+
* Returns the provider DB when tenantId is undefined/null.
|
|
146
|
+
*/
|
|
147
|
+
async getDb(tenantId) {
|
|
148
|
+
if (!tenantId) return this.providerDb;
|
|
149
|
+
const cached = this.connections.get(tenantId);
|
|
150
|
+
if (cached) {
|
|
151
|
+
this.lastAccessed.set(tenantId, Date.now());
|
|
152
|
+
return cached;
|
|
153
|
+
}
|
|
154
|
+
const db = await this.tenantFactory(tenantId);
|
|
155
|
+
this.connections.set(tenantId, db);
|
|
156
|
+
this.lastAccessed.set(tenantId, Date.now());
|
|
157
|
+
if (this.options.logging) log.info(`Tenant DB created: ${tenantId} (${this.connections.size} total)`);
|
|
158
|
+
return db;
|
|
159
|
+
}
|
|
160
|
+
/** Register DRIZZLE_TENANT_DB as a transient factory in DI */
|
|
161
|
+
async beforeStart({ container }) {
|
|
162
|
+
let getCurrentTenant;
|
|
163
|
+
try {
|
|
164
|
+
getCurrentTenant = (await import("@forinda/kickjs-multi-tenant")).getCurrentTenant;
|
|
165
|
+
} catch {
|
|
166
|
+
log.warn("DrizzleTenantAdapter: @forinda/kickjs-multi-tenant not found. DRIZZLE_TENANT_DB will always resolve to the provider database.");
|
|
167
|
+
}
|
|
168
|
+
container.registerFactory(DRIZZLE_TENANT_DB, () => {
|
|
169
|
+
const tenant = getCurrentTenant?.();
|
|
170
|
+
return this.getDb(tenant?.id);
|
|
171
|
+
}, Scope.TRANSIENT);
|
|
172
|
+
log.info(`Drizzle tenant DB registered (${getCurrentTenant ? "multi-tenant mode" : "provider-only mode"})`);
|
|
173
|
+
}
|
|
174
|
+
/** Evict connections that haven't been accessed within cacheTtl */
|
|
175
|
+
async evictStale() {
|
|
176
|
+
const ttl = this.options.cacheTtl;
|
|
177
|
+
if (!ttl) return;
|
|
178
|
+
const now = Date.now();
|
|
179
|
+
for (const [tenantId, lastTime] of this.lastAccessed) if (now - lastTime > ttl) {
|
|
180
|
+
const db = this.connections.get(tenantId);
|
|
181
|
+
if (db && this.options.onTenantShutdown) try {
|
|
182
|
+
await this.options.onTenantShutdown(db, tenantId);
|
|
183
|
+
} catch (err) {
|
|
184
|
+
log.error(`Failed to evict tenant DB ${tenantId}: ${err}`);
|
|
185
|
+
}
|
|
186
|
+
this.connections.delete(tenantId);
|
|
187
|
+
this.lastAccessed.delete(tenantId);
|
|
188
|
+
if (this.options.logging) log.info(`Tenant DB evicted (idle): ${tenantId}`);
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
/** Close all tenant connections on shutdown */
|
|
192
|
+
async shutdown() {
|
|
193
|
+
if (this.evictionTimer) clearInterval(this.evictionTimer);
|
|
194
|
+
if (this.options.onTenantShutdown) for (const [tenantId, db] of this.connections) try {
|
|
195
|
+
await this.options.onTenantShutdown(db, tenantId);
|
|
196
|
+
} catch (err) {
|
|
197
|
+
log.error(`Failed to close tenant DB ${tenantId}: ${err}`);
|
|
198
|
+
}
|
|
199
|
+
this.connections.clear();
|
|
200
|
+
this.lastAccessed.clear();
|
|
201
|
+
log.info("All tenant DB connections closed");
|
|
202
|
+
}
|
|
203
|
+
/** Number of cached tenant connections (useful for monitoring) */
|
|
204
|
+
get connectionCount() {
|
|
205
|
+
return this.connections.size;
|
|
206
|
+
}
|
|
207
|
+
};
|
|
208
|
+
//#endregion
|
|
79
209
|
//#region src/query-adapter.ts
|
|
80
210
|
/**
|
|
81
211
|
* Convert a DrizzleQueryParamsConfig into a string-based QueryFieldConfig.
|
|
@@ -292,6 +422,6 @@ var DrizzleQueryAdapter = class {
|
|
|
292
422
|
}
|
|
293
423
|
};
|
|
294
424
|
//#endregion
|
|
295
|
-
export { DRIZZLE_DB, DrizzleAdapter, DrizzleQueryAdapter, toQueryFieldConfig };
|
|
425
|
+
export { DRIZZLE_DB, DRIZZLE_TENANT_DB, DrizzleAdapter, DrizzleQueryAdapter, DrizzleTenantAdapter, toQueryFieldConfig };
|
|
296
426
|
|
|
297
427
|
//# sourceMappingURL=index.mjs.map
|
package/dist/index.mjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
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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"}
|
|
1
|
+
{"version":3,"file":"index.mjs","names":["log"],"sources":["../src/types.ts","../src/drizzle.adapter.ts","../src/drizzle-tenant.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 (single-tenant) */\nexport const DRIZZLE_DB = Symbol('DrizzleDB')\n\n/** DI token for resolving the current tenant's Drizzle database instance (multi-tenant) */\nexport const DRIZZLE_TENANT_DB = Symbol('DrizzleTenantDB')\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\nexport interface DrizzleTenantAdapterOptions<TDb = unknown> {\n /**\n * The provider (default) database instance. Used when no tenant is\n * resolved or when accessing the tenant registry.\n */\n providerDb: TDb\n\n /**\n * Factory that creates a typed Drizzle instance for a given tenant.\n * Called once per tenant — the result is cached for subsequent requests.\n *\n * @example\n * ```ts\n * tenantFactory: async (tenantId) => {\n * const url = await lookupTenantDbUrl(tenantId)\n * return drizzle(new Pool({ connectionString: url }), { schema })\n * }\n * ```\n */\n tenantFactory: (tenantId: string) => TDb | Promise<TDb>\n\n /**\n * Optional function to close a tenant DB connection.\n * Called for each cached connection during shutdown.\n */\n onTenantShutdown?: (db: TDb, tenantId: string) => MaybePromise<any>\n\n /** Enable query logging (default: false) */\n logging?: boolean\n\n /**\n * Cache TTL in milliseconds. Tenant connections idle beyond this\n * duration are evicted. Default: no eviction (connections live until shutdown).\n */\n cacheTtl?: number\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 { Logger, type AppAdapter, type AdapterContext, Scope } from '@forinda/kickjs'\nimport { DRIZZLE_TENANT_DB, type DrizzleTenantAdapterOptions } from './types'\n\nconst log = Logger.for('DrizzleTenantAdapter')\n\n/**\n * Multi-tenant Drizzle adapter — manages per-tenant database connections\n * with automatic caching and lifecycle management.\n *\n * Registers `DRIZZLE_TENANT_DB` as a TRANSIENT DI token that resolves\n * to the current tenant's Drizzle instance using AsyncLocalStorage\n * (requires `TenantAdapter` to be configured).\n *\n * Works alongside `DrizzleAdapter` — use `DRIZZLE_DB` for the provider\n * database and `DRIZZLE_TENANT_DB` for the current tenant's database.\n *\n * @example\n * ```ts\n * import { drizzle } from 'drizzle-orm/node-postgres'\n * import { Pool } from 'pg'\n * import * as schema from './schema'\n *\n * const providerDb = drizzle(new Pool({ connectionString: PROVIDER_URL }), { schema })\n *\n * bootstrap({\n * adapters: [\n * new TenantAdapter({ strategy: 'subdomain' }),\n * new DrizzleTenantAdapter({\n * providerDb,\n * tenantFactory: async (tenantId) => {\n * const url = await lookupTenantDbUrl(tenantId)\n * return drizzle(new Pool({ connectionString: url }), { schema })\n * },\n * }),\n * ],\n * })\n * ```\n *\n * Inject in services:\n * ```ts\n * @Service()\n * class ProjectService {\n * constructor(@Inject(DRIZZLE_TENANT_DB) private db: NodePgDatabase<typeof schema>) {}\n * }\n * ```\n */\nexport class DrizzleTenantAdapter<TDb = unknown> implements AppAdapter {\n name = 'DrizzleTenantAdapter'\n private readonly providerDb: TDb\n private readonly tenantFactory: (tenantId: string) => TDb | Promise<TDb>\n private readonly connections = new Map<string, TDb>()\n private readonly lastAccessed = new Map<string, number>()\n private readonly options: DrizzleTenantAdapterOptions<TDb>\n private readonly evictionTimer?: ReturnType<typeof setInterval>\n\n constructor(options: DrizzleTenantAdapterOptions<TDb>) {\n this.options = options\n this.providerDb = options.providerDb\n this.tenantFactory = options.tenantFactory\n\n // Start cache eviction timer if cacheTtl is configured\n if (options.cacheTtl && options.cacheTtl > 0) {\n const interval = Math.min(options.cacheTtl, 60_000)\n this.evictionTimer = setInterval(() => this.evictStale(), interval)\n this.evictionTimer.unref()\n }\n }\n\n /**\n * Get the database for a specific tenant.\n * Creates and caches the connection on first access.\n * Returns the provider DB when tenantId is undefined/null.\n */\n async getDb(tenantId?: string | null): Promise<TDb> {\n if (!tenantId) return this.providerDb\n\n const cached = this.connections.get(tenantId)\n if (cached) {\n this.lastAccessed.set(tenantId, Date.now())\n return cached\n }\n\n const db = await this.tenantFactory(tenantId)\n this.connections.set(tenantId, db)\n this.lastAccessed.set(tenantId, Date.now())\n\n if (this.options.logging) {\n log.info(`Tenant DB created: ${tenantId} (${this.connections.size} total)`)\n }\n\n return db\n }\n\n /** Register DRIZZLE_TENANT_DB as a transient factory in DI */\n async beforeStart({ container }: AdapterContext): Promise<void> {\n // Dynamically import getCurrentTenant to avoid hard dep on multi-tenant package\n let getCurrentTenant: (() => { id: string } | undefined) | undefined\n\n try {\n // @ts-expect-error optional peer dependency\n const mt = await import('@forinda/kickjs-multi-tenant')\n getCurrentTenant = mt.getCurrentTenant\n } catch {\n log.warn(\n 'DrizzleTenantAdapter: @forinda/kickjs-multi-tenant not found. ' +\n 'DRIZZLE_TENANT_DB will always resolve to the provider database.',\n )\n }\n\n container.registerFactory(\n DRIZZLE_TENANT_DB,\n () => {\n const tenant = getCurrentTenant?.()\n return this.getDb(tenant?.id)\n },\n Scope.TRANSIENT,\n )\n\n log.info(\n `Drizzle tenant DB registered (${getCurrentTenant ? 'multi-tenant mode' : 'provider-only mode'})`,\n )\n }\n\n /** Evict connections that haven't been accessed within cacheTtl */\n private async evictStale(): Promise<void> {\n const ttl = this.options.cacheTtl\n if (!ttl) return\n\n const now = Date.now()\n for (const [tenantId, lastTime] of this.lastAccessed) {\n if (now - lastTime > ttl) {\n const db = this.connections.get(tenantId)\n if (db && this.options.onTenantShutdown) {\n try {\n await this.options.onTenantShutdown(db, tenantId)\n } catch (err) {\n log.error(`Failed to evict tenant DB ${tenantId}: ${err}`)\n }\n }\n this.connections.delete(tenantId)\n this.lastAccessed.delete(tenantId)\n\n if (this.options.logging) {\n log.info(`Tenant DB evicted (idle): ${tenantId}`)\n }\n }\n }\n }\n\n /** Close all tenant connections on shutdown */\n async shutdown(): Promise<void> {\n if (this.evictionTimer) clearInterval(this.evictionTimer)\n\n if (this.options.onTenantShutdown) {\n for (const [tenantId, db] of this.connections) {\n try {\n await this.options.onTenantShutdown(db, tenantId)\n } catch (err) {\n log.error(`Failed to close tenant DB ${tenantId}: ${err}`)\n }\n }\n }\n\n this.connections.clear()\n this.lastAccessed.clear()\n log.info('All tenant DB connections closed')\n }\n\n /** Number of cached tenant connections (useful for monitoring) */\n get connectionCount(): number {\n return this.connections.size\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
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@forinda/kickjs-drizzle",
|
|
3
|
-
"version": "
|
|
3
|
+
"version": "3.0.2",
|
|
4
4
|
"description": "Drizzle ORM adapter with DI integration, transaction support, and query building for KickJS",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"kickjs",
|
|
@@ -73,15 +73,22 @@
|
|
|
73
73
|
}
|
|
74
74
|
},
|
|
75
75
|
"dependencies": {
|
|
76
|
-
"reflect-metadata": "^0.2.2"
|
|
77
|
-
"@forinda/kickjs": "2.3.3"
|
|
76
|
+
"reflect-metadata": "^0.2.2"
|
|
78
77
|
},
|
|
79
78
|
"peerDependencies": {
|
|
80
|
-
"drizzle-orm": ">=0.30.0"
|
|
79
|
+
"drizzle-orm": ">=0.30.0",
|
|
80
|
+
"@forinda/kickjs-multi-tenant": ">=2.0.0",
|
|
81
|
+
"@forinda/kickjs": ">=2.3.0"
|
|
82
|
+
},
|
|
83
|
+
"peerDependenciesMeta": {
|
|
84
|
+
"@forinda/kickjs-multi-tenant": {
|
|
85
|
+
"optional": true
|
|
86
|
+
}
|
|
81
87
|
},
|
|
82
88
|
"devDependencies": {
|
|
83
89
|
"@types/node": "^25.0.0",
|
|
84
|
-
"typescript": "^5.9.2"
|
|
90
|
+
"typescript": "^5.9.2",
|
|
91
|
+
"@forinda/kickjs": "3.0.2"
|
|
85
92
|
},
|
|
86
93
|
"publishConfig": {
|
|
87
94
|
"access": "public"
|