@stjoseph/prumo 0.0.1

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,26 @@
+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/test/factories/user.factory.ts

@@ -0,0 +1,21 @@
+import { randomUUID } from 'node:crypto'
+import type { EntityManager } from '@mikro-orm/postgresql'
+
+type UserOverrides = Partial<{ name: string; email: string }>
+
+export async function createUser(
+  em: EntityManager,
+  overrides: UserOverrides = {},
+): Promise<string> {
+  const id = randomUUID()
+
+  // auth.user belongs to Better Auth and has no entity here, so the QueryBuilder cannot reach it.
+  await em
+    .getConnection()
+    .execute(
+      'insert into auth."user" (id, name, email, "emailVerified", "createdAt", "updatedAt") values (?, ?, ?, false, now(), now())',
+      [id, overrides.name ?? 'Test Person', overrides.email ?? `${id}@example.com`],
+    )
+
+  return id
+}

package/templates/api/test/global-setup.ts

@@ -0,0 +1,20 @@
+import { PostgreSqlContainer, type StartedPostgreSqlContainer } from '@testcontainers/postgresql'
+import type { TestProject } from 'vitest/node'
+
+let container: StartedPostgreSqlContainer
+
+export async function setup(project: TestProject): Promise<void> {
+  container = await new PostgreSqlContainer('postgres:18-alpine').start()
+
+  project.provide('postgresUrl', container.getConnectionUri())
+}
+
+export async function teardown(): Promise<void> {
+  await container.stop()
+}
+
+declare module 'vitest' {
+  interface ProvidedContext {
+    postgresUrl: string
+  }
+}

package/templates/api/test/setup.ts

@@ -0,0 +1,80 @@
+import { MikroORM } from '@mikro-orm/postgresql'
+import { getMigrations } from 'better-auth/db/migration'
+import { Client, type Pool } from 'pg'
+import { afterAll, beforeAll, beforeEach, inject } from 'vitest'
+import { createAuth } from '../src/auth/auth.factory'
+import { createOrmConfig } from '../src/mikro-orm.factory'
+
+let orm: MikroORM
+let databaseUrl: string
+let tables: string[] = []
+
+export function testOrm(): MikroORM {
+  return orm
+}
+
+export function testDatabaseUrl(): string {
+  return databaseUrl
+}
+
+async function createWorkerDatabase(baseUrl: string, name: string): Promise<string> {
+  const admin = new Client({ connectionString: baseUrl })
+
+  await admin.connect()
+  await admin.query(`DROP DATABASE IF EXISTS "${name}"`)
+  await admin.query(`CREATE DATABASE "${name}"`)
+  await admin.end()
+
+  const url = new URL(baseUrl)
+  url.pathname = `/${name}`
+
+  const worker = new Client({ connectionString: url.toString() })
+
+  await worker.connect()
+  await worker.query('CREATE SCHEMA IF NOT EXISTS auth')
+  await worker.end()
+
+  return url.toString()
+}
+
+async function migrateAuth(databaseUrl: string): Promise<void> {
+  const auth = createAuth({
+    AUTH_DATABASE_URL: databaseUrl,
+    BETTER_AUTH_SECRET: 'test-secret-that-is-at-least-32-characters',
+    BETTER_AUTH_URL: 'http://localhost',
+    WEB_ORIGIN: 'http://localhost:5173',
+  })
+  const { runMigrations } = await getMigrations(auth.options)
+
+  await runMigrations()
+  await (auth.options.database as Pool).end()
+}
+
+beforeAll(async () => {
+  const name = `test_${process.env.VITEST_WORKER_ID ?? '1'}`
+  const clientUrl = await createWorkerDatabase(inject('postgresUrl'), name)
+
+  databaseUrl = clientUrl
+  await migrateAuth(clientUrl)
+
+  orm = await MikroORM.init(createOrmConfig({ DATABASE_URL: clientUrl, NODE_ENV: 'test' }))
+
+  await orm.migrator.up()
+
+  const metadata = orm.getMetadata().getAll()
+  const own = Object.values(metadata)
+    .filter((meta) => meta.tableName !== undefined && meta.pivotTable !== true)
+    .map((meta) => `"${meta.tableName}"`)
+
+  tables = [...own, 'auth."user"', 'auth.session', 'auth.account', 'auth.verification']
+})
+
+beforeEach(async () => {
+  if (tables.length > 0) {
+    await orm.em.getConnection().execute(`TRUNCATE ${tables.join(', ')} RESTART IDENTITY CASCADE`)
+  }
+})
+
+afterAll(async () => {
+  await orm.close()
+})

