feat(data-modeling): add Lucid models, migrations and seeders for the EER schema

.adonisjs/client/data.d.ts

@@ -5,11 +5,6 @@
 
 /// <reference path="./manifest.d.ts" />
 import type { InferData, InferVariants } from '@adonisjs/core/types/transformers'
-import type UserTransformer from '#transformers/user_transformer'
 
 export namespace Data {
-  export type User = InferData<UserTransformer>
-  export namespace User {
-    export type Variants = InferVariants<UserTransformer>
-  }
 }

.adonisjs/server/controllers.ts

@@ -4,7 +4,5 @@
  */
 
 export const controllers = {
-  AccessTokens: () => import('#controllers/access_tokens_controller'),
-  NewAccount: () => import('#controllers/new_account_controller'),
-  Profile: () => import('#controllers/profile_controller'),
+  Health: () => import('#controllers/health_controller'),
 }

.github/workflows/ci.yml

@@ -65,5 +65,8 @@ jobs:
       - name: Lint
         run: npm run lint
 
+      - name: Run migrations
+        run: node ace migration:run --force
+
       - name: Run tests
         run: npm test

.github/workflows/pr-checks.yml

@@ -72,6 +72,12 @@ jobs:
       - name: Lint
         run: npm run lint
 
+      # Migrations must run against the fresh service container before any
+      # test touches the database, unit specs under tests/unit/database and
+      # tests/unit/models assume the schema already exists.
+      - name: Run migrations
+        run: node ace migration:run --force
+
       # Functional tests start the AdonisJS HTTP server and issue real requests.
       # Future browser / E2E suites will use @japa/browser-client with Playwright
       # in headless-chromium mode; install steps will be added when that suite

app/models/activation_token.ts

@@ -0,0 +1,30 @@
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import { DateTime } from 'luxon'
+import User from '#models/user'
+
+export default class ActivationToken extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare userId: number
+
+  @column()
+  declare token: string
+
+  // NOT NULL per the README's Auth Model table. Uses Lucid's autoCreate so
+  // every row gets a creation timestamp without the issuing service (owned
+  // by feature/auth) having to set it manually.
+  @column.dateTime({ autoCreate: true })
+  declare createdAt: DateTime
+
+  @column.dateTime()
+  declare expiresAt: DateTime | null
+
+  @column.dateTime()
+  declare validatedAt: DateTime | null
+
+  @belongsTo(() => User)
+  declare user: BelongsTo<typeof User>
+}

app/models/blacklisted_token.ts

@@ -0,0 +1,40 @@
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import { DateTime } from 'luxon'
+import User from '#models/user'
+
+/**
+ * Backs the JWT revocation list. `jti` is the JWT ID claim of the token
+ * being blacklisted and is unique so the same token cannot be blacklisted
+ * twice; feature/auth's AuthMiddleware queries this table by `jti` on
+ * every authenticated request to reject revoked tokens before the guard
+ * even looks at the signature's expiry.
+ */
+export default class BlacklistedToken extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare userId: number
+
+  @column()
+  declare token: string
+
+  @column()
+  declare jti: string
+
+  @column.dateTime()
+  declare blacklistedAt: DateTime | null
+
+  @column.dateTime({ autoCreate: true })
+  declare createdAt: DateTime
+
+  @column.dateTime()
+  declare expiresAt: DateTime | null
+
+  @column.dateTime()
+  declare validatedAt: DateTime | null
+
+  @belongsTo(() => User)
+  declare user: BelongsTo<typeof User>
+}

app/models/category.ts

@@ -0,0 +1,20 @@
+import { BaseModel, column, hasMany } from '@adonisjs/lucid/orm'
+import type { HasMany } from '@adonisjs/lucid/types/relations'
+import Product from '#models/product'
+
+// NOTE: the README's Data Model "Column Details" table for `categories`
+// lists only `id` and `category_name`, with no `created_at` / `updated_at`
+// columns, unlike the generic Lucid model example in the patterns skill.
+// This model and its migration follow the README's explicit column list
+// rather than the generic pattern, since the README is the authoritative
+// spec for this branch.
+export default class Category extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare categoryName: string
+
+  @hasMany(() => Product)
+  declare products: HasMany<typeof Product>
+}

app/models/customer.ts

@@ -0,0 +1,32 @@
+import { BaseModel, column, hasMany } from '@adonisjs/lucid/orm'
+import type { HasMany } from '@adonisjs/lucid/types/relations'
+import Order from '#models/order'
+
+export default class Customer extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare firstName: string
+
+  @column()
+  declare lastName: string
+
+  @column()
+  declare telephone: string
+
+  @column()
+  declare email: string
+
+  @column()
+  declare address: string
+
+  // NOTE: the README's Data Model diagram shows customers 1 -- N orders,
+  // and the Column Details table only defines orders.customer_id as the FK
+  // side. The inverse hasMany here is not explicitly requested by the
+  // Tasks checklist (which only lists scalar columns for Customer) but is
+  // added because the diagram documents the relation and orders.customer_id
+  // would otherwise be unreachable from the Customer side.
+  @hasMany(() => Order)
+  declare orders: HasMany<typeof Order>
+}

app/models/order.ts

@@ -0,0 +1,27 @@
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import Customer from '#models/customer'
+import Product from '#models/product'
+
+export default class Order extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare customerId: number
+
+  @column()
+  declare productId: number
+
+  @column()
+  declare quantity: number
+
+  @column()
+  declare total: number
+
+  @belongsTo(() => Customer)
+  declare customer: BelongsTo<typeof Customer>
+
+  @belongsTo(() => Product)
+  declare product: BelongsTo<typeof Product>
+}

app/models/password_reset_token.ts

@@ -0,0 +1,28 @@
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import { DateTime } from 'luxon'
+import User from '#models/user'
+
+export default class PasswordResetToken extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare userId: number
+
+  @column()
+  declare token: string
+
+  // NOTE: the README does not enumerate the values for `type`. feature/auth
+  // owns the actual reset flow and will decide the concrete values (for
+  // example 'password_reset' vs 'account_activation'); this model keeps
+  // the column as a plain string to stay unopinionated about that choice.
+  @column()
+  declare type: string
+
+  @column.dateTime()
+  declare expiryDate: DateTime
+
+  @belongsTo(() => User)
+  declare user: BelongsTo<typeof User>
+}

app/models/permission.ts

@@ -0,0 +1,22 @@
+import { BaseModel, column, manyToMany } from '@adonisjs/lucid/orm'
+import type { ManyToMany } from '@adonisjs/lucid/types/relations'
+import Role from '#models/role'
+
+export default class Permission extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare resource: string
+
+  @column()
+  declare action: string
+
+  // NOTE: the README only specifies the Role -> Permission direction
+  // (`@manyToMany(() => Permission, { pivotTable: 'role_permission' })` on
+  // Role). The inverse is declared here so a Permission can be traced back
+  // to the roles that grant it, which the `role_permission` FK pair
+  // supports without any extra schema.
+  @manyToMany(() => Role, { pivotTable: 'role_permission' })
+  declare roles: ManyToMany<typeof Role>
+}

app/models/product.ts

@@ -0,0 +1,20 @@
+import { BaseModel, belongsTo, column } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import Category from '#models/category'
+
+export default class Product extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare categoryId: number
+
+  @column()
+  declare productName: string
+
+  @column()
+  declare unitPrice: number
+
+  @belongsTo(() => Category)
+  declare category: BelongsTo<typeof Category>
+}

app/models/role.ts

@@ -0,0 +1,18 @@
+import { BaseModel, column, manyToMany } from '@adonisjs/lucid/orm'
+import type { ManyToMany } from '@adonisjs/lucid/types/relations'
+import User from '#models/user'
+import Permission from '#models/permission'
+
+export default class Role extends BaseModel {
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare roleName: string
+
+  @manyToMany(() => User, { pivotTable: 'role_user' })
+  declare users: ManyToMany<typeof User>
+
+  @manyToMany(() => Permission, { pivotTable: 'role_permission' })
+  declare permissions: ManyToMany<typeof Permission>
+}