The batteries-included TypeScript framework

import { middleware } from '#start/kernel'
import router from '@adonisjs/core/services/router'
import { controllers } from '#generated/controllers'

router
  .group(() => {
    router.get('login', [controllers.Session, 'create'])
    router.post('login', [controllers.Session, 'store'])

    router.get('signup', [controllers.NewAccount, 'create'])
    router.post('signup', [controllers.NewAccount, 'store'])
  })
  .use(middleware.guest())

// Creates a total of 7 routes to manage posts
router.resource('posts', controllers.Posts)

import Post from '#models/post'
import { HttpContext } from '@adonisjs/core/http'

export default class PostsController {
  async index({ request }: HttpContext) {
    const posts = await Post.query().preload('author').paginate(1, 20)
    return posts
  }

  async store({ request, auth, response }: HttpContext) {
    const data = request.validateUsing(createPostValidator)    
    const post = await auth.user.related('posts').create(data)

    return response.created(post)
  }
}

import vine from '@vinejs/vine'

export const createPostValidator = vine.create({
  title: vine.string().minLength(3).maxLength(255),
  content: vine.string().minLength(10),
  coverImage: vine.file({
    size: '2mb',
    extnames: ['jpg', 'png', 'webp']
  }).optional()
})

export const createUserValidator = vine.create({
  fullName: vine.string().nullable(),
  email: vine.string().email().unique({ table: 'users' }),
  password: vine.string().confirmed()
})

import User from '#models/user'
import Comment from '#models/comment'
import { PostSchema } from '#database/schema'
// ...other imports

export default class Post extends PostSchema {
  @belongsTo(() => User)
  author: BelongsTo<typeof User>

  @hasMany(() => Comment)
  comments: HasMany<typeof Comment>
}

await Post.all()
await Post.query().preload('author').where('id', 1).firstOrFail()
await Post.query().withCount('comments').paginate(1, 20)

// ...imports
export default class AuthController {
  async login({ request, auth }: HttpContext) {
    const user = await User.verifyCredentials(email, password)
    // Create session for user
    await auth.use('web').login(user)
  }

  async loginWithToken({ request }: HttpContext) {
    const user = await User.verifyCredentials(email, password)

    // Create token for user
    const token = await User.accessTokens.create(user)
    return { token: token.value!.release() }
  }
}

// ...imports
export default class AssetsController {
  async store({ request, response }: HttpContext) {
    const { file } = await request.validateUsing(createFileValidator)

    const fileName = `${uuid()}.${file.extname}`
    await file.moveToDisk(fileName, 'r2')
    
    return response.created({ fileName, url: `/assets/${fileName}` })
  }

  async show({ params, response }: HttpContext) {
    const stream = await drive.use('r2').getStream(params.fileName)
    return response.stream(stream)
  }
}

// ...imports
export default class WelcomeMail extends BaseMail {
  subject = 'Welcome to Acme!'
  constructor(protected user: User) {
    super()
  }

  prepare() {
    this.message
      .to(this.user.email)
      .htmlView('emails/welcome', { user: this.user })
  }
}

// Usage example
await mail.send(new WelcomeMail(user))

import limiter from '@adonisjs/limiter/services/main'

export const apiThrottle = limiter.define('api', ({ auth, request }) => {
  if (auth.user) {
    const key = `user_${auth.user.id}`
    return limiter.allowRequests(100).every('1 minute').usingKey(key)
  }

  const key = `ip_${request.ip()}`
  return limiter.allowRequests(10).every('1 minute').usingKey(key)
})

// Usage example
router
  .get('api/repos', () => {})
  .use(apiThrottle)

import { test } from '@japa/runner'
import { UserFactory } from '#factories/user'

test.group('Posts store', (group) => {
  test('create post as authenticated user', async ({ client }) => {
    const user = await UserFactory.create()
    
    const response = await client
      .visit('posts.store')
      .loginAs(user)
      .json({ title: 'Hello World', content: 'My first post' })
    
    response.assertStatus(201)
    response.assertBodyContains(postData)
  })
})