SQL_ORM=none                # no SQL ORM / PostgreSQL (products context disabled)
FEATURE_MONGOOSE=false      # ReviewsModule and MongoDB disabled
PROFILER_ENABLED=true
PROFILER_STORAGE_TYPE=memory

docker compose up -d

# Profile SQL queries through MikroORM instead of TypeORM
SQL_ORM=mikro-orm pnpm example:dev

# Run without any database (Posts, Auth, Config, Validator, GraphQL collectors still active)
SQL_ORM=none FEATURE_MONGOOSE=false pnpm example:dev

# Run without GraphQL
FEATURE_GRAPHQL=false pnpm example:dev

pnpm example:dev

pnpm --filter example-api build

# Fetches posts via axios and caches them — the profile shows Command + HTTP Client + Cache panels
FEATURE_TYPEORM=false FEATURE_MONGOOSE=false pnpm --filter example-api cli sync:posts --limit 3

# A trivial command; add --fail to produce a failed profile (Exceptions tab)
FEATURE_TYPEORM=false FEATURE_MONGOOSE=false pnpm --filter example-api cli demo:greet --name Fabien

query GetBooks {
  books {
    id
    title
    author
    publishedYear
  }
}

query GetBook($id: ID!) {
  book(id: $id) {
    id
    title
    author
    publishedYear
  }
}

mutation CreateBook($title: String!, $author: String!, $publishedYear: Int) {
  createBook(input: { title: $title, author: $author, publishedYear: $publishedYear }) {
    id
    title
    author
    publishedYear
  }
}

AppModule
├── ProductModule  → selects ONE adapter by SQL_ORM (mutually exclusive):
│     ├── ProductTypeOrmModule   [SQL_ORM=typeorm]   → TypeOrmCollectorModule (nest-profiler-typeorm)
│     └── ProductMikroOrmModule  [SQL_ORM=mikro-orm] → MikroOrmCollectorModule (nest-profiler-mikro-orm)
│           (both bind the same ProductRepository port; SQL_ORM=none loads neither)
├── MongoModule [FEATURE_MONGOOSE]
│   └── ReviewsModule   → MongooseCollectorModule (nest-profiler-mongoose)
├── AppGraphQLModule [FEATURE_GRAPHQL]
│   └── BooksModule     → ProfilerGraphQLModule (nest-profiler-graphql) + Apollo Server
├── PostsModule     → AxiosCollectorModule + CacheCollectorModule
│                     uses global ValidatorCollectorModule (POST /posts)
├── AuthModule      → AuthCollectorModule (nest-profiler-auth)
├── ConfigCollectorModule  (nest-profiler-config, global)
└── ValidatorCollectorModule (nest-profiler-validator, global APP_PIPE)

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      load: [appConfig, featuresConfig],
    }),
    ConditionalModule.registerWhen(ProductModule, isSqlOrmEnabled), // skipped when SQL_ORM=none
    ConditionalModule.registerWhen(MongoModule, isMongooseEnabled),
    CacheModule.register({ isGlobal: true, ttl: 30000 }),
    ProfilerModule.forRoot({ isGlobal: true, storageType: 'file', storagePath: '.profiler' }),
    ConfigCollectorModule.forRoot({ maskKeys: ['database.password'] }),
    ValidatorCollectorModule.forRoot({ whitelist: true, transform: true }),
    AuthModule,
    PostsModule,
  ],
})
export class AppModule {}

@Module({
  imports: [
    ConditionalModule.registerWhen(ProductTypeOrmModule, isSqlOrm('typeorm')),
    ConditionalModule.registerWhen(ProductMikroOrmModule, isSqlOrm('mikro-orm')),
  ],
  controllers: [ProductController],
  providers: [ProductService], // injects ProductRepository, exported by the active adapter
})
export class ProductModule {}

products/
├── product.module.ts    controller + service; selects one adapter by SQL_ORM (ConditionalModule)
├── domain/         product.ts, product.repository.ts  (ProductRepository port = DI token)
├── application/    product.service.ts                 (depends only on the port)
├── http/           product.controller.ts, dto/
└── infrastructure/
    ├── typeorm/     product.typeorm.{entity,repository,module}.ts   (+ TypeOrmCollectorModule)
    └── mikro-orm/   product.mikro-orm.{entity,repository,module}.ts (+ MikroOrmCollectorModule)

@Module({
  imports: [
    MikroOrmModule.forRootAsync({
      /* Postgres, driver: PostgreSqlDriver */
    }),
    MikroOrmModule.forFeature([ProductEntity]),
    MikroOrmCollectorModule.forRoot({ slowQueryThreshold: 50 }),
  ],
  providers: [{ provide: ProductRepository, useClass: MikroOrmProductRepository }],
  exports: [ProductRepository],
})
export class ProductMikroOrmModule {}

@Module({
  imports: [
    HttpModule, // prerequisite for AxiosCollectorModule
    AxiosCollectorModule.forRoot(),
    CacheCollectorModule.forRoot(),
  ],
  controllers: [PostsController],
})
export class PostsModule {}

@Module({
  imports: [
    MongooseModule.forFeature([{ name: Review.name, schema: ReviewSchema }]),
    MongooseCollectorModule.forRoot({ slowQueryThreshold: 50 }),
  ],
})
export class ReviewsModule {}

@Module({
  imports: [
    ProfilerGraphQLModule.forRoot(),
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: true,
      context: ({ req }) => ({ req }), // exposes the request to the profiler adapter
    }),
    BooksModule,
  ],
})
export class AppGraphQLModule {}

@Module({
  imports: [AuthCollectorModule.forRoot({ maskUserFields: ['password', 'refreshToken'] })],
})
export class AuthModule {}

# default (SQL_ORM=typeorm), or run with SQL_ORM=mikro-orm pnpm example:dev
curl http://localhost:3000/products
curl http://localhost:3000/products/1
curl -X POST http://localhost:3000/products \
  -H "Content-Type: application/json" \
  -d '{"name":"Widget","price":9.99}'

# MISS + axios call + SET
curl http://localhost:3000/posts

# HIT — no axios call
curl http://localhost:3000/posts

# Reset
curl http://localhost:3000/posts/cache/clear

# List all reviews (Mongoose find)
curl http://localhost:3000/reviews

# Create a review
curl -X POST http://localhost:3000/reviews \
  -H "Content-Type: application/json" \
  -d '{"productId":"abc123","rating":4,"comment":"Great product!","author":"Alice"}'

# Aggregation pipeline — average rating per product
curl http://localhost:3000/reviews/stats

TOKEN=$(curl -s "http://localhost:3000/auth/token?role=admin" | jq -r .token)
curl -H "Authorization: Bearer $TOKEN" http://localhost:3000/auth/me

# Valid DTO — shows "valid" capture
curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"My post","body":"Body long enough to pass the MinLength(20) constraint."}'

# Invalid DTO — shows violations
curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"Hi","body":"Too short"}'

# Named query
curl -X POST http://localhost:3000/graphql \
  -H "Content-Type: application/json" \
  -d '{"operationName":"GetBooks","query":"query GetBooks { books { id title author publishedYear } }"}'

# Query with variable
curl -X POST http://localhost:3000/graphql \
  -H "Content-Type: application/json" \
  -d '{"operationName":"GetBook","query":"query GetBook($id: ID!) { book(id: $id) { id title author } }","variables":{"id":"1"}}'

# Mutation
curl -X POST http://localhost:3000/graphql \
  -H "Content-Type: application/json" \
  -d '{"operationName":"CreateBook","query":"mutation CreateBook($title: String!, $author: String!) { createBook(input: { title: $title, author: $author }) { id title } }","variables":{"title":"NestJS in Action","author":"John Doe"}}'

curl http://localhost:3000/slow

const app = await NestFactory.create(AppModule, { bufferLogs: true });
const profilerService = app.get(ProfilerService);

const baseLogger = isPinoLoggerEnabled(process.env)
  ? app.get(PinoLogger) // nestjs-pino
  : new ConsoleLogger('ExampleApi'); // NestJS default

app.useLogger(profilerService.createLogger(baseLogger));
await app.listen(port);

# default ConsoleLogger
FEATURE_TYPEORM=false FEATURE_MONGOOSE=false pnpm example:dev
# third-party nestjs-pino (JSON, request-bound)
FEATURE_PINO_LOGGER=true FEATURE_TYPEORM=false FEATURE_MONGOOSE=false pnpm example:dev

// NestJS style — trailing context name (appended by `new Logger(MyService.name)`)
this.logger.log('Health check');

// message-first payload — ReviewsService
this.logger.log('Fetching reviews for product', { productId });

// pino object-first — PostsController (the injected PinoLogger also provides
// its `@InjectPinoLogger(...)` context name automatically)
this.logger?.info({ postCount, authorCount, cacheKey }, 'Resolved authors, caching enriched posts');