giuseppe-trisciuoglio/developer-kit

nestjs-drizzle-crud-generator

Generates complete CRUD modules for NestJS applications with Drizzle ORM.

Ver código fuente

Cómo usar

  1. Copia el comando y revisa el paquete antes de instalarlo en tu entorno de agente.
  2. Consulta las herramientas, credenciales y entornos necesarios en el documento original.
  3. Describe las entradas y el resultado deseado; contrasta la salida con las fuentes.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill nestjs-drizzle-crud-generator

Antes de empezar

  • La instalación no incluye suscripción al modelo, cuota API ni permisos sobre tus archivos.
  • Las estrellas e instalaciones reflejan actividad, no una prueba independiente de calidad o seguridad.
Documento original del Skill

Contenido del repositorio de origen con títulos, ejemplos, código, tablas, enlaces e imágenes preservados.

NestJS Drizzle CRUD Generator

Overview

Automatically generates complete CRUD modules for NestJS applications using Drizzle ORM. Creates all necessary files following the zaccheroni-monorepo patterns: feature modules, controllers, services, Zod-validated DTOs, Drizzle schemas, and Jest unit tests.

When to Use

  • Creating new entity modules with full CRUD endpoints
  • Building database-backed features in NestJS
  • Generating type-safe DTOs with Zod validation
  • Adding services with Drizzle ORM queries
  • Creating unit tests with mocked database

Instructions

Step 1: Define Entity Fields

Gather entity definition:

  • Entity name (e.g., user, product, order)
  • List of fields with types (see references/field-types.md for supported types)
  • Required fields vs optional fields with defaults

Step 2: Run the Generator

bash
python scripts/generate_crud.py --feature <name> --fields '<json-array>' --output <path>

Step 3: Verify Generated Files

Check that all expected files were created:

bash
ls -la libs/server/<feature-name>/src/lib/

Expected structure:

controllers/
services/
dto/
schema/
<feature>-feature.module.ts

Step 4: Run TypeScript Compilation

bash
cd libs/server && npx tsc --noEmit

Step 5: Execute Unit Tests

bash
cd libs/server && npm test -- --testPathPattern=<feature-name>

Examples

Generate a User module

bash
python scripts/generate_crud.py \
  --feature user \
  --fields '[{"name": "name", "type": "string", "required": true}, {"name": "email", "type": "email", "required": true}, {"name": "password", "type": "string", "required": true}]' \
  --output ./libs/server

Generate a Product module

bash
python scripts/generate_crud.py \
  --feature product \
  --fields '[{"name": "title", "type": "string", "required": true}, {"name": "price", "type": "number", "required": true}, {"name": "description", "type": "text", "required": false}, {"name": "inStock", "type": "boolean", "required": false, "default": true}]' \
  --output ./libs/server

Generated Structure

libs/server/{feature-name}/
├── src/
│   ├── index.ts
│   └── lib/
│       ├── {feature}-feature.module.ts
│       ├── controllers/
│       │   ├── index.ts
│       │   └── {feature}.controller.ts
│       ├── services/
│       │   ├── index.ts
│       │   ├── {feature}.service.ts
│       │   └── {feature}.service.spec.ts
│       ├── dto/
│       │   ├── index.ts
│       │   └── {feature}.dto.ts
│       └── schema/
│           └── {feature}.table.ts

Features

Module

  • Uses forRootAsync pattern for lazy configuration
  • Exports generated service for other modules
  • Imports DatabaseModule for feature tables

Controller

  • Full CRUD endpoints: POST, GET, PATCH, DELETE
  • Query parameter validation for pagination
  • Zod validation pipe integration

Service

  • Drizzle ORM query methods
  • Soft delete support (via deletedAt column)
  • Pagination with limit/offset
  • Filtering support
  • Type-safe return types

DTOs

  • Zod schemas for Create and Update
  • Query parameter schemas for filtering
  • NestJS DTO integration

Tests

  • Jest test suite
  • Mocked Drizzle database
  • Test cases for all CRUD operations

Manual Integration

After generation, integrate into your app module:

typescript
// app.module.ts
import { {{FeatureName}}FeatureModule } from '@your-org/server-{{feature}}';

@Module({
  imports: [
    {{FeatureName}}FeatureModule.forRootAsync({
      useFactory: () => ({
        defaultPageSize: 10,
        maxPageSize: 100,
      }),
    }),
  ],
})
export class AppModule {}

Dependencies

Required packages:

  • @nestjs/common
  • @nestjs/core
  • drizzle-orm
  • drizzle-zod
  • zod
  • nestjs-zod

Best Practices

  1. Verify before commit: Always run tsc --noEmit and tests before committing generated code
  2. Customize services: Add business logic to generated services after validation
  3. Database migrations: Create migrations separately for generated Drizzle schemas
  4. Use generated types: Reference generated types in your application code
  5. Review DTOs: Adjust Zod validation rules based on your API requirements

Constraints and Warnings

  • Soft delete only: Delete operations use soft delete (deletedAt timestamp). Hard deletes require manual modification
  • No authentication: Generated code does not include auth guards - add them based on your security requirements
  • Basic CRUD only: Complex queries, transactions, or business logic must be implemented manually
  • JSON escaping: Use single quotes around the JSON array when passing fields on command line

Relacionados por tarea

del mismo repositorio

Más Skills

Todos los Skills
giuseppe-trisciuoglio
Comunidad

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

Instalaciones / 1h
2
GitHub Stars
372
Actualizado
10 sept
giuseppe-trisciuoglio
Comunidad

adr-drafting

Creates new Architecture Decision Record (ADR) documents for significant architectural changes using a consistent template and repository-aware naming and storage guidance. Use when a user or agent decides on an architectural change, needs to document technical rationale, or wants to add a new ADR to the project history.

Instalaciones / 1h
1
GitHub Stars
372
Actualizado
10 sept
giuseppe-trisciuoglio
Comunidad

clean-architecture

Provides implementation patterns for Clean Architecture, Hexagonal Architecture (Ports & Adapters), and Domain-Driven Design in PHP 8.3+ with Symfony 7.x. Use when architecting enterprise PHP applications with entities/value objects/aggregates, refactoring legacy code to modern patterns, implementing domain-driven design with Symfony, or creating testable backends with clear separation of concerns.

Instalaciones / 1h
1
GitHub Stars
372
Actualizado
10 sept
giuseppe-trisciuoglio
Comunidad

langchain4j-spring-boot-integration

Provides integration patterns for LangChain4j with Spring Boot. Configures AI model beans, sets up chat memory with Spring context, integrates RAG pipelines with Spring Data, and handles auto-configuration, dependency injection, and Spring ecosystem integration. Use when embedding LangChain4j into Spring Boot applications, building Java LLM applications with @Bean configuration, or setting up Spring AI patterns.

Instalaciones / 1h
1
GitHub Stars
372
Actualizado
10 sept