Database

# backend/.env

DB_HOST=localhost
DB_PORT=5432
DB_USER=root
DB_PASSWORD=root
DB_DATABASE=app

import { BaseModel, column, hasMany } from '@adonisjs/lucid/orm'
import { DateTime } from 'luxon'

export default class Team extends BaseModel {
  @column({ isPrimary: true })
  declare id: number

  @column()
  declare name: string

  @column.dateTime({ autoCreate: true })
  declare createdAt: DateTime

  @column.dateTime({ autoCreate: true, autoUpdate: true })
  declare updatedAt: DateTime
}

@column({ serializeAs: null })
declare avatar: string | null

@computed()
get avatarUrl() {
  if (!this.avatar) return null
  return `${env.get('APP_URL')}/uploads/${this.avatar}`
}

@column({ serializeAs: null })
declare password: string | null

@column({ serializeAs: null })
declare isDeleted: boolean

# Run all pending migrations
node ace migration:run

# Rollback last batch
node ace migration:rollback

# Fresh database (rollback all + migrate)
node ace migration:fresh

# Check migration status
node ace migration:status

node ace make:migration create_posts_table

import { BaseSchema } from '@adonisjs/lucid/schema'

export default class extends BaseSchema {
  protected tableName = 'posts'

  async up() {
    this.schema.createTable(this.tableName, (table) => {
      table.increments('id')
      table.string('title').notNullable()
      table.text('content')
      table.integer('user_id').unsigned().references('users.id')
      table.timestamp('created_at')
      table.timestamp('updated_at')
    })
  }

  async down() {
    this.schema.dropTable(this.tableName)
  }
}

# Run all seeders
node ace db:seed

# Run specific seeder
node ace db:seed --files=database/seeders/plan_seeder.ts

import { BaseSeeder } from '@adonisjs/lucid/seeders'
import Plan, { PlanMode } from '#models/plan'

export default class extends BaseSeeder {
  async run() {
    await Plan.createMany([
      {
        name: 'Pro',
        key: 'pro',
        stripePriceId: 'price_xxx', // From Stripe
        mode: PlanMode.SUBSCRIPTION,
        isActive: true,
      },
      {
        name: 'Ultimate',
        key: 'ultimate',
        stripePriceId: 'price_xxx', // From Stripe
        mode: PlanMode.SUBSCRIPTION,
        isActive: true,
      },
    ])
  }
}

node ace make:seeder Post

// Single record
const user = await User.create({
  email: 'user@example.com',
  firstName: 'John',
})

// Multiple records
const teams = await Team.createMany([
  { name: 'Team A' },
  { name: 'Team B' },
])

// Find by ID
const user = await User.find(1)
const user = await User.findOrFail(1) // Throws if not found

// Find by column
const user = await User.findBy('email', 'user@example.com')

// Query builder
const users = await User.query()
  .where('isDeleted', false)
  .orderBy('createdAt', 'desc')
  .limit(10)

// Find and update
const user = await User.findOrFail(1)
user.firstName = 'Jane'
await user.save()

// Or use merge
await user.merge({ firstName: 'Jane' }).save()

const user = await User.findOrFail(1)
await user.delete()

// Load relationship
const user = await User.query()
  .where('id', 1)
  .preload('teams')
  .firstOrFail()

// Access related records
user.teams.forEach(team => console.log(team.name))

// Create related record
await user.related('subscriptions').create({
  planId: 1,
  status: 'active',
})

// Attach many-to-many
await user.related('teams').attach({
  [teamId]: { role: 'member' }
})

// Detach many-to-many
await user.related('teams').detach([teamId])

import db from '@adonisjs/lucid/services/db'

const team = await db.transaction(async (trx) => {
  const newTeam = await Team.create({ name: 'New Team' }, { client: trx })
  
  await user.related('teams').attach({
    [newTeam.id]: { role: 'owner' }
  }, trx)
  
  return newTeam
})

┌─────────────────┐     ┌─────────────────┐
│     users       │     │     teams       │
├─────────────────┤     ├─────────────────┤
│ id              │     │ id              │
│ first_name      │     │ name            │
│ last_name       │     │ avatar          │
│ email           │     │ created_at      │
│ password        │     │ updated_at      │
│ avatar          │     └────────┬────────┘
│ stripe_customer │              │
│ is_deleted      │              │
│ email_verified  │     ┌────────┴────────┐
│ created_at      │     │  team_members   │
│ updated_at      │     ├─────────────────┤
└────────┬────────┘     │ user_id (FK)    │
         │              │ team_id (FK)    │
         └──────────────│ role            │
                        │ default         │
                        └─────────────────┘

┌─────────────────┐     ┌─────────────────┐
│  invitations    │     │     plans       │
├─────────────────┤     ├─────────────────┤
│ id              │     │ id              │
│ team_id (FK)    │     │ name            │
│ email           │     │ key             │
│ role            │     │ stripe_price_id │
│ token           │     │ price           │
│ expires_at      │     │ mode            │
│ created_at      │     │ is_active       │
└─────────────────┘     └─────────────────┘

┌─────────────────┐
│  subscriptions  │
├─────────────────┤
│ id              │
│ user_id (FK)    │
│ stripe_id       │
│ stripe_status   │
│ stripe_price_id │
│ ends_at         │
└─────────────────┘