package/templates/api/tsconfig.build.json

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

package/templates/api/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "removeComments": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "noUncheckedIndexedAccess": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["src", "test", "vitest.config.mts"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/api/vitest.config.mts

@@ -0,0 +1,17 @@
+import swc from 'unplugin-swc'
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  plugins: [swc.vite({ module: { type: 'es6' } })],
+  resolve: {
+    alias: { '@': `${import.meta.dirname}/src` },
+  },
+  test: {
+    globals: true,
+    include: ['src/**/*.spec.ts'],
+    globalSetup: ['./test/global-setup.ts'],
+    setupFiles: ['./test/setup.ts'],
+    pool: 'forks',
+    coverage: { provider: 'v8', include: ['src/**'] },
+  },
+})

package/templates/mobile/.env.example

@@ -0,0 +1 @@
+EXPO_PUBLIC_API_URL=http://localhost:3000

package/templates/mobile/.githooks/install.mjs

@@ -0,0 +1,18 @@
+import { execFileSync } from 'node:child_process'
+
+function insideRepository() {
+  try {
+    execFileSync('git', ['rev-parse', '--git-dir'], { stdio: 'ignore' })
+    return true
+  } catch (error) {
+    // No git, or no repository: an install from an archive or inside a container, where hooks have no use.
+    if (error.code === 'ENOENT' || error.status === 128) {
+      return false
+    }
+    throw error
+  }
+}
+
+if (insideRepository()) {
+  execFileSync('git', ['config', 'core.hooksPath', '.githooks'], { stdio: 'inherit' })
+}

package/templates/mobile/.githooks/pre-commit

@@ -0,0 +1,2 @@
+#!/bin/sh
+pnpm biome check --staged --write

package/templates/mobile/.githooks/pre-push

@@ -0,0 +1,2 @@
+#!/bin/sh
+pnpm typecheck

package/templates/mobile/README.md

@@ -0,0 +1,30 @@
+# mobile
+
+## Requirements
+
+Node 22.17 or later, pnpm, and the API running with `MOBILE_APP_SCHEME=app`. A simulator or a device with Expo Go
+to open the app.
+
+## Running it
+
+```sh
+pnpm install
+cp .env.example .env        # EXPO_PUBLIC_API_URL points at the API
+pnpm start
+```
+
+On an Android emulator `localhost` is the emulator itself; point `EXPO_PUBLIC_API_URL` at your machine's address.
+
+## Everyday commands
+
+| Command | What it does |
+|---|---|
+| `pnpm test` | Jest with `jest-expo`, rendering components against a fake transport; no API needed |
+| `pnpm lint` | Biome |
+| `pnpm typecheck` | `tsc --noEmit`, also run before every push |
+| `pnpm bundle` | Produces the iOS and Android bundles. It reads `EXPO_PUBLIC_API_URL` from the environment, not from `.env`, and fails without it |
+
+## Conventions
+
+The rules this project follows live in `.prumo/`, and `AGENTS.md` points to them. Read those before
+changing how something is done.

package/templates/mobile/app.config.ts

@@ -0,0 +1,13 @@
+import type { ConfigContext, ExpoConfig } from 'expo/config'
+
+const REQUIRED = ['EXPO_PUBLIC_API_URL'] as const
+
+export default ({ config }: ConfigContext): ExpoConfig => {
+  const missing = REQUIRED.filter((name) => !process.env[name])
+
+  if (missing.length > 0) {
+    throw new Error(`Missing environment variables: ${missing.join(', ')}`)
+  }
+
+  return config as ExpoConfig
+}

package/templates/mobile/app.json

@@ -0,0 +1,39 @@
+{
+  "expo": {
+    "name": "mobile",
+    "slug": "mobile",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/images/icon.png",
+    "scheme": "app",
+    "userInterfaceStyle": "automatic",
+    "ios": {
+      "icon": "./assets/expo.icon"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "backgroundColor": "#E6F4FE",
+        "foregroundImage": "./assets/images/android-icon-foreground.png",
+        "backgroundImage": "./assets/images/android-icon-background.png",
+        "monochromeImage": "./assets/images/android-icon-monochrome.png"
+      },
+      "predictiveBackGestureEnabled": false
+    },
+    "platforms": ["ios", "android"],
+    "plugins": [
+      "expo-router",
+      "expo-secure-store",
+      [
+        "expo-splash-screen",
+        {
+          "backgroundColor": "#208AEF",
+          "image": "./assets/images/splash-icon.png",
+          "imageWidth": 76
+        }
+      ]
+    ],
+    "experiments": {
+      "typedRoutes": true
+    }
+  }
+}

package/templates/mobile/assets/expo.icon/Assets/expo-symbol 2.svg

@@ -0,0 +1,3 @@
+<svg width="652" height="606" viewBox="0 0 652 606" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M353.554 0H298.446C273.006 0 249.684 14.6347 237.962 37.9539L4.37994 502.646C-1.04325 513.435 -1.45067 526.178 3.2716 537.313L22.6123 582.918C34.6475 611.297 72.5404 614.156 88.4414 587.885L309.863 222.063C313.34 216.317 319.439 212.826 326 212.826C332.561 212.826 338.659 216.317 342.137 222.063L563.559 587.885C579.46 614.156 617.352 611.297 629.388 582.918L648.728 537.313C653.451 526.178 653.043 513.435 647.62 502.646L414.038 37.9539C402.316 14.6347 378.994 0 353.554 0Z" fill="white"/>
+</svg>

package/templates/mobile/assets/expo.icon/icon.json

@@ -0,0 +1,35 @@
+{
+  "fill": {
+    "automatic-gradient": "extended-srgb:0.00000,0.47843,1.00000,1.00000"
+  },
+  "groups": [
+    {
+      "layers": [
+        {
+          "image-name": "expo-symbol 2.svg",
+          "name": "expo-symbol 2",
+          "position": {
+            "scale": 1,
+            "translation-in-points": [1.1008400065293245e-5, -16.046875]
+          }
+        },
+        {
+          "image-name": "grid.png",
+          "name": "grid"
+        }
+      ],
+      "shadow": {
+        "kind": "neutral",
+        "opacity": 0.5
+      },
+      "translucency": {
+        "enabled": true,
+        "value": 0.5
+      }
+    }
+  ],
+  "supported-platforms": {
+    "circles": ["watchOS"],
+    "squares": "shared"
+  }
+}

package/templates/mobile/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = (api) => {
+  api.cache(true)
+  return {
+    presets: [['babel-preset-expo', { jsxImportSource: 'nativewind' }], 'nativewind/babel'],
+  }
+}

package/templates/mobile/biome.jsonc

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.5.13/schema.json",
+  "vcs": { "enabled": true, "clientKind": "git", "useIgnoreFile": true },
+  "files": { "includes": ["**", "!dist", "!coverage", "!.expo", "!assets"] },
+  "formatter": { "indentStyle": "space", "indentWidth": 2, "lineWidth": 100 },
+  "linter": { "rules": { "preset": "recommended" } },
+  "javascript": { "formatter": { "quoteStyle": "single", "semicolons": "asNeeded" } },
+  "overrides": [
+    {
+      "includes": ["src/global.css"],
+      "linter": {
+        "rules": {
+          "suspicious": {
+            // NativeWind 4 needs Tailwind 3's @tailwind directives; Biome only knows Tailwind 4's syntax.
+            "noUnknownAtRules": "off"
+          }
+        }
+      }
+    }
+  ]
+}

package/templates/mobile/gitignore

@@ -0,0 +1,11 @@
+node_modules
+.expo
+dist
+coverage
+expo-env.d.ts
+*.tsbuildinfo
+.env
+.env*.local
+/ios
+/android
+.metro-health-check*

package/templates/mobile/global.d.ts

@@ -0,0 +1 @@
+declare module '*.css'