@forinda/kickjs-cli 1.2.7 → 1.2.9

package/dist/cli.js

@@ -146,7 +146,8 @@ export default defineConfig({
         "ES2022"
       ],
       types: [
-        "node"
+        "node",
+        "vite/client"
       ],
       strict: true,
       esModuleInterop: true,
@@ -948,6 +949,28 @@ export const ${pascal.toUpperCase()}_QUERY_CONFIG: QueryParamsConfig = {
 `;
 }
 __name(generateConstants, "generateConstants");
+function generateDrizzleConstants(pascal, kebab) {
+  return `import type { DrizzleQueryParamsConfig } from '@forinda/kickjs-drizzle'
+// TODO: Import your schema table and reference actual columns for type safety
+// import { ${kebab}s } from '@/db/schema'
+
+export const ${pascal.toUpperCase()}_QUERY_CONFIG: DrizzleQueryParamsConfig = {
+  columns: {
+    // Replace with actual Drizzle Column references for type-safe filtering:
+    // name: ${kebab}s.name,
+    // status: ${kebab}s.status,
+  },
+  sortable: {
+    // name: ${kebab}s.name,
+    // createdAt: ${kebab}s.createdAt,
+  },
+  searchColumns: [
+    // ${kebab}s.name,
+  ],
+}
+`;
+}
+__name(generateDrizzleConstants, "generateDrizzleConstants");
 
 // src/generators/templates/dtos.ts
 function generateCreateDTO(pascal, kebab) {
@@ -1195,65 +1218,73 @@ function generateDrizzleRepository(pascal, kebab, repoPrefix = "../../domain/rep
  * Drizzle ${pascal} Repository
  *
  * Implements the repository interface using Drizzle ORM.
- * Requires a Drizzle database instance injected via the DI container.
+ * Uses buildFromColumns() with Column objects for type-safe query building.
  *
  * TODO: Update the schema import to match your Drizzle schema file.
- * TODO: Replace 'db' injection token with your actual database token.
+ * TODO: Replace DRIZZLE_DB injection token with your actual database token.
  *
  * @Repository() registers this class in the DI container as a singleton.
  */
-import { eq, sql } from 'drizzle-orm'
-import { Repository, HttpException, Autowired } from '@forinda/kickjs-core'
+import { eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc, count, sql } from 'drizzle-orm'
+import { Repository, HttpException, Inject } from '@forinda/kickjs-core'
+import { DRIZZLE_DB, DrizzleQueryAdapter } from '@forinda/kickjs-drizzle'
 import type { ParsedQuery } from '@forinda/kickjs-http'
 import type { I${pascal}Repository } from '${repoPrefix}/${kebab}.repository'
 import type { ${pascal}ResponseDTO } from '${dtoPrefix}/${kebab}-response.dto'
 import type { Create${pascal}DTO } from '${dtoPrefix}/create-${kebab}.dto'
 import type { Update${pascal}DTO } from '${dtoPrefix}/update-${kebab}.dto'
+import { ${pascal.toUpperCase()}_QUERY_CONFIG } from '../../constants'
 
 // TODO: Import your Drizzle schema table \u2014 e.g.:
 // import { ${kebab}s } from '@/db/schema'
 
-// TODO: Import your Drizzle DB injection token \u2014 e.g.:
-// import { DRIZZLE_DB } from '@/db/drizzle.provider'
+const queryAdapter = new DrizzleQueryAdapter({
+  eq, ne, gt, gte, lt, lte, ilike, inArray, between, and, or, asc, desc,
+})
 
 @Repository()
 export class Drizzle${pascal}Repository implements I${pascal}Repository {
-  // TODO: Uncomment and configure your Drizzle DB injection:
-  // @Autowired(DRIZZLE_DB) private db!: DrizzleDB
+  constructor(@Inject(DRIZZLE_DB) private db: any) {}
 
   async findById(id: string): Promise<${pascal}ResponseDTO | null> {
     // TODO: Implement with Drizzle
-    // const [row] = await this.db.select().from(${kebab}s).where(eq(${kebab}s.id, id))
+    // const row = this.db.select().from(${kebab}s).where(eq(${kebab}s.id, id)).get()
     // return row ?? null
     throw new Error('Drizzle ${pascal} repository not yet implemented \u2014 update schema imports and queries')
   }
 
   async findAll(): Promise<${pascal}ResponseDTO[]> {
     // TODO: Implement with Drizzle
-    // return this.db.select().from(${kebab}s)
+    // return this.db.select().from(${kebab}s).all()
     throw new Error('Drizzle ${pascal} repository not yet implemented')
   }
 
   async findPaginated(parsed: ParsedQuery): Promise<{ data: ${pascal}ResponseDTO[]; total: number }> {
-    // TODO: Implement with Drizzle
-    // const data = await this.db.select().from(${kebab}s)
-    //   .limit(parsed.pagination.limit)
-    //   .offset(parsed.pagination.offset)
-    // const [{ count }] = await this.db.select({ count: sql\`count(*)\` }).from(${kebab}s)
-    // return { data, total: Number(count) }
+    // TODO: Use buildFromColumns() with your query config for type-safe filtering
+    // const query = queryAdapter.buildFromColumns(parsed, ${pascal.toUpperCase()}_QUERY_CONFIG)
+    //
+    // const data = this.db
+    //   .select().from(${kebab}s).$dynamic()
+    //   .where(query.where).orderBy(...query.orderBy)
+    //   .limit(query.limit).offset(query.offset).all()
+    //
+    // const totalResult = this.db
+    //   .select({ count: count() }).from(${kebab}s)
+    //   .$dynamic().where(query.where).get()
+    //
+    // return { data, total: totalResult?.count ?? 0 }
     throw new Error('Drizzle ${pascal} repository not yet implemented')
   }
 
   async create(dto: Create${pascal}DTO): Promise<${pascal}ResponseDTO> {
     // TODO: Implement with Drizzle
-    // const [row] = await this.db.insert(${kebab}s).values(dto).returning()
-    // return row
+    // return this.db.insert(${kebab}s).values(dto).returning().get()
     throw new Error('Drizzle ${pascal} repository not yet implemented')
   }
 
   async update(id: string, dto: Update${pascal}DTO): Promise<${pascal}ResponseDTO> {
     // TODO: Implement with Drizzle
-    // const [row] = await this.db.update(${kebab}s).set(dto).where(eq(${kebab}s.id, id)).returning()
+    // const row = this.db.update(${kebab}s).set(dto).where(eq(${kebab}s.id, id)).returning().get()
     // if (!row) throw HttpException.notFound('${pascal} not found')
     // return row
     throw new Error('Drizzle ${pascal} repository not yet implemented')
@@ -1261,8 +1292,7 @@ export class Drizzle${pascal}Repository implements I${pascal}Repository {
 
   async delete(id: string): Promise<void> {
     // TODO: Implement with Drizzle
-    // const result = await this.db.delete(${kebab}s).where(eq(${kebab}s.id, id))
-    // if (!result.rowCount) throw HttpException.notFound('${pascal} not found')
+    // this.db.delete(${kebab}s).where(eq(${kebab}s.id, id)).run()
     throw new Error('Drizzle ${pascal} repository not yet implemented')
   }
 }
@@ -2165,7 +2195,7 @@ __name(generateCqrsFiles, "generateCqrsFiles");
 async function generateDddFiles(ctx) {
   const { pascal, kebab, plural, pluralPascal, repo, noEntity, noTests, write } = ctx;
   await write("index.ts", generateModuleIndex(pascal, kebab, plural, repo));
-  await write("constants.ts", generateConstants(pascal));
+  await write("constants.ts", repo === "drizzle" ? generateDrizzleConstants(pascal, kebab) : generateConstants(pascal));
   await write(`presentation/${kebab}.controller.ts`, generateController(pascal, kebab, plural, pluralPascal));
   await write(`application/dtos/create-${kebab}.dto.ts`, generateCreateDTO(pascal, kebab));
   await write(`application/dtos/update-${kebab}.dto.ts`, generateUpdateDTO(pascal, kebab));