@stjoseph/prumo 0.0.5 → 0.1.0

package/templates/api/src/auth/auth.guard.ts

@@ -1,43 +0,0 @@
-import {
-  type CanActivate,
-  type ExecutionContext,
-  Inject,
-  Injectable,
-  UnauthorizedException,
-} from '@nestjs/common'
-import { Reflector } from '@nestjs/core'
-import { fromNodeHeaders } from 'better-auth/node'
-import type { Request } from 'express'
-import { AUTH, IS_PUBLIC } from './auth.constants'
-import type { Auth } from './auth.factory'
-
-@Injectable()
-export class AuthGuard implements CanActivate {
-  constructor(
-    private readonly reflector: Reflector,
-    @Inject(AUTH) private readonly auth: Auth,
-  ) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest<Request>()
-    const session = await this.auth.api.getSession({ headers: fromNodeHeaders(request.headers) })
-
-    request.user = session?.user
-    request.session = session?.session
-
-    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC, [
-      context.getHandler(),
-      context.getClass(),
-    ])
-
-    if (isPublic === true) {
-      return true
-    }
-
-    if (session === null) {
-      throw new UnauthorizedException()
-    }
-
-    return true
-  }
-}

package/templates/api/src/auth/auth.module.ts

@@ -1,30 +0,0 @@
-import { Global, Module } from '@nestjs/common'
-import { APP_GUARD } from '@nestjs/core'
-import { Env } from '@/config/env'
-import { UsersModule } from '@/users/users.module'
-import { UsersService } from '@/users/users.service'
-import { AUTH } from './auth.constants'
-import { AuthController } from './auth.controller'
-import { createAuth } from './auth.factory'
-import { AuthGuard } from './auth.guard'
-
-@Global()
-@Module({
-  imports: [UsersModule],
-  controllers: [AuthController],
-  providers: [
-    {
-      provide: AUTH,
-      inject: [Env, UsersService],
-      useFactory: (env: Env, users: UsersService) =>
-        createAuth(env, {
-          onUserCreated: async (user) => {
-            await users.createProfile(user.id, user.name)
-          },
-        }),
-    },
-    { provide: APP_GUARD, useClass: AuthGuard },
-  ],
-  exports: [AUTH],
-})
-export class AuthModule {}

package/templates/api/src/auth/auth.ts

@@ -1,4 +0,0 @@
-import { loadEnv } from '@/config/env'
-import { createAuth } from './auth.factory'
-
-export const auth = createAuth(loadEnv())

package/templates/api/src/auth/current-user.decorator.ts

@@ -1,9 +0,0 @@
-import { createParamDecorator, type ExecutionContext } from '@nestjs/common'
-import type { Request } from 'express'
-import type { AuthUser } from './auth.factory'
-
-export const CurrentUser = createParamDecorator(
-  (_data: unknown, context: ExecutionContext): AuthUser | undefined => {
-    return context.switchToHttp().getRequest<Request>().user
-  },
-)

package/templates/api/src/auth/express.d.ts

@@ -1,10 +0,0 @@
-import type { AuthSession, AuthUser } from './auth.factory'
-
-declare global {
-  namespace Express {
-    interface Request {
-      user?: AuthUser
-      session?: NonNullable<AuthSession>['session']
-    }
-  }
-}

package/templates/api/src/auth/public.decorator.ts

@@ -1,4 +0,0 @@
-import { SetMetadata } from '@nestjs/common'
-import { IS_PUBLIC } from './auth.constants'
-
-export const Public = () => SetMetadata(IS_PUBLIC, true)

package/templates/api/src/config/env.module.ts

@@ -1,11 +0,0 @@
-import { Global, Module } from '@nestjs/common'
-import { ConfigModule } from '@nestjs/config'
-import { Env, loadEnv } from './env'
-
-@Global()
-@Module({
-  imports: [ConfigModule.forRoot({ cache: true, ignoreEnvFile: true, validate: loadEnv })],
-  providers: [{ provide: Env, useFactory: loadEnv }],
-  exports: [Env],
-})
-export class EnvModule {}

package/templates/api/src/config/env.ts

@@ -1,81 +0,0 @@
-import 'reflect-metadata'
-import { existsSync } from 'node:fs'
-import { plainToInstance } from 'class-transformer'
-import {
-  IsEnum,
-  IsInt,
-  IsOptional,
-  IsString,
-  Matches,
-  Max,
-  Min,
-  MinLength,
-  validateSync,
-} from 'class-validator'
-
-export type NodeEnv = 'development' | 'test' | 'production'
-export type LogLevel = 'error' | 'warn' | 'info' | 'debug'
-
-export class Env {
-  @IsEnum(['development', 'test', 'production'])
-  NODE_ENV: NodeEnv
-
-  @IsInt()
-  @Min(1)
-  @Max(65535)
-  PORT: number
-
-  @IsString()
-  @MinLength(1)
-  DATABASE_URL: string
-
-  @IsString()
-  @MinLength(1)
-  AUTH_DATABASE_URL: string
-
-  @IsString()
-  @MinLength(32)
-  BETTER_AUTH_SECRET: string
-
-  @IsString()
-  @MinLength(1)
-  BETTER_AUTH_URL: string
-
-  @IsString()
-  @MinLength(1)
-  WEB_ORIGIN: string
-
-  @IsOptional()
-  @Matches(/^[a-z][a-z0-9+.-]*$/)
-  MOBILE_APP_SCHEME?: string
-
-  @IsEnum(['error', 'warn', 'info', 'debug'])
-  LOG_LEVEL: LogLevel
-}
-
-export function validate(raw: Record<string, unknown>): Env {
-  const env = plainToInstance(Env, raw, { enableImplicitConversion: true })
-  const errors = validateSync(env, { whitelist: true, forbidUnknownValues: false })
-
-  if (errors.length > 0) {
-    const named = errors.map((error) => error.property).join(', ')
-    throw new Error(`Invalid environment: ${named}`)
-  }
-
-  loaded = env
-  return env
-}
-
-let loaded: Env | undefined
-
-export function loadEnv(): Env {
-  if (loaded !== undefined) {
-    return loaded
-  }
-
-  if (process.env.NODE_ENV !== 'production' && existsSync('.env')) {
-    process.loadEnvFile('.env')
-  }
-
-  return validate(process.env)
-}

package/templates/api/src/errors/problem-details.filter.ts

@@ -1,86 +0,0 @@
-import {
-  type ArgumentsHost,
-  Catch,
-  type ExceptionFilter,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common'
-import type { Request, Response } from 'express'
-import { RequestContextService } from '@/request-context/request-context.service'
-import { ValidationFailedException } from './validation-exception.factory'
-
-type ProblemDocument = {
-  type: string
-  title: string
-  status: number
-  detail: string
-  instance: string
-  requestId?: string
-  errors?: Record<string, string[]>
-}
-
-const TITLES: Record<number, string> = {
-  400: 'Bad Request',
-  401: 'Unauthorized',
-  403: 'Forbidden',
-  404: 'Not Found',
-  409: 'Conflict',
-  422: 'Unprocessable Entity',
-  500: 'Internal Server Error',
-  503: 'Service Unavailable',
-}
-
-function detailOf(exception: HttpException): string {
-  const response = exception.getResponse()
-
-  if (typeof response === 'string') {
-    return response
-  }
-
-  const message = (response as { message?: unknown }).message
-
-  if (typeof message === 'string') {
-    return message
-  }
-
-  return exception.message
-}
-
-@Catch()
-export class ProblemDetailsFilter implements ExceptionFilter {
-  private readonly logger = new Logger(ProblemDetailsFilter.name)
-
-  constructor(private readonly context: RequestContextService) {}
-
-  catch(exception: unknown, host: ArgumentsHost): void {
-    const http = host.switchToHttp()
-    const request = http.getRequest<Request>()
-    const response = http.getResponse<Response>()
-
-    const status =
-      exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR
-
-    const problem: ProblemDocument = {
-      type: 'about:blank',
-      title: TITLES[status] ?? 'Error',
-      status,
-      detail:
-        exception instanceof HttpException && status < HttpStatus.INTERNAL_SERVER_ERROR
-          ? detailOf(exception)
-          : 'An unexpected error occurred.',
-      instance: request.originalUrl,
-      requestId: this.context.requestId,
-    }
-
-    if (exception instanceof ValidationFailedException) {
-      problem.errors = exception.fields
-    }
-
-    if (status >= HttpStatus.INTERNAL_SERVER_ERROR) {
-      this.logger.error(exception)
-    }
-
-    response.status(status).type('application/problem+json').json(problem)
-  }
-}

package/templates/api/src/errors/validation-exception.factory.ts

@@ -1,30 +0,0 @@
-import { BadRequestException, type ValidationError } from '@nestjs/common'
-
-export type FieldErrors = Record<string, string[]>
-
-function collect(errors: ValidationError[], prefix: string, into: FieldErrors): void {
-  for (const error of errors) {
-    const key = prefix === '' ? error.property : `${prefix}.${error.property}`
-    const messages = Object.values(error.constraints ?? {})
-
-    if (messages.length > 0) {
-      into[key] = messages
-    }
-
-    if (error.children !== undefined && error.children.length > 0) {
-      collect(error.children, key, into)
-    }
-  }
-}
-
-export class ValidationFailedException extends BadRequestException {
-  constructor(readonly fields: FieldErrors) {
-    super('Validation failed')
-  }
-}
-
-export function validationExceptionFactory(errors: ValidationError[]): ValidationFailedException {
-  const fields: FieldErrors = {}
-  collect(errors, '', fields)
-  return new ValidationFailedException(fields)
-}

package/templates/api/src/health/health.controller.ts

@@ -1,32 +0,0 @@
-import { Controller, Get, VERSION_NEUTRAL } from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-import {
-  HealthCheck,
-  type HealthCheckResult,
-  HealthCheckService,
-  MikroOrmHealthIndicator,
-} from '@nestjs/terminus'
-import { Public } from '@/auth/public.decorator'
-
-@ApiTags('health')
-@Controller({ path: 'health', version: VERSION_NEUTRAL })
-export class HealthController {
-  constructor(
-    private readonly health: HealthCheckService,
-    private readonly database: MikroOrmHealthIndicator,
-  ) {}
-
-  @Public()
-  @Get('live')
-  @HealthCheck()
-  live(): Promise<HealthCheckResult> {
-    return this.health.check([])
-  }
-
-  @Public()
-  @Get('ready')
-  @HealthCheck()
-  ready(): Promise<HealthCheckResult> {
-    return this.health.check([() => this.database.pingCheck('database')])
-  }
-}

package/templates/api/src/health/health.module.ts

@@ -1,9 +0,0 @@
-import { Module } from '@nestjs/common'
-import { TerminusModule } from '@nestjs/terminus'
-import { HealthController } from './health.controller'
-
-@Module({
-  imports: [TerminusModule],
-  controllers: [HealthController],
-})
-export class HealthModule {}

package/templates/api/src/main.ts

@@ -1,43 +0,0 @@
-import { MikroORM } from '@mikro-orm/postgresql'
-import { ClassSerializerInterceptor, ValidationPipe, VersioningType } from '@nestjs/common'
-import { NestFactory, Reflector } from '@nestjs/core'
-import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'
-import { Logger } from 'nestjs-pino'
-import { AppModule } from './app.module'
-import { Env } from './config/env'
-import { validationExceptionFactory } from './errors/validation-exception.factory'
-
-async function bootstrap(): Promise<void> {
-  const app = await NestFactory.create(AppModule, { bufferLogs: true })
-  const env = app.get(Env)
-
-  app.useLogger(app.get(Logger))
-  app.setGlobalPrefix('api')
-  app.enableCors({ origin: env.WEB_ORIGIN, credentials: true, exposedHeaders: ['X-Request-Id'] })
-  app.enableVersioning({ type: VersioningType.URI })
-
-  app.useGlobalPipes(
-    new ValidationPipe({
-      whitelist: true,
-      forbidNonWhitelisted: true,
-      transform: true,
-      exceptionFactory: validationExceptionFactory,
-    }),
-  )
-  app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)))
-
-  if (env.NODE_ENV !== 'production') {
-    const document = SwaggerModule.createDocument(
-      app,
-      new DocumentBuilder().setTitle('API').setVersion('1').build(),
-    )
-    SwaggerModule.setup('api/docs', app, document)
-  }
-
-  // MikroORM 7 no longer connects on init, so readiness would report the database down until a first query.
-  await app.get(MikroORM).connect()
-
-  await app.listen(env.PORT)
-}
-
-void bootstrap()

package/templates/api/src/mikro-orm.factory.ts

@@ -1,14 +0,0 @@
-import { Migrator } from '@mikro-orm/migrations'
-import { defineConfig } from '@mikro-orm/postgresql'
-import type { Env } from './config/env'
-import { Profile } from './users/entities/profile.entity'
-
-export function createOrmConfig(env: Pick<Env, 'DATABASE_URL' | 'NODE_ENV'>) {
-  return defineConfig({
-    clientUrl: env.DATABASE_URL,
-    entities: [Profile],
-    extensions: [Migrator],
-    migrations: { path: './migrations', snapshot: false },
-    debug: env.NODE_ENV === 'development',
-  })
-}

package/templates/api/src/request-context/request-context.module.ts

@@ -1,9 +0,0 @@
-import { Global, Module } from '@nestjs/common'
-import { RequestContextService } from './request-context.service'
-
-@Global()
-@Module({
-  providers: [RequestContextService],
-  exports: [RequestContextService],
-})
-export class RequestContextModule {}

package/templates/api/src/request-context/request-context.service.ts

@@ -1,17 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import { Injectable } from '@nestjs/common'
-
-type Store = { requestId: string }
-
-@Injectable()
-export class RequestContextService {
-  private readonly storage = new AsyncLocalStorage<Store>()
-
-  run<T>(requestId: string, callback: () => T): T {
-    return this.storage.run({ requestId }, callback)
-  }
-
-  get requestId(): string | undefined {
-    return this.storage.getStore()?.requestId
-  }
-}

package/templates/api/src/request-context/request-id.middleware.ts

@@ -1,19 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { Injectable, type NestMiddleware } from '@nestjs/common'
-import type { NextFunction, Request, Response } from 'express'
-import { RequestContextService } from './request-context.service'
-
-export const REQUEST_ID_HEADER = 'x-request-id'
-
-@Injectable()
-export class RequestIdMiddleware implements NestMiddleware {
-  constructor(private readonly context: RequestContextService) {}
-
-  use(request: Request, response: Response, next: NextFunction): void {
-    const inbound = request.header(REQUEST_ID_HEADER)
-    const requestId = inbound && inbound.length > 0 ? inbound : randomUUID()
-
-    response.setHeader(REQUEST_ID_HEADER, requestId)
-    this.context.run(requestId, next)
-  }
-}

package/templates/api/src/users/dto/update-profile.dto.ts

@@ -1,20 +0,0 @@
-import { IsIn, IsOptional, IsString, MaxLength, MinLength } from 'class-validator'
-
-const LOCALES = ['en', 'pt-BR'] as const
-
-export class UpdateProfileDto {
-  @IsOptional()
-  @IsString()
-  @MinLength(1)
-  @MaxLength(80)
-  displayName?: string
-
-  @IsOptional()
-  @IsIn(LOCALES)
-  locale?: (typeof LOCALES)[number]
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(64)
-  timezone?: string
-}

package/templates/api/src/users/entities/profile.entity.ts

@@ -1,27 +0,0 @@
-import { defineEntity, p } from '@mikro-orm/core'
-
-const ProfileSchema = defineEntity({
-  name: 'Profile',
-  properties: {
-    id: p.uuid().primary().defaultRaw('uuidv7()'),
-    userId: p.uuid().unique(),
-    displayName: p.text(),
-    locale: p.text().default('en'),
-    timezone: p.text().default('UTC'),
-    createdAt: p
-      .datetime()
-      .onCreate(() => new Date())
-      .defaultRaw('now()'),
-    updatedAt: p
-      .datetime()
-      .onCreate(() => new Date())
-      .onUpdate(() => new Date())
-      .defaultRaw('now()'),
-  },
-})
-
-export class Profile extends ProfileSchema.class {}
-
-ProfileSchema.setClass(Profile)
-
-export { ProfileSchema }

package/templates/api/src/users/users.controller.ts

@@ -1,23 +0,0 @@
-import { Body, Controller, Get, Patch } from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-import type { AuthUser } from '@/auth/auth.factory'
-import { CurrentUser } from '@/auth/current-user.decorator'
-import { UpdateProfileDto } from './dto/update-profile.dto'
-import type { Profile } from './entities/profile.entity'
-import { UsersService } from './users.service'
-
-@ApiTags('users')
-@Controller({ path: 'users', version: '1' })
-export class UsersController {
-  constructor(private readonly users: UsersService) {}
-
-  @Get('me')
-  findMe(@CurrentUser() user: AuthUser): Promise<Profile> {
-    return this.users.findProfile(user.id)
-  }
-
-  @Patch('me')
-  updateMe(@CurrentUser() user: AuthUser, @Body() changes: UpdateProfileDto): Promise<Profile> {
-    return this.users.updateProfile(user.id, changes)
-  }
-}

package/templates/api/src/users/users.module.ts

@@ -1,10 +0,0 @@
-import { Module } from '@nestjs/common'
-import { UsersController } from './users.controller'
-import { UsersService } from './users.service'
-
-@Module({
-  controllers: [UsersController],
-  providers: [UsersService],
-  exports: [UsersService],
-})
-export class UsersModule {}

package/templates/api/src/users/users.service.spec.ts

@@ -1,44 +0,0 @@
-import { NotFoundException } from '@nestjs/common'
-import { plainToInstance } from 'class-transformer'
-import { beforeEach, describe, expect, it } from 'vitest'
-import { createProfile } from '../../test/factories/profile.factory'
-import { testOrm } from '../../test/setup'
-import { UpdateProfileDto } from './dto/update-profile.dto'
-import { UsersService } from './users.service'
-
-describe('UsersService', () => {
-  let service: UsersService
-
-  beforeEach(() => {
-    service = new UsersService(testOrm().em.fork())
-  })
-
-  it('finds the profile belonging to a user', async () => {
-    const em = testOrm().em.fork()
-    const created = await createProfile(em, { displayName: 'Ana' })
-
-    await expect(service.findProfile(created.userId)).resolves.toMatchObject({
-      displayName: 'Ana',
-    })
-  })
-
-  it('refuses a user without a profile', async () => {
-    await expect(service.findProfile(crypto.randomUUID())).rejects.toBeInstanceOf(NotFoundException)
-  })
-
-  it('applies only the fields the request carries', async () => {
-    const em = testOrm().em.fork()
-    const created = await createProfile(em, {
-      displayName: 'Ana',
-      timezone: 'UTC',
-    })
-
-    const changes = plainToInstance(UpdateProfileDto, { timezone: 'America/Sao_Paulo' })
-    const updated = await service.updateProfile(created.userId, changes)
-
-    expect(updated).toMatchObject({
-      displayName: 'Ana',
-      timezone: 'America/Sao_Paulo',
-    })
-  })
-})

package/templates/api/src/users/users.service.ts

@@ -1,36 +0,0 @@
-import { EntityManager } from '@mikro-orm/postgresql'
-import { Injectable, NotFoundException } from '@nestjs/common'
-import type { UpdateProfileDto } from './dto/update-profile.dto'
-import { Profile } from './entities/profile.entity'
-
-@Injectable()
-export class UsersService {
-  constructor(private readonly em: EntityManager) {}
-
-  async findProfile(userId: string): Promise<Profile> {
-    const profile = await this.em.findOne(Profile, { userId })
-
-    if (profile === null) {
-      throw new NotFoundException('Profile not found')
-    }
-
-    return profile
-  }
-
-  async updateProfile(userId: string, changes: UpdateProfileDto): Promise<Profile> {
-    const profile = await this.findProfile(userId)
-
-    this.em.assign(profile, changes, { ignoreUndefined: true })
-    await this.em.flush()
-
-    return profile
-  }
-
-  async createProfile(userId: string, displayName: string): Promise<Profile> {
-    const profile = this.em.create(Profile, { userId, displayName })
-
-    await this.em.flush()
-
-    return profile
-  }
-}

package/templates/api/test/factories/profile.factory.ts

@@ -1,26 +0,0 @@
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { Profile } from '@/users/entities/profile.entity'
-import { createUser } from './user.factory'
-
-type ProfileOverrides = Partial<{
-  userId: string
-  displayName: string
-  locale: string
-  timezone: string
-}>
-
-export async function createProfile(
-  em: EntityManager,
-  overrides: ProfileOverrides = {},
-): Promise<Profile> {
-  const profile = em.create(Profile, {
-    userId: overrides.userId ?? (await createUser(em)),
-    displayName: overrides.displayName ?? 'Test Person',
-    locale: overrides.locale ?? 'en',
-    timezone: overrides.timezone ?? 'UTC',
-  })
-
-  await em.flush()
-
-  return profile
-}

package/templates/api/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src"
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "test", "**/*.spec.ts"]
-}