Move models to typescript-sequelize

9 files changed, 728 insertions, 1104 deletions

diff --git a/server/models/account/account-follow-interface.ts b/server/models/account/account-follow-interface.ts
deleted file mode 100644
index 7975a46f3..000000000
--- a/server/models/account/account-follow-interface.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import * as Bluebird from 'bluebird'
-import * as Sequelize from 'sequelize'
-import { AccountFollow, FollowState } from '../../../shared/models/accounts/follow.model'
-import { ResultList } from '../../../shared/models/result-list.model'
-import { AccountInstance } from './account-interface'
-
-export namespace AccountFollowMethods {
-  export type LoadByAccountAndTarget = (
-    accountId: number,
-    targetAccountId: number,
-    t?: Sequelize.Transaction
-  ) => Bluebird<AccountFollowInstance>
-
-  export type ListFollowingForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountFollowInstance>>
-  export type ListFollowersForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountFollowInstance>>
-
-  export type ListAcceptedFollowerUrlsForApi = (
-    accountId: number[],
-    t: Sequelize.Transaction,
-    start?: number,
-    count?: number
-  ) => Promise< ResultList<string> >
-  export type ListAcceptedFollowingUrlsForApi = (
-    accountId: number[],
-    t: Sequelize.Transaction,
-    start?: number,
-    count?: number
-  ) => Promise< ResultList<string> >
-  export type ListAcceptedFollowerSharedInboxUrls = (accountId: number[], t: Sequelize.Transaction) => Promise< ResultList<string> >
-  export type ToFormattedJSON = (this: AccountFollowInstance) => AccountFollow
-}
-
-export interface AccountFollowClass {
-  loadByAccountAndTarget: AccountFollowMethods.LoadByAccountAndTarget
-  listFollowersForApi: AccountFollowMethods.ListFollowersForApi
-  listFollowingForApi: AccountFollowMethods.ListFollowingForApi
-
-  listAcceptedFollowerUrlsForApi: AccountFollowMethods.ListAcceptedFollowerUrlsForApi
-  listAcceptedFollowingUrlsForApi: AccountFollowMethods.ListAcceptedFollowingUrlsForApi
-  listAcceptedFollowerSharedInboxUrls: AccountFollowMethods.ListAcceptedFollowerSharedInboxUrls
-}
-
-export interface AccountFollowAttributes {
-  accountId: number
-  targetAccountId: number
-  state: FollowState
-}
-
-export interface AccountFollowInstance extends AccountFollowClass, AccountFollowAttributes, Sequelize.Instance<AccountFollowAttributes> {
-  id: number
-  createdAt: Date
-  updatedAt: Date
-
-  AccountFollower?: AccountInstance
-  AccountFollowing?: AccountInstance
-
-  toFormattedJSON: AccountFollowMethods.ToFormattedJSON
-}
-
-export interface AccountFollowModel extends AccountFollowClass, Sequelize.Model<AccountFollowInstance, AccountFollowAttributes> {}
diff --git a/server/models/account/account-follow.ts b/server/models/account/account-follow.ts
index 724f37baa..975e7ee7d 100644
--- a/server/models/account/account-follow.ts
+++ b/server/models/account/account-follow.ts
@@ -1,64 +1,45 @@
+import * as Bluebird from 'bluebird'
 import { values } from 'lodash'
 import * as Sequelize from 'sequelize'
-
-import { addMethodsToModel, getSort } from '../utils'
-import { AccountFollowAttributes, AccountFollowInstance, AccountFollowMethods } from './account-follow-interface'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { FollowState } from '../../../shared/models/accounts'
 import { FOLLOW_STATES } from '../../initializers/constants'
+import { ServerModel } from '../server/server'
+import { getSort } from '../utils'
+import { AccountModel } from './account'
 
-let AccountFollow: Sequelize.Model<AccountFollowInstance, AccountFollowAttributes>
-let loadByAccountAndTarget: AccountFollowMethods.LoadByAccountAndTarget
-let listFollowingForApi: AccountFollowMethods.ListFollowingForApi
-let listFollowersForApi: AccountFollowMethods.ListFollowersForApi
-let listAcceptedFollowerUrlsForApi: AccountFollowMethods.ListAcceptedFollowerUrlsForApi
-let listAcceptedFollowingUrlsForApi: AccountFollowMethods.ListAcceptedFollowingUrlsForApi
-let listAcceptedFollowerSharedInboxUrls: AccountFollowMethods.ListAcceptedFollowerSharedInboxUrls
-let toFormattedJSON: AccountFollowMethods.ToFormattedJSON
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  AccountFollow = sequelize.define<AccountFollowInstance, AccountFollowAttributes>('AccountFollow',
+@Table({
+  tableName: 'accountFollow',
+  indexes: [
     {
-      state: {
-        type: DataTypes.ENUM(values(FOLLOW_STATES)),
-        allowNull: false
-      }
+      fields: [ 'accountId' ]
     },
     {
-      indexes: [
-        {
-          fields: [ 'accountId' ]
-        },
-        {
-          fields: [ 'targetAccountId' ]
-        },
-        {
-          fields: [ 'accountId', 'targetAccountId' ],
-          unique: true
-        }
-      ]
+      fields: [ 'targetAccountId' ]
+    },
+    {
+      fields: [ 'accountId', 'targetAccountId' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate,
-    loadByAccountAndTarget,
-    listFollowingForApi,
-    listFollowersForApi,
-    listAcceptedFollowerUrlsForApi,
-    listAcceptedFollowingUrlsForApi,
-    listAcceptedFollowerSharedInboxUrls
   ]
-  const instanceMethods = [
-    toFormattedJSON
-  ]
-  addMethodsToModel(AccountFollow, classMethods, instanceMethods)
+})
+export class AccountFollowModel extends Model<AccountFollowModel> {
 
-  return AccountFollow
-}
+  @AllowNull(false)
+  @Column(DataType.ENUM(values(FOLLOW_STATES)))
+  state: FollowState
 
-// ------------------------------ STATICS ------------------------------
+  @CreatedAt
+  createdAt: Date
 
-function associate (models) {
-  AccountFollow.belongsTo(models.Account, {
+  @UpdatedAt
+  updatedAt: Date
+
+  @ForeignKey(() => AccountModel)
+  @Column
+  accountId: number
+
+  @BelongsTo(() => AccountModel, {
     foreignKey: {
       name: 'accountId',
       allowNull: false
@@ -66,8 +47,13 @@ function associate (models) {
     as: 'AccountFollower',
     onDelete: 'CASCADE'
   })
+  AccountFollower: AccountModel
 
-  AccountFollow.belongsTo(models.Account, {
+  @ForeignKey(() => AccountModel)
+  @Column
+  targetAccountId: number
+
+  @BelongsTo(() => AccountModel, {
     foreignKey: {
       name: 'targetAccountId',
       allowNull: false
@@ -75,170 +61,168 @@ function associate (models) {
     as: 'AccountFollowing',
     onDelete: 'CASCADE'
   })
-}
+  AccountFollowing: AccountModel
 
-toFormattedJSON = function (this: AccountFollowInstance) {
-  const follower = this.AccountFollower.toFormattedJSON()
-  const following = this.AccountFollowing.toFormattedJSON()
-
-  const json = {
-    id: this.id,
-    follower,
-    following,
-    state: this.state,
-    createdAt: this.createdAt,
-    updatedAt: this.updatedAt
-  }
-
-  return json
-}
-
-loadByAccountAndTarget = function (accountId: number, targetAccountId: number, t?: Sequelize.Transaction) {
-  const query = {
-    where: {
-      accountId,
-      targetAccountId
-    },
-    include: [
-      {
-        model: AccountFollow[ 'sequelize' ].models.Account,
-        required: true,
-        as: 'AccountFollower'
+  static loadByAccountAndTarget (accountId: number, targetAccountId: number, t?: Sequelize.Transaction) {
+    const query = {
+      where: {
+        accountId,
+        targetAccountId
       },
-      {
-        model: AccountFollow['sequelize'].models.Account,
-        required: true,
-        as: 'AccountFollowing'
-      }
-    ],
-    transaction: t
+      include: [
+        {
+          model: AccountModel,
+          required: true,
+          as: 'AccountFollower'
+        },
+        {
+          model: AccountModel,
+          required: true,
+          as: 'AccountFollowing'
+        }
+      ],
+      transaction: t
+    }
+
+    return AccountFollowModel.findOne(query)
   }
 
-  return AccountFollow.findOne(query)
-}
+  static listFollowingForApi (id: number, start: number, count: number, sort: string) {
+    const query = {
+      distinct: true,
+      offset: start,
+      limit: count,
+      order: [ getSort(sort) ],
+      include: [
+        {
+          model: AccountModel,
+          required: true,
+          as: 'AccountFollower',
+          where: {
+            id
+          }
+        },
+        {
+          model: AccountModel,
+          as: 'AccountFollowing',
+          required: true,
+          include: [ ServerModel ]
+        }
+      ]
+    }
 
-listFollowingForApi = function (id: number, start: number, count: number, sort: string) {
-  const query = {
-    distinct: true,
-    offset: start,
-    limit: count,
-    order: [ getSort(sort) ],
-    include: [
-      {
-        model: AccountFollow[ 'sequelize' ].models.Account,
-        required: true,
-        as: 'AccountFollower',
-        where: {
-          id
+    return AccountFollowModel.findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return {
+          data: rows,
+          total: count
         }
-      },
-      {
-        model: AccountFollow['sequelize'].models.Account,
-        as: 'AccountFollowing',
-        required: true,
-        include: [ AccountFollow['sequelize'].models.Server ]
-      }
-    ]
+      })
   }
 
-  return AccountFollow.findAndCountAll(query).then(({ rows, count }) => {
-    return {
-      data: rows,
-      total: count
+  static listFollowersForApi (id: number, start: number, count: number, sort: string) {
+    const query = {
+      distinct: true,
+      offset: start,
+      limit: count,
+      order: [ getSort(sort) ],
+      include: [
+        {
+          model: AccountModel,
+          required: true,
+          as: 'AccountFollower',
+          include: [ ServerModel ]
+        },
+        {
+          model: AccountModel,
+          as: 'AccountFollowing',
+          required: true,
+          where: {
+            id
+          }
+        }
+      ]
     }
-  })
-}
 
-listFollowersForApi = function (id: number, start: number, count: number, sort: string) {
-  const query = {
-    distinct: true,
-    offset: start,
-    limit: count,
-    order: [ getSort(sort) ],
-    include: [
-      {
-        model: AccountFollow[ 'sequelize' ].models.Account,
-        required: true,
-        as: 'AccountFollower',
-        include: [ AccountFollow['sequelize'].models.Server ]
-      },
-      {
-        model: AccountFollow['sequelize'].models.Account,
-        as: 'AccountFollowing',
-        required: true,
-        where: {
-          id
+    return AccountFollowModel.findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return {
+          data: rows,
+          total: count
         }
-      }
-    ]
+      })
   }
 
-  return AccountFollow.findAndCountAll(query).then(({ rows, count }) => {
-    return {
-      data: rows,
-      total: count
-    }
-  })
-}
+  static listAcceptedFollowerUrlsForApi (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+    return AccountFollowModel.createListAcceptedFollowForApiQuery('followers', accountIds, t, start, count)
+  }
 
-listAcceptedFollowerUrlsForApi = function (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
-  return createListAcceptedFollowForApiQuery('followers', accountIds, t, start, count)
-}
+  static listAcceptedFollowerSharedInboxUrls (accountIds: number[], t: Sequelize.Transaction) {
+    return AccountFollowModel.createListAcceptedFollowForApiQuery('followers', accountIds, t, undefined, undefined, 'sharedInboxUrl')
+  }
 
-listAcceptedFollowerSharedInboxUrls = function (accountIds: number[], t: Sequelize.Transaction) {
-  return createListAcceptedFollowForApiQuery('followers', accountIds, t, undefined, undefined, 'sharedInboxUrl')
-}
+  static listAcceptedFollowingUrlsForApi (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+    return AccountFollowModel.createListAcceptedFollowForApiQuery('following', accountIds, t, start, count)
+  }
 
-listAcceptedFollowingUrlsForApi = function (accountIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
-  return createListAcceptedFollowForApiQuery('following', accountIds, t, start, count)
-}
+  private static async createListAcceptedFollowForApiQuery (type: 'followers' | 'following',
+                                       accountIds: number[],
+                                       t: Sequelize.Transaction,
+                                       start?: number,
+                                       count?: number,
+                                       columnUrl = 'url') {
+    let firstJoin: string
+    let secondJoin: string
+
+    if (type === 'followers') {
+      firstJoin = 'targetAccountId'
+      secondJoin = 'accountId'
+    } else {
+      firstJoin = 'accountId'
+      secondJoin = 'targetAccountId'
+    }
 
-// ------------------------------ UTILS ------------------------------
-
-async function createListAcceptedFollowForApiQuery (
-  type: 'followers' | 'following',
-  accountIds: number[],
-  t: Sequelize.Transaction,
-  start?: number,
-  count?: number,
-  columnUrl = 'url'
-) {
-  let firstJoin: string
-  let secondJoin: string
-
-  if (type === 'followers') {
-    firstJoin = 'targetAccountId'
-    secondJoin = 'accountId'
-  } else {
-    firstJoin = 'accountId'
-    secondJoin = 'targetAccountId'
-  }
+    const selections = [ '"Follows"."' + columnUrl + '" AS "url"', 'COUNT(*) AS "total"' ]
+    const tasks: Bluebird<any>[] = []
 
-  const selections = [ '"Follows"."' + columnUrl + '" AS "url"', 'COUNT(*) AS "total"' ]
-  const tasks: Promise<any>[] = []
+    for (const selection of selections) {
+      let query = 'SELECT ' + selection + ' FROM "account" ' +
+        'INNER JOIN "accountFollow" ON "accountFollow"."' + firstJoin + '" = "account"."id" ' +
+        'INNER JOIN "account" AS "Follows" ON "accountFollow"."' + secondJoin + '" = "Follows"."id" ' +
+        'WHERE "account"."id" = ANY ($accountIds) AND "accountFollow"."state" = \'accepted\' '
 
-  for (const selection of selections) {
-    let query = 'SELECT ' + selection + ' FROM "Accounts" ' +
-      'INNER JOIN "AccountFollows" ON "AccountFollows"."' + firstJoin + '" = "Accounts"."id" ' +
-      'INNER JOIN "Accounts" AS "Follows" ON "AccountFollows"."' + secondJoin + '" = "Follows"."id" ' +
-      'WHERE "Accounts"."id" = ANY ($accountIds) AND "AccountFollows"."state" = \'accepted\' '
+      if (count !== undefined) query += 'LIMIT ' + count
+      if (start !== undefined) query += ' OFFSET ' + start
 
-    if (count !== undefined) query += 'LIMIT ' + count
-    if (start !== undefined) query += ' OFFSET ' + start
+      const options = {
+        bind: { accountIds },
+        type: Sequelize.QueryTypes.SELECT,
+        transaction: t
+      }
+      tasks.push(AccountFollowModel.sequelize.query(query, options))
+    }
 
-    const options = {
-      bind: { accountIds },
-      type: Sequelize.QueryTypes.SELECT,
-      transaction: t
+    const [ followers, [ { total } ] ] = await
+    Promise.all(tasks)
+    const urls: string[] = followers.map(f => f.url)
+
+    return {
+      data: urls,
+      total: parseInt(total, 10)
     }
-    tasks.push(AccountFollow['sequelize'].query(query, options))
   }
 
-  const [ followers, [ { total } ]] = await Promise.all(tasks)
-  const urls: string[] = followers.map(f => f.url)
+  toFormattedJSON () {
+    const follower = this.AccountFollower.toFormattedJSON()
+    const following = this.AccountFollowing.toFormattedJSON()
 
-  return {
-    data: urls,
-    total: parseInt(total, 10)
+    return {
+      id: this.id,
+      follower,
+      following,
+      state: this.state,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt
+    }
   }
 }
diff --git a/server/models/account/account-interface.ts b/server/models/account/account-interface.ts
deleted file mode 100644
index 46fe068e3..000000000
--- a/server/models/account/account-interface.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import * as Bluebird from 'bluebird'
-import * as Sequelize from 'sequelize'
-import { Account as FormattedAccount, ActivityPubActor } from '../../../shared'
-import { AvatarInstance } from '../avatar'
-import { ServerInstance } from '../server/server-interface'
-import { VideoChannelInstance } from '../video/video-channel-interface'
-
-export namespace AccountMethods {
-  export type LoadApplication = () => Bluebird<AccountInstance>
-
-  export type Load = (id: number) => Bluebird<AccountInstance>
-  export type LoadByUUID = (uuid: string) => Bluebird<AccountInstance>
-  export type LoadByUrl = (url: string, transaction?: Sequelize.Transaction) => Bluebird<AccountInstance>
-  export type LoadLocalByName = (name: string) => Bluebird<AccountInstance>
-  export type LoadByNameAndHost = (name: string, host: string) => Bluebird<AccountInstance>
-  export type ListByFollowersUrls = (followerUrls: string[], transaction: Sequelize.Transaction) => Bluebird<AccountInstance[]>
-
-  export type ToActivityPubObject = (this: AccountInstance) => ActivityPubActor
-  export type ToFormattedJSON = (this: AccountInstance) => FormattedAccount
-  export type IsOwned = (this: AccountInstance) => boolean
-  export type GetFollowerSharedInboxUrls = (this: AccountInstance, t: Sequelize.Transaction) => Bluebird<string[]>
-  export type GetFollowingUrl = (this: AccountInstance) => string
-  export type GetFollowersUrl = (this: AccountInstance) => string
-  export type GetPublicKeyUrl = (this: AccountInstance) => string
-}
-
-export interface AccountClass {
-  loadApplication: AccountMethods.LoadApplication
-  load: AccountMethods.Load
-  loadByUUID: AccountMethods.LoadByUUID
-  loadByUrl: AccountMethods.LoadByUrl
-  loadLocalByName: AccountMethods.LoadLocalByName
-  loadByNameAndHost: AccountMethods.LoadByNameAndHost
-  listByFollowersUrls: AccountMethods.ListByFollowersUrls
-}
-
-export interface AccountAttributes {
-  name: string
-  url?: string
-  publicKey: string
-  privateKey: string
-  followersCount: number
-  followingCount: number
-  inboxUrl: string
-  outboxUrl: string
-  sharedInboxUrl: string
-  followersUrl: string
-  followingUrl: string
-
-  uuid?: string
-
-  serverId?: number
-  userId?: number
-  applicationId?: number
-  avatarId?: number
-}
-
-export interface AccountInstance extends AccountClass, AccountAttributes, Sequelize.Instance<AccountAttributes> {
-  isOwned: AccountMethods.IsOwned
-  toActivityPubObject: AccountMethods.ToActivityPubObject
-  toFormattedJSON: AccountMethods.ToFormattedJSON
-  getFollowerSharedInboxUrls: AccountMethods.GetFollowerSharedInboxUrls
-  getFollowingUrl: AccountMethods.GetFollowingUrl
-  getFollowersUrl: AccountMethods.GetFollowersUrl
-  getPublicKeyUrl: AccountMethods.GetPublicKeyUrl
-
-  id: number
-  createdAt: Date
-  updatedAt: Date
-
-  Server: ServerInstance
-  VideoChannels: VideoChannelInstance[]
-  Avatar: AvatarInstance
-}
-
-export interface AccountModel extends AccountClass, Sequelize.Model<AccountInstance, AccountAttributes> {}
diff --git a/server/models/account/account-video-rate-interface.ts b/server/models/account/account-video-rate-interface.ts
deleted file mode 100644
index 1f395bc45..000000000
--- a/server/models/account/account-video-rate-interface.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import * as Sequelize from 'sequelize'
-import * as Promise from 'bluebird'
-
-import { VideoRateType } from '../../../shared/models/videos/video-rate.type'
-import { AccountInstance } from './account-interface'
-
-export namespace AccountVideoRateMethods {
-  export type Load = (accountId: number, videoId: number, transaction: Sequelize.Transaction) => Promise<AccountVideoRateInstance>
-}
-
-export interface AccountVideoRateClass {
-  load: AccountVideoRateMethods.Load
-}
-
-export interface AccountVideoRateAttributes {
-  type: VideoRateType
-  accountId: number
-  videoId: number
-
-  Account?: AccountInstance
-}
-
-export interface AccountVideoRateInstance
-  extends AccountVideoRateClass, AccountVideoRateAttributes, Sequelize.Instance<AccountVideoRateAttributes> {
-  id: number
-  createdAt: Date
-  updatedAt: Date
-}
-
-export interface AccountVideoRateModel
-  extends AccountVideoRateClass, Sequelize.Model<AccountVideoRateInstance, AccountVideoRateAttributes> {}
diff --git a/server/models/account/account-video-rate.ts b/server/models/account/account-video-rate.ts
index d92834bbb..e969e4a43 100644
--- a/server/models/account/account-video-rate.ts
+++ b/server/models/account/account-video-rate.ts
@@ -1,78 +1,69 @@
-/*
-  Account rates per video.
-*/
 import { values } from 'lodash'
-import * as Sequelize from 'sequelize'
-
+import { Transaction } from 'sequelize'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { IFindOptions } from 'sequelize-typescript/lib/interfaces/IFindOptions'
+import { VideoRateType } from '../../../shared/models/videos'
 import { VIDEO_RATE_TYPES } from '../../initializers'
+import { VideoModel } from '../video/video'
+import { AccountModel } from './account'
 
-import { addMethodsToModel } from '../utils'
-import {
-  AccountVideoRateInstance,
-  AccountVideoRateAttributes,
-
-  AccountVideoRateMethods
-} from './account-video-rate-interface'
-
-let AccountVideoRate: Sequelize.Model<AccountVideoRateInstance, AccountVideoRateAttributes>
-let load: AccountVideoRateMethods.Load
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  AccountVideoRate = sequelize.define<AccountVideoRateInstance, AccountVideoRateAttributes>('AccountVideoRate',
-    {
-      type: {
-        type: DataTypes.ENUM(values(VIDEO_RATE_TYPES)),
-        allowNull: false
-      }
-    },
+/*
+  Account rates per video.
+*/
+@Table({
+  tableName: 'accountVideoRate',
+  indexes: [
     {
-      indexes: [
-        {
-          fields: [ 'videoId', 'accountId' ],
-          unique: true
-        }
-      ]
+      fields: [ 'videoId', 'accountId' ],
+      unique: true
     }
-  )
+  ]
+})
+export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
 
-  const classMethods = [
-    associate,
+  @AllowNull(false)
+  @Column(DataType.ENUM(values(VIDEO_RATE_TYPES)))
+  type: VideoRateType
 
-    load
-  ]
-  addMethodsToModel(AccountVideoRate, classMethods)
+  @CreatedAt
+  createdAt: Date
 
-  return AccountVideoRate
-}
+  @UpdatedAt
+  updatedAt: Date
 
-// ------------------------------ STATICS ------------------------------
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
 
-function associate (models) {
-  AccountVideoRate.belongsTo(models.Video, {
+  @BelongsTo(() => VideoModel, {
     foreignKey: {
-      name: 'videoId',
       allowNull: false
     },
     onDelete: 'CASCADE'
   })
+  Video: VideoModel
 
-  AccountVideoRate.belongsTo(models.Account, {
+  @ForeignKey(() => AccountModel)
+  @Column
+  accountId: number
+
+  @BelongsTo(() => AccountModel, {
     foreignKey: {
-      name: 'accountId',
       allowNull: false
     },
     onDelete: 'CASCADE'
   })
-}
+  Account: AccountModel
 
-load = function (accountId: number, videoId: number, transaction: Sequelize.Transaction) {
-  const options: Sequelize.FindOptions<AccountVideoRateAttributes> = {
-    where: {
-      accountId,
-      videoId
+  static load (accountId: number, videoId: number, transaction: Transaction) {
+    const options: IFindOptions<AccountVideoRateModel> = {
+      where: {
+        accountId,
+        videoId
+      }
     }
-  }
-  if (transaction) options.transaction = transaction
+    if (transaction) options.transaction = transaction
 
-  return AccountVideoRate.findOne(options)
+    return AccountVideoRateModel.findOne(options)
+  }
 }
diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index 8b0819f39..d6758fa10 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -1,253 +1,200 @@
 import { join } from 'path'
 import * as Sequelize from 'sequelize'
+import {
+  AfterDestroy,
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  Default,
+  ForeignKey,
+  HasMany,
+  Is,
+  IsUUID,
+  Model,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
 import { Avatar } from '../../../shared/models/avatars/avatar.model'
+import { activityPubContextify } from '../../helpers'
 import {
-  activityPubContextify,
   isAccountFollowersCountValid,
   isAccountFollowingCountValid,
   isAccountPrivateKeyValid,
   isAccountPublicKeyValid,
-  isUserUsernameValid
-} from '../../helpers'
-import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { AVATARS_DIR } from '../../initializers'
-import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers/constants'
-import { sendDeleteAccount } from '../../lib/activitypub/send/send-delete'
-import { addMethodsToModel } from '../utils'
-import { AccountAttributes, AccountInstance, AccountMethods } from './account-interface'
-
-let Account: Sequelize.Model<AccountInstance, AccountAttributes>
-let load: AccountMethods.Load
-let loadApplication: AccountMethods.LoadApplication
-let loadByUUID: AccountMethods.LoadByUUID
-let loadByUrl: AccountMethods.LoadByUrl
-let loadLocalByName: AccountMethods.LoadLocalByName
-let loadByNameAndHost: AccountMethods.LoadByNameAndHost
-let listByFollowersUrls: AccountMethods.ListByFollowersUrls
-let isOwned: AccountMethods.IsOwned
-let toActivityPubObject: AccountMethods.ToActivityPubObject
-let toFormattedJSON: AccountMethods.ToFormattedJSON
-let getFollowerSharedInboxUrls: AccountMethods.GetFollowerSharedInboxUrls
-let getFollowingUrl: AccountMethods.GetFollowingUrl
-let getFollowersUrl: AccountMethods.GetFollowersUrl
-let getPublicKeyUrl: AccountMethods.GetPublicKeyUrl
-
-export default function defineAccount (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  Account = sequelize.define<AccountInstance, AccountAttributes>('Account',
+  isActivityPubUrlValid
+} from '../../helpers/custom-validators/activitypub'
+import { isUserUsernameValid } from '../../helpers/custom-validators/users'
+import { AVATARS_DIR, CONFIG, CONSTRAINTS_FIELDS } from '../../initializers'
+import { sendDeleteAccount } from '../../lib/activitypub/send'
+import { ApplicationModel } from '../application/application'
+import { AvatarModel } from '../avatar/avatar'
+import { ServerModel } from '../server/server'
+import { throwIfNotValid } from '../utils'
+import { VideoChannelModel } from '../video/video-channel'
+import { AccountFollowModel } from './account-follow'
+import { UserModel } from './user'
+
+@Table({
+  tableName: 'account',
+  indexes: [
     {
-      uuid: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        validate: {
-          isUUID: 4
-        }
-      },
-      name: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        validate: {
-          nameValid: value => {
-            const res = isUserUsernameValid(value)
-            if (res === false) throw new Error('Name is not valid.')
-          }
-        }
-      },
-      url: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          urlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('URL is not valid.')
-          }
-        }
-      },
-      publicKey: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PUBLIC_KEY.max),
-        allowNull: true,
-        validate: {
-          publicKeyValid: value => {
-            const res = isAccountPublicKeyValid(value)
-            if (res === false) throw new Error('Public key is not valid.')
-          }
-        }
-      },
-      privateKey: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PRIVATE_KEY.max),
-        allowNull: true,
-        validate: {
-          privateKeyValid: value => {
-            const res = isAccountPrivateKeyValid(value)
-            if (res === false) throw new Error('Private key is not valid.')
-          }
-        }
-      },
-      followersCount: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        validate: {
-          followersCountValid: value => {
-            const res = isAccountFollowersCountValid(value)
-            if (res === false) throw new Error('Followers count is not valid.')
-          }
-        }
-      },
-      followingCount: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        validate: {
-          followingCountValid: value => {
-            const res = isAccountFollowingCountValid(value)
-            if (res === false) throw new Error('Following count is not valid.')
-          }
-        }
-      },
-      inboxUrl: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          inboxUrlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('Inbox URL is not valid.')
-          }
-        }
-      },
-      outboxUrl: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          outboxUrlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('Outbox URL is not valid.')
-          }
-        }
-      },
-      sharedInboxUrl: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          sharedInboxUrlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('Shared inbox URL is not valid.')
-          }
-        }
-      },
-      followersUrl: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          followersUrlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('Followers URL is not valid.')
-          }
-        }
-      },
-      followingUrl: {
-        type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
-        allowNull: false,
-        validate: {
-          followingUrlValid: value => {
-            const res = isActivityPubUrlValid(value)
-            if (res === false) throw new Error('Following URL is not valid.')
-          }
-        }
-      }
+      fields: [ 'name' ]
     },
     {
-      indexes: [
-        {
-          fields: [ 'name' ]
-        },
-        {
-          fields: [ 'serverId' ]
-        },
-        {
-          fields: [ 'userId' ],
-          unique: true
-        },
-        {
-          fields: [ 'applicationId' ],
-          unique: true
-        },
-        {
-          fields: [ 'name', 'serverId', 'applicationId' ],
-          unique: true
-        }
-      ],
-      hooks: { afterDestroy }
+      fields: [ 'serverId' ]
+    },
+    {
+      fields: [ 'userId' ],
+      unique: true
+    },
+    {
+      fields: [ 'applicationId' ],
+      unique: true
+    },
+    {
+      fields: [ 'name', 'serverId', 'applicationId' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate,
-    loadApplication,
-    load,
-    loadByUUID,
-    loadByUrl,
-    loadLocalByName,
-    loadByNameAndHost,
-    listByFollowersUrls
-  ]
-  const instanceMethods = [
-    isOwned,
-    toActivityPubObject,
-    toFormattedJSON,
-    getFollowerSharedInboxUrls,
-    getFollowingUrl,
-    getFollowersUrl,
-    getPublicKeyUrl
   ]
-  addMethodsToModel(Account, classMethods, instanceMethods)
-
-  return Account
-}
+})
+export class AccountModel extends Model<Account> {
+
+  @AllowNull(false)
+  @Default(DataType.UUIDV4)
+  @IsUUID(4)
+  @Column(DataType.UUID)
+  uuid: string
+
+  @AllowNull(false)
+  @Is('AccountName', value => throwIfNotValid(value, isUserUsernameValid, 'account name'))
+  @Column
+  name: string
+
+  @AllowNull(false)
+  @Is('AccountUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  url: string
+
+  @AllowNull(true)
+  @Is('AccountPublicKey', value => throwIfNotValid(value, isAccountPublicKeyValid, 'public key'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PUBLIC_KEY.max))
+  publicKey: string
+
+  @AllowNull(true)
+  @Is('AccountPublicKey', value => throwIfNotValid(value, isAccountPrivateKeyValid, 'private key'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PRIVATE_KEY.max))
+  privateKey: string
+
+  @AllowNull(false)
+  @Is('AccountFollowersCount', value => throwIfNotValid(value, isAccountFollowersCountValid, 'followers count'))
+  @Column
+  followersCount: number
+
+  @AllowNull(false)
+  @Is('AccountFollowersCount', value => throwIfNotValid(value, isAccountFollowingCountValid, 'following count'))
+  @Column
+  followingCount: number
+
+  @AllowNull(false)
+  @Is('AccountInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'inbox url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  inboxUrl: string
+
+  @AllowNull(false)
+  @Is('AccountOutboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'outbox url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  outboxUrl: string
+
+  @AllowNull(false)
+  @Is('AccountSharedInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'shared inbox url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  sharedInboxUrl: string
+
+  @AllowNull(false)
+  @Is('AccountFollowersUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'followers url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  followersUrl: string
+
+  @AllowNull(false)
+  @Is('AccountFollowingUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'following url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max))
+  followingUrl: string
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @ForeignKey(() => AvatarModel)
+  @Column
+  avatarId: number
+
+  @BelongsTo(() => AvatarModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'cascade'
+  })
+  Avatar: AvatarModel
 
-// ---------------------------------------------------------------------------
+  @ForeignKey(() => ServerModel)
+  @Column
+  serverId: number
 
-function associate (models) {
-  Account.belongsTo(models.Server, {
+  @BelongsTo(() => ServerModel, {
     foreignKey: {
-      name: 'serverId',
       allowNull: true
     },
     onDelete: 'cascade'
   })
+  Server: ServerModel
 
-  Account.belongsTo(models.User, {
+  @ForeignKey(() => UserModel)
+  @Column
+  userId: number
+
+  @BelongsTo(() => UserModel, {
     foreignKey: {
-      name: 'userId',
       allowNull: true
     },
     onDelete: 'cascade'
   })
+  User: UserModel
+
+  @ForeignKey(() => ApplicationModel)
+  @Column
+  applicationId: number
 
-  Account.belongsTo(models.Application, {
+  @BelongsTo(() => ApplicationModel, {
     foreignKey: {
-      name: 'applicationId',
       allowNull: true
     },
     onDelete: 'cascade'
   })
+  Application: ApplicationModel
 
-  Account.hasMany(models.VideoChannel, {
+  @HasMany(() => VideoChannelModel, {
     foreignKey: {
-      name: 'accountId',
       allowNull: false
     },
     onDelete: 'cascade',
     hooks: true
   })
+  VideoChannels: VideoChannelModel[]
 
-  Account.hasMany(models.AccountFollow, {
+  @HasMany(() => AccountFollowModel, {
     foreignKey: {
       name: 'accountId',
       allowNull: false
     },
     onDelete: 'cascade'
   })
+  AccountFollowing: AccountFollowModel[]
 
-  Account.hasMany(models.AccountFollow, {
+  @HasMany(() => AccountFollowModel, {
     foreignKey: {
       name: 'targetAccountId',
       allowNull: false
@@ -255,209 +202,199 @@ function associate (models) {
     as: 'followers',
     onDelete: 'cascade'
   })
+  AccountFollowers: AccountFollowModel[]
 
-  Account.hasOne(models.Avatar, {
-    foreignKey: {
-      name: 'avatarId',
-      allowNull: true
-    },
-    onDelete: 'cascade'
-  })
-}
+  @AfterDestroy
+  static sendDeleteIfOwned (instance: AccountModel) {
+    if (instance.isOwned()) {
+      return sendDeleteAccount(instance, undefined)
+    }
 
-function afterDestroy (account: AccountInstance) {
-  if (account.isOwned()) {
-    return sendDeleteAccount(account, undefined)
+    return undefined
   }
 
-  return undefined
-}
+  static loadApplication () {
+    return AccountModel.findOne({
+      include: [
+        {
+          model: ApplicationModel,
+          required: true
+        }
+      ]
+    })
+  }
 
-toFormattedJSON = function (this: AccountInstance) {
-  let host = CONFIG.WEBSERVER.HOST
-  let score: number
-  let avatar: Avatar = null
+  static load (id: number) {
+    return AccountModel.findById(id)
+  }
 
-  if (this.Avatar) {
-    avatar = {
-      path: join(AVATARS_DIR.ACCOUNT, this.Avatar.filename),
-      createdAt: this.Avatar.createdAt,
-      updatedAt: this.Avatar.updatedAt
+  static loadByUUID (uuid: string) {
+    const query = {
+      where: {
+        uuid
+      }
     }
-  }
 
-  if (this.Server) {
-    host = this.Server.host
-    score = this.Server.score as number
+    return AccountModel.findOne(query)
   }
 
-  const json = {
-    id: this.id,
-    uuid: this.uuid,
-    host,
-    score,
-    name: this.name,
-    followingCount: this.followingCount,
-    followersCount: this.followersCount,
-    createdAt: this.createdAt,
-    updatedAt: this.updatedAt,
-    avatar
-  }
+  static loadLocalByName (name: string) {
+    const query = {
+      where: {
+        name,
+        [ Sequelize.Op.or ]: [
+          {
+            userId: {
+              [ Sequelize.Op.ne ]: null
+            }
+          },
+          {
+            applicationId: {
+              [ Sequelize.Op.ne ]: null
+            }
+          }
+        ]
+      }
+    }
 
-  return json
-}
+    return AccountModel.findOne(query)
+  }
 
-toActivityPubObject = function (this: AccountInstance) {
-  const type = this.serverId ? 'Application' as 'Application' : 'Person' as 'Person'
-
-  const json = {
-    type,
-    id: this.url,
-    following: this.getFollowingUrl(),
-    followers: this.getFollowersUrl(),
-    inbox: this.inboxUrl,
-    outbox: this.outboxUrl,
-    preferredUsername: this.name,
-    url: this.url,
-    name: this.name,
-    endpoints: {
-      sharedInbox: this.sharedInboxUrl
-    },
-    uuid: this.uuid,
-    publicKey: {
-      id: this.getPublicKeyUrl(),
-      owner: this.url,
-      publicKeyPem: this.publicKey
+  static loadByNameAndHost (name: string, host: string) {
+    const query = {
+      where: {
+        name
+      },
+      include: [
+        {
+          model: ServerModel,
+          required: true,
+          where: {
+            host
+          }
+        }
+      ]
     }
+
+    return AccountModel.findOne(query)
   }
 
-  return activityPubContextify(json)
-}
+  static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
+    const query = {
+      where: {
+        url
+      },
+      transaction
+    }
 
-isOwned = function (this: AccountInstance) {
-  return this.serverId === null
-}
+    return AccountModel.findOne(query)
+  }
 
-getFollowerSharedInboxUrls = function (this: AccountInstance, t: Sequelize.Transaction) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    attributes: [ 'sharedInboxUrl' ],
-    include: [
-      {
-        model: Account['sequelize'].models.AccountFollow,
-        required: true,
-        as: 'followers',
-        where: {
-          targetAccountId: this.id
+  static listByFollowersUrls (followersUrls: string[], transaction?: Sequelize.Transaction) {
+    const query = {
+      where: {
+        followersUrl: {
+          [ Sequelize.Op.in ]: followersUrls
         }
-      }
-    ],
-    transaction: t
-  }
+      },
+      transaction
+    }
 
-  return Account.findAll(query)
-    .then(accounts => accounts.map(a => a.sharedInboxUrl))
-}
+    return AccountModel.findAll(query)
+  }
 
-getFollowingUrl = function (this: AccountInstance) {
-  return this.url + '/following'
-}
+  toFormattedJSON () {
+    let host = CONFIG.WEBSERVER.HOST
+    let score: number
+    let avatar: Avatar = null
 
-getFollowersUrl = function (this: AccountInstance) {
-  return this.url + '/followers'
-}
+    if (this.Avatar) {
+      avatar = {
+        path: join(AVATARS_DIR.ACCOUNT, this.Avatar.filename),
+        createdAt: this.Avatar.createdAt,
+        updatedAt: this.Avatar.updatedAt
+      }
+    }
 
-getPublicKeyUrl = function (this: AccountInstance) {
-  return this.url + '#main-key'
-}
+    if (this.Server) {
+      host = this.Server.host
+      score = this.Server.score
+    }
 
-// ------------------------------ STATICS ------------------------------
+    return {
+      id: this.id,
+      uuid: this.uuid,
+      host,
+      score,
+      name: this.name,
+      followingCount: this.followingCount,
+      followersCount: this.followersCount,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      avatar
+    }
+  }
 
-loadApplication = function () {
-  return Account.findOne({
-    include: [
-      {
-        model: Account['sequelize'].models.Application,
-        required: true
+  toActivityPubObject () {
+    const type = this.serverId ? 'Application' as 'Application' : 'Person' as 'Person'
+
+    const json = {
+      type,
+      id: this.url,
+      following: this.getFollowingUrl(),
+      followers: this.getFollowersUrl(),
+      inbox: this.inboxUrl,
+      outbox: this.outboxUrl,
+      preferredUsername: this.name,
+      url: this.url,
+      name: this.name,
+      endpoints: {
+        sharedInbox: this.sharedInboxUrl
+      },
+      uuid: this.uuid,
+      publicKey: {
+        id: this.getPublicKeyUrl(),
+        owner: this.url,
+        publicKeyPem: this.publicKey
       }
-    ]
-  })
-}
-
-load = function (id: number) {
-  return Account.findById(id)
-}
-
-loadByUUID = function (uuid: string) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    where: {
-      uuid
     }
+
+    return activityPubContextify(json)
   }
 
-  return Account.findOne(query)
-}
+  isOwned () {
+    return this.serverId === null
+  }
 
-loadLocalByName = function (name: string) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    where: {
-      name,
-      [Sequelize.Op.or]: [
-        {
-          userId: {
-            [Sequelize.Op.ne]: null
-          }
-        },
+  getFollowerSharedInboxUrls (t: Sequelize.Transaction) {
+    const query = {
+      attributes: [ 'sharedInboxUrl' ],
+      include: [
         {
-          applicationId: {
-            [Sequelize.Op.ne]: null
+          model: AccountFollowModel,
+          required: true,
+          as: 'followers',
+          where: {
+            targetAccountId: this.id
           }
         }
-      ]
+      ],
+      transaction: t
     }
-  }
 
-  return Account.findOne(query)
-}
-
-loadByNameAndHost = function (name: string, host: string) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    where: {
-      name
-    },
-    include: [
-      {
-        model: Account['sequelize'].models.Server,
-        required: true,
-        where: {
-          host
-        }
-      }
-    ]
+    return AccountModel.findAll(query)
+      .then(accounts => accounts.map(a => a.sharedInboxUrl))
   }
 
-  return Account.findOne(query)
-}
-
-loadByUrl = function (url: string, transaction?: Sequelize.Transaction) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    where: {
-      url
-    },
-    transaction
+  getFollowingUrl () {
+    return this.url + '/following'
   }
 
-  return Account.findOne(query)
-}
-
-listByFollowersUrls = function (followersUrls: string[], transaction?: Sequelize.Transaction) {
-  const query: Sequelize.FindOptions<AccountAttributes> = {
-    where: {
-      followersUrl: {
-        [Sequelize.Op.in]: followersUrls
-      }
-    },
-    transaction
+  getFollowersUrl () {
+    return this.url + '/followers'
   }
 
-  return Account.findAll(query)
+  getPublicKeyUrl () {
+    return this.url + '#main-key'
+  }
 }
diff --git a/server/models/account/index.ts b/server/models/account/index.ts
deleted file mode 100644
index 179f66974..000000000
--- a/server/models/account/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export * from './account-interface'
-export * from './account-follow-interface'
-export * from './account-video-rate-interface'
-export * from './user-interface'
diff --git a/server/models/account/user-interface.ts b/server/models/account/user-interface.ts
deleted file mode 100644
index 0f0b72063..000000000
--- a/server/models/account/user-interface.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import * as Bluebird from 'bluebird'
-import * as Sequelize from 'sequelize'
-import { ResultList } from '../../../shared/models/result-list.model'
-import { UserRight } from '../../../shared/models/users/user-right.enum'
-import { UserRole } from '../../../shared/models/users/user-role'
-import { User as FormattedUser } from '../../../shared/models/users/user.model'
-import { AccountInstance } from './account-interface'
-
-export namespace UserMethods {
-  export type HasRight = (this: UserInstance, right: UserRight) => boolean
-  export type IsPasswordMatch = (this: UserInstance, password: string) => Promise<boolean>
-
-  export type ToFormattedJSON = (this: UserInstance) => FormattedUser
-  export type IsAbleToUploadVideo = (this: UserInstance, videoFile: Express.Multer.File) => Promise<boolean>
-
-  export type CountTotal = () => Bluebird<number>
-
-  export type GetByUsername = (username: string) => Bluebird<UserInstance>
-
-  export type ListForApi = (start: number, count: number, sort: string) => Bluebird< ResultList<UserInstance> >
-
-  export type LoadById = (id: number) => Bluebird<UserInstance>
-
-  export type LoadByUsername = (username: string) => Bluebird<UserInstance>
-  export type LoadByUsernameAndPopulateChannels = (username: string) => Bluebird<UserInstance>
-
-  export type LoadByUsernameOrEmail = (username: string, email: string) => Bluebird<UserInstance>
-}
-
-export interface UserClass {
-  isPasswordMatch: UserMethods.IsPasswordMatch,
-  toFormattedJSON: UserMethods.ToFormattedJSON,
-  hasRight: UserMethods.HasRight,
-  isAbleToUploadVideo: UserMethods.IsAbleToUploadVideo,
-
-  countTotal: UserMethods.CountTotal,
-  getByUsername: UserMethods.GetByUsername,
-  listForApi: UserMethods.ListForApi,
-  loadById: UserMethods.LoadById,
-  loadByUsername: UserMethods.LoadByUsername,
-  loadByUsernameAndPopulateChannels: UserMethods.LoadByUsernameAndPopulateChannels,
-  loadByUsernameOrEmail: UserMethods.LoadByUsernameOrEmail
-}
-
-export interface UserAttributes {
-  id?: number
-  password: string
-  username: string
-  email: string
-  displayNSFW?: boolean
-  role: UserRole
-  videoQuota: number
-
-  Account?: AccountInstance
-}
-
-export interface UserInstance extends UserClass, UserAttributes, Sequelize.Instance<UserAttributes> {
-  id: number
-  createdAt: Date
-  updatedAt: Date
-
-  isPasswordMatch: UserMethods.IsPasswordMatch
-  toFormattedJSON: UserMethods.ToFormattedJSON
-  hasRight: UserMethods.HasRight
-}
-
-export interface UserModel extends UserClass, Sequelize.Model<UserInstance, UserAttributes> {}
diff --git a/server/models/account/user.ts b/server/models/account/user.ts
index 3705947c0..84adad96e 100644
--- a/server/models/account/user.ts
+++ b/server/models/account/user.ts
@@ -1,301 +1,251 @@
 import * as Sequelize from 'sequelize'
+import {
+  AllowNull,
+  BeforeCreate,
+  BeforeUpdate,
+  Column, CreatedAt,
+  DataType,
+  Default,
+  HasMany,
+  HasOne,
+  Is,
+  IsEmail,
+  Model,
+  Table, UpdatedAt
+} from 'sequelize-typescript'
 import { hasUserRight, USER_ROLE_LABELS, UserRight } from '../../../shared'
 import {
   comparePassword,
-  cryptPassword,
-  isUserDisplayNSFWValid,
-  isUserPasswordValid,
-  isUserRoleValid,
-  isUserUsernameValid,
-  isUserVideoQuotaValid
+  cryptPassword
 } from '../../helpers'
-import { addMethodsToModel, getSort } from '../utils'
-import { UserAttributes, UserInstance, UserMethods } from './user-interface'
-
-let User: Sequelize.Model<UserInstance, UserAttributes>
-let isPasswordMatch: UserMethods.IsPasswordMatch
-let hasRight: UserMethods.HasRight
-let toFormattedJSON: UserMethods.ToFormattedJSON
-let countTotal: UserMethods.CountTotal
-let getByUsername: UserMethods.GetByUsername
-let listForApi: UserMethods.ListForApi
-let loadById: UserMethods.LoadById
-let loadByUsername: UserMethods.LoadByUsername
-let loadByUsernameAndPopulateChannels: UserMethods.LoadByUsernameAndPopulateChannels
-let loadByUsernameOrEmail: UserMethods.LoadByUsernameOrEmail
-let isAbleToUploadVideo: UserMethods.IsAbleToUploadVideo
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  User = sequelize.define<UserInstance, UserAttributes>('User',
+import {
+  isUserDisplayNSFWValid, isUserPasswordValid, isUserRoleValid, isUserUsernameValid,
+  isUserVideoQuotaValid
+} from '../../helpers/custom-validators/users'
+import { OAuthTokenModel } from '../oauth/oauth-token'
+import { getSort, throwIfNotValid } from '../utils'
+import { VideoChannelModel } from '../video/video-channel'
+import { AccountModel } from './account'
+
+@Table({
+  tableName: 'user',
+  indexes: [
     {
-      password: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        validate: {
-          passwordValid: value => {
-            const res = isUserPasswordValid(value)
-            if (res === false) throw new Error('Password not valid.')
-          }
-        }
-      },
-      username: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        validate: {
-          usernameValid: value => {
-            const res = isUserUsernameValid(value)
-            if (res === false) throw new Error('Username not valid.')
-          }
-        }
-      },
-      email: {
-        type: DataTypes.STRING(400),
-        allowNull: false,
-        validate: {
-          isEmail: true
-        }
-      },
-      displayNSFW: {
-        type: DataTypes.BOOLEAN,
-        allowNull: false,
-        defaultValue: false,
-        validate: {
-          nsfwValid: value => {
-            const res = isUserDisplayNSFWValid(value)
-            if (res === false) throw new Error('Display NSFW is not valid.')
-          }
-        }
-      },
-      role: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        validate: {
-          roleValid: value => {
-            const res = isUserRoleValid(value)
-            if (res === false) throw new Error('Role is not valid.')
-          }
-        }
-      },
-      videoQuota: {
-        type: DataTypes.BIGINT,
-        allowNull: false,
-        validate: {
-          videoQuotaValid: value => {
-            const res = isUserVideoQuotaValid(value)
-            if (res === false) throw new Error('Video quota is not valid.')
-          }
-        }
-      }
+      fields: [ 'username' ],
+      unique: true
     },
     {
-      indexes: [
-        {
-          fields: [ 'username' ],
-          unique: true
-        },
-        {
-          fields: [ 'email' ],
-          unique: true
-        }
-      ],
-      hooks: {
-        beforeCreate: beforeCreateOrUpdate,
-        beforeUpdate: beforeCreateOrUpdate
-      }
+      fields: [ 'email' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate,
-
-    countTotal,
-    getByUsername,
-    listForApi,
-    loadById,
-    loadByUsername,
-    loadByUsernameAndPopulateChannels,
-    loadByUsernameOrEmail
   ]
-  const instanceMethods = [
-    hasRight,
-    isPasswordMatch,
-    toFormattedJSON,
-    isAbleToUploadVideo
-  ]
-  addMethodsToModel(User, classMethods, instanceMethods)
-
-  return User
-}
+})
+export class UserModel extends Model<UserModel> {
+
+  @AllowNull(false)
+  @Is('UserPassword', value => throwIfNotValid(value, isUserPasswordValid, 'user password'))
+  @Column
+  password: string
+
+  @AllowNull(false)
+  @Is('UserPassword', value => throwIfNotValid(value, isUserUsernameValid, 'user name'))
+  @Column
+  username: string
+
+  @AllowNull(false)
+  @IsEmail
+  @Column(DataType.STRING(400))
+  email: string
+
+  @AllowNull(false)
+  @Default(false)
+  @Is('UserDisplayNSFW', value => throwIfNotValid(value, isUserDisplayNSFWValid, 'display NSFW boolean'))
+  @Column
+  displayNSFW: boolean
+
+  @AllowNull(false)
+  @Is('UserRole', value => throwIfNotValid(value, isUserRoleValid, 'role'))
+  @Column
+  role: number
+
+  @AllowNull(false)
+  @Is('UserVideoQuota', value => throwIfNotValid(value, isUserVideoQuotaValid, 'video quota'))
+  @Column(DataType.BIGINT)
+  videoQuota: number
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @HasOne(() => AccountModel, {
+    foreignKey: 'userId',
+    onDelete: 'cascade'
+  })
+  Account: AccountModel
 
-function beforeCreateOrUpdate (user: UserInstance) {
-  if (user.changed('password')) {
-    return cryptPassword(user.password)
-      .then(hash => {
-        user.password = hash
-        return undefined
-      })
+  @HasMany(() => OAuthTokenModel, {
+    foreignKey: 'userId',
+    onDelete: 'cascade'
+  })
+  OAuthTokens: OAuthTokenModel[]
+
+  @BeforeCreate
+  @BeforeUpdate
+  static cryptPasswordIfNeeded (instance: UserModel) {
+    if (instance.changed('password')) {
+      return cryptPassword(instance.password)
+        .then(hash => {
+          instance.password = hash
+          return undefined
+        })
+    }
   }
-}
-
-// ------------------------------ METHODS ------------------------------
 
-hasRight = function (this: UserInstance, right: UserRight) {
-  return hasUserRight(this.role, right)
-}
+  static countTotal () {
+    return this.count()
+  }
 
-isPasswordMatch = function (this: UserInstance, password: string) {
-  return comparePassword(password, this.password)
-}
+  static getByUsername (username: string) {
+    const query = {
+      where: {
+        username: username
+      },
+      include: [ { model: AccountModel, required: true } ]
+    }
 
-toFormattedJSON = function (this: UserInstance) {
-  const json = {
-    id: this.id,
-    username: this.username,
-    email: this.email,
-    displayNSFW: this.displayNSFW,
-    role: this.role,
-    roleLabel: USER_ROLE_LABELS[this.role],
-    videoQuota: this.videoQuota,
-    createdAt: this.createdAt,
-    account: this.Account.toFormattedJSON()
+    return UserModel.findOne(query)
   }
 
-  if (Array.isArray(this.Account.VideoChannels) === true) {
-    const videoChannels = this.Account.VideoChannels
-      .map(c => c.toFormattedJSON())
-      .sort((v1, v2) => {
-        if (v1.createdAt < v2.createdAt) return -1
-        if (v1.createdAt === v2.createdAt) return 0
+  static listForApi (start: number, count: number, sort: string) {
+    const query = {
+      offset: start,
+      limit: count,
+      order: [ getSort(sort) ],
+      include: [ { model: AccountModel, required: true } ]
+    }
 
-        return 1
+    return UserModel.findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return {
+          data: rows,
+          total: count
+        }
       })
-
-    json['videoChannels'] = videoChannels
   }
 
-  return json
-}
-
-isAbleToUploadVideo = function (this: UserInstance, videoFile: Express.Multer.File) {
-  if (this.videoQuota === -1) return Promise.resolve(true)
-
-  return getOriginalVideoFileTotalFromUser(this).then(totalBytes => {
-    return (videoFile.size + totalBytes) < this.videoQuota
-  })
-}
-
-// ------------------------------ STATICS ------------------------------
-
-function associate (models) {
-  User.hasOne(models.Account, {
-    foreignKey: 'userId',
-    onDelete: 'cascade'
-  })
+  static loadById (id: number) {
+    const options = {
+      include: [ { model: AccountModel, required: true } ]
+    }
 
-  User.hasMany(models.OAuthToken, {
-    foreignKey: 'userId',
-    onDelete: 'cascade'
-  })
-}
+    return UserModel.findById(id, options)
+  }
 
-countTotal = function () {
-  return this.count()
-}
+  static loadByUsername (username: string) {
+    const query = {
+      where: {
+        username
+      },
+      include: [ { model: AccountModel, required: true } ]
+    }
 
-getByUsername = function (username: string) {
-  const query = {
-    where: {
-      username: username
-    },
-    include: [ { model: User['sequelize'].models.Account, required: true } ]
+    return UserModel.findOne(query)
   }
 
-  return User.findOne(query)
-}
+  static loadByUsernameAndPopulateChannels (username: string) {
+    const query = {
+      where: {
+        username
+      },
+      include: [
+        {
+          model: AccountModel,
+          required: true,
+          include: [ VideoChannelModel ]
+        }
+      ]
+    }
 
-listForApi = function (start: number, count: number, sort: string) {
-  const query = {
-    offset: start,
-    limit: count,
-    order: [ getSort(sort) ],
-    include: [ { model: User['sequelize'].models.Account, required: true } ]
+    return UserModel.findOne(query)
   }
 
-  return User.findAndCountAll(query).then(({ rows, count }) => {
-    return {
-      data: rows,
-      total: count
+  static loadByUsernameOrEmail (username: string, email: string) {
+    const query = {
+      include: [ { model: AccountModel, required: true } ],
+      where: {
+        [ Sequelize.Op.or ]: [ { username }, { email } ]
+      }
     }
-  })
-}
 
-loadById = function (id: number) {
-  const options = {
-    include: [ { model: User['sequelize'].models.Account, required: true } ]
+    // FIXME: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18387
+    return (UserModel as any).findOne(query)
   }
 
-  return User.findById(id, options)
-}
+  private static getOriginalVideoFileTotalFromUser (user: UserModel) {
+    // Don't use sequelize because we need to use a sub query
+    const query = 'SELECT SUM("size") AS "total" FROM ' +
+      '(SELECT MAX("videoFile"."size") AS "size" FROM "videoFile" ' +
+      'INNER JOIN "video" ON "videoFile"."videoId" = "video"."id" ' +
+      'INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ' +
+      'INNER JOIN "account" ON "videoChannel"."accountId" = "account"."id" ' +
+      'INNER JOIN "user" ON "account"."userId" = "user"."id" ' +
+      'WHERE "user"."id" = $userId GROUP BY "video"."id") t'
+
+    const options = {
+      bind: { userId: user.id },
+      type: Sequelize.QueryTypes.SELECT
+    }
+    return UserModel.sequelize.query(query, options)
+      .then(([ { total } ]) => {
+        if (total === null) return 0
 
-loadByUsername = function (username: string) {
-  const query = {
-    where: {
-      username
-    },
-    include: [ { model: User['sequelize'].models.Account, required: true } ]
+        return parseInt(total, 10)
+      })
   }
 
-  return User.findOne(query)
-}
+  hasRight (right: UserRight) {
+    return hasUserRight(this.role, right)
+  }
 
-loadByUsernameAndPopulateChannels = function (username: string) {
-  const query = {
-    where: {
-      username
-    },
-    include: [
-      {
-        model: User['sequelize'].models.Account,
-        required: true,
-        include: [ User['sequelize'].models.VideoChannel ]
-      }
-    ]
+  isPasswordMatch (password: string) {
+    return comparePassword(password, this.password)
   }
 
-  return User.findOne(query)
-}
+  toFormattedJSON () {
+    const json = {
+      id: this.id,
+      username: this.username,
+      email: this.email,
+      displayNSFW: this.displayNSFW,
+      role: this.role,
+      roleLabel: USER_ROLE_LABELS[ this.role ],
+      videoQuota: this.videoQuota,
+      createdAt: this.createdAt,
+      account: this.Account.toFormattedJSON()
+    }
+
+    if (Array.isArray(this.Account.VideoChannels) === true) {
+      json['videoChannels'] = this.Account.VideoChannels
+        .map(c => c.toFormattedJSON())
+        .sort((v1, v2) => {
+          if (v1.createdAt < v2.createdAt) return -1
+          if (v1.createdAt === v2.createdAt) return 0
 
-loadByUsernameOrEmail = function (username: string, email: string) {
-  const query = {
-    include: [ { model: User['sequelize'].models.Account, required: true } ],
-    where: {
-      [Sequelize.Op.or]: [ { username }, { email } ]
+          return 1
+        })
     }
+
+    return json
   }
 
-  // FIXME: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18387
-  return (User as any).findOne(query)
-}
+  isAbleToUploadVideo (videoFile: Express.Multer.File) {
+    if (this.videoQuota === -1) return Promise.resolve(true)
 
-// ---------------------------------------------------------------------------
-
-function getOriginalVideoFileTotalFromUser (user: UserInstance) {
-  // Don't use sequelize because we need to use a sub query
-  const query = 'SELECT SUM("size") AS "total" FROM ' +
-                '(SELECT MAX("VideoFiles"."size") AS "size" FROM "VideoFiles" ' +
-                'INNER JOIN "Videos" ON "VideoFiles"."videoId" = "Videos"."id" ' +
-                'INNER JOIN "VideoChannels" ON "VideoChannels"."id" = "Videos"."channelId" ' +
-                'INNER JOIN "Accounts" ON "VideoChannels"."accountId" = "Accounts"."id" ' +
-                'INNER JOIN "Users" ON "Accounts"."userId" = "Users"."id" ' +
-                'WHERE "Users"."id" = $userId GROUP BY "Videos"."id") t'
-
-  const options = {
-    bind: { userId: user.id },
-    type: Sequelize.QueryTypes.SELECT
+    return UserModel.getOriginalVideoFileTotalFromUser(this)
+      .then(totalBytes => {
+        return (videoFile.size + totalBytes) < this.videoQuota
+      })
   }
-  return User['sequelize'].query(query, options).then(([ { total } ]) => {
-    if (total === null) return 0
-
-    return parseInt(total, 10)
-  })
 }