server/models/account/account.ts

   1 import * as Sequelize from 'sequelize'
   2
   3 import {
   4   isUserUsernameValid,
   5   isAccountPublicKeyValid,
   6   isAccountUrlValid,
   7   isAccountPrivateKeyValid,
   8   isAccountFollowersCountValid,
   9   isAccountFollowingCountValid,
  10   isAccountInboxValid,
  11   isAccountOutboxValid,
  12   isAccountSharedInboxValid,
  13   isAccountFollowersValid,
  14   isAccountFollowingValid,
  15   activityPubContextify
  16 } from '../../helpers'
  17
  18 import { addMethodsToModel, getSort } from '../utils'
  19 import {
  20   AccountInstance,
  21   AccountAttributes,
  22
  23   AccountMethods
  24 } from './account-interface'
  25 import { sendDeleteAccount } from '../../lib/activitypub/send-request'
  26 import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers/constants'
  27
  28 let Account: Sequelize.Model<AccountInstance, AccountAttributes>
  29 let loadAccountByPodAndUUID: AccountMethods.LoadAccountByPodAndUUID
  30 let load: AccountMethods.Load
  31 let loadApplication: AccountMethods.LoadApplication
  32 let loadByUUID: AccountMethods.LoadByUUID
  33 let loadByUrl: AccountMethods.LoadByUrl
  34 let loadLocalByName: AccountMethods.LoadLocalByName
  35 let loadByNameAndHost: AccountMethods.LoadByNameAndHost
  36 let listOwned: AccountMethods.ListOwned
  37 let isOwned: AccountMethods.IsOwned
  38 let toActivityPubObject: AccountMethods.ToActivityPubObject
  39 let toFormattedJSON: AccountMethods.ToFormattedJSON
  40 let getFollowerSharedInboxUrls: AccountMethods.GetFollowerSharedInboxUrls
  41 let getFollowingUrl: AccountMethods.GetFollowingUrl
  42 let getFollowersUrl: AccountMethods.GetFollowersUrl
  43 let getPublicKeyUrl: AccountMethods.GetPublicKeyUrl
  44
  45 export default function defineAccount (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
  46   Account = sequelize.define<AccountInstance, AccountAttributes>('Account',
  47     {
  48       uuid: {
  49         type: DataTypes.UUID,
  50         defaultValue: DataTypes.UUIDV4,
  51         allowNull: false,
  52         validate: {
  53           isUUID: 4
  54         }
  55       },
  56       name: {
  57         type: DataTypes.STRING,
  58         allowNull: false,
  59         validate: {
  60           nameValid: value => {
  61             const res = isUserUsernameValid(value)
  62             if (res === false) throw new Error('Name is not valid.')
  63           }
  64         }
  65       },
  66       url: {
  67         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
  68         allowNull: false,
  69         validate: {
  70           urlValid: value => {
  71             const res = isAccountUrlValid(value)
  72             if (res === false) throw new Error('URL is not valid.')
  73           }
  74         }
  75       },
  76       publicKey: {
  77         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PUBLIC_KEY.max),
  78         allowNull: false,
  79         validate: {
  80           publicKeyValid: value => {
  81             const res = isAccountPublicKeyValid(value)
  82             if (res === false) throw new Error('Public key is not valid.')
  83           }
  84         }
  85       },
  86       privateKey: {
  87         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.PRIVATE_KEY.max),
  88         allowNull: true,
  89         validate: {
  90           privateKeyValid: value => {
  91             const res = isAccountPrivateKeyValid(value)
  92             if (res === false) throw new Error('Private key is not valid.')
  93           }
  94         }
  95       },
  96       followersCount: {
  97         type: DataTypes.INTEGER,
  98         allowNull: false,
  99         validate: {
 100           followersCountValid: value => {
 101             const res = isAccountFollowersCountValid(value)
 102             if (res === false) throw new Error('Followers count is not valid.')
 103           }
 104         }
 105       },
 106       followingCount: {
 107         type: DataTypes.INTEGER,
 108         allowNull: false,
 109         validate: {
 110           followingCountValid: value => {
 111             const res = isAccountFollowingCountValid(value)
 112             if (res === false) throw new Error('Following count is not valid.')
 113           }
 114         }
 115       },
 116       inboxUrl: {
 117         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
 118         allowNull: false,
 119         validate: {
 120           inboxUrlValid: value => {
 121             const res = isAccountInboxValid(value)
 122             if (res === false) throw new Error('Inbox URL is not valid.')
 123           }
 124         }
 125       },
 126       outboxUrl: {
 127         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
 128         allowNull: false,
 129         validate: {
 130           outboxUrlValid: value => {
 131             const res = isAccountOutboxValid(value)
 132             if (res === false) throw new Error('Outbox URL is not valid.')
 133           }
 134         }
 135       },
 136       sharedInboxUrl: {
 137         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
 138         allowNull: false,
 139         validate: {
 140           sharedInboxUrlValid: value => {
 141             const res = isAccountSharedInboxValid(value)
 142             if (res === false) throw new Error('Shared inbox URL is not valid.')
 143           }
 144         }
 145       },
 146       followersUrl: {
 147         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
 148         allowNull: false,
 149         validate: {
 150           followersUrlValid: value => {
 151             const res = isAccountFollowersValid(value)
 152             if (res === false) throw new Error('Followers URL is not valid.')
 153           }
 154         }
 155       },
 156       followingUrl: {
 157         type: DataTypes.STRING(CONSTRAINTS_FIELDS.ACCOUNTS.URL.max),
 158         allowNull: false,
 159         validate: {
 160           followingUrlValid: value => {
 161             const res = isAccountFollowingValid(value)
 162             if (res === false) throw new Error('Following URL is not valid.')
 163           }
 164         }
 165       }
 166     },
 167     {
 168       indexes: [
 169         {
 170           fields: [ 'name' ]
 171         },
 172         {
 173           fields: [ 'podId' ]
 174         },
 175         {
 176           fields: [ 'userId' ],
 177           unique: true
 178         },
 179         {
 180           fields: [ 'applicationId' ],
 181           unique: true
 182         },
 183         {
 184           fields: [ 'name', 'podId', 'applicationId' ],
 185           unique: true
 186         }
 187       ],
 188       hooks: { afterDestroy }
 189     }
 190   )
 191
 192   const classMethods = [
 193     associate,
 194     loadAccountByPodAndUUID,
 195     loadApplication,
 196     load,
 197     loadByUUID,
 198     loadByUrl,
 199     loadLocalByName,
 200     loadByNameAndHost,
 201     listOwned
 202   ]
 203   const instanceMethods = [
 204     isOwned,
 205     toActivityPubObject,
 206     toFormattedJSON,
 207     getFollowerSharedInboxUrls,
 208     getFollowingUrl,
 209     getFollowersUrl,
 210     getPublicKeyUrl
 211   ]
 212   addMethodsToModel(Account, classMethods, instanceMethods)
 213
 214   return Account
 215 }
 216
 217 // ---------------------------------------------------------------------------
 218
 219 function associate (models) {
 220   Account.belongsTo(models.Pod, {
 221     foreignKey: {
 222       name: 'podId',
 223       allowNull: true
 224     },
 225     onDelete: 'cascade'
 226   })
 227
 228   Account.belongsTo(models.User, {
 229     foreignKey: {
 230       name: 'userId',
 231       allowNull: true
 232     },
 233     onDelete: 'cascade'
 234   })
 235
 236   Account.belongsTo(models.Application, {
 237     foreignKey: {
 238       name: 'applicationId',
 239       allowNull: true
 240     },
 241     onDelete: 'cascade'
 242   })
 243
 244   Account.hasMany(models.VideoChannel, {
 245     foreignKey: {
 246       name: 'accountId',
 247       allowNull: false
 248     },
 249     onDelete: 'cascade',
 250     hooks: true
 251   })
 252
 253   Account.hasMany(models.AccountFollow, {
 254     foreignKey: {
 255       name: 'accountId',
 256       allowNull: false
 257     },
 258     as: 'following',
 259     onDelete: 'cascade'
 260   })
 261
 262   Account.hasMany(models.AccountFollow, {
 263     foreignKey: {
 264       name: 'targetAccountId',
 265       allowNull: false
 266     },
 267     as: 'followers',
 268     onDelete: 'cascade'
 269   })
 270 }
 271
 272 function afterDestroy (account: AccountInstance) {
 273   if (account.isOwned()) {
 274     return sendDeleteAccount(account, undefined)
 275   }
 276
 277   return undefined
 278 }
 279
 280 toFormattedJSON = function (this: AccountInstance) {
 281   let host = this.Pod ? this.Pod.host : CONFIG.WEBSERVER.HOST
 282
 283   const json = {
 284     id: this.id,
 285     host,
 286     name: this.name
 287   }
 288
 289   return json
 290 }
 291
 292 toActivityPubObject = function (this: AccountInstance) {
 293   const type = this.podId ? 'Application' as 'Application' : 'Person' as 'Person'
 294
 295   const json = {
 296     type,
 297     id: this.url,
 298     following: this.getFollowingUrl(),
 299     followers: this.getFollowersUrl(),
 300     inbox: this.inboxUrl,
 301     outbox: this.outboxUrl,
 302     preferredUsername: this.name,
 303     url: this.url,
 304     name: this.name,
 305     endpoints: {
 306       sharedInbox: this.sharedInboxUrl
 307     },
 308     uuid: this.uuid,
 309     publicKey: {
 310       id: this.getPublicKeyUrl(),
 311       owner: this.url,
 312       publicKeyPem: this.publicKey
 313     }
 314   }
 315
 316   return activityPubContextify(json)
 317 }
 318
 319 isOwned = function (this: AccountInstance) {
 320   return this.podId === null
 321 }
 322
 323 getFollowerSharedInboxUrls = function (this: AccountInstance) {
 324   const query: Sequelize.FindOptions<AccountAttributes> = {
 325     attributes: [ 'sharedInboxUrl' ],
 326     include: [
 327       {
 328         model: Account['sequelize'].models.AccountFollow,
 329         required: true,
 330         as: 'followers',
 331         where: {
 332           targetAccountId: this.id
 333         }
 334       }
 335     ]
 336   }
 337
 338   return Account.findAll(query)
 339     .then(accounts => accounts.map(a => a.sharedInboxUrl))
 340 }
 341
 342 getFollowingUrl = function (this: AccountInstance) {
 343   return this.url + '/following'
 344 }
 345
 346 getFollowersUrl = function (this: AccountInstance) {
 347   return this.url + '/followers'
 348 }
 349
 350 getPublicKeyUrl = function (this: AccountInstance) {
 351   return this.url + '#main-key'
 352 }
 353
 354 // ------------------------------ STATICS ------------------------------
 355
 356 listOwned = function () {
 357   const query: Sequelize.FindOptions<AccountAttributes> = {
 358     where: {
 359       podId: null
 360     }
 361   }
 362
 363   return Account.findAll(query)
 364 }
 365
 366 loadApplication = function () {
 367   return Account.findOne({
 368     include: [
 369       {
 370         model: Account['sequelize'].models.Application,
 371         required: true
 372       }
 373     ]
 374   })
 375 }
 376
 377 load = function (id: number) {
 378   return Account.findById(id)
 379 }
 380
 381 loadByUUID = function (uuid: string) {
 382   const query: Sequelize.FindOptions<AccountAttributes> = {
 383     where: {
 384       uuid
 385     }
 386   }
 387
 388   return Account.findOne(query)
 389 }
 390
 391 loadLocalByName = function (name: string) {
 392   const query: Sequelize.FindOptions<AccountAttributes> = {
 393     where: {
 394       name,
 395       [Sequelize.Op.or]: [
 396         {
 397           userId: {
 398             [Sequelize.Op.ne]: null
 399           }
 400         },
 401         {
 402           applicationId: {
 403             [Sequelize.Op.ne]: null
 404           }
 405         }
 406       ]
 407     }
 408   }
 409
 410   return Account.findOne(query)
 411 }
 412
 413 loadByNameAndHost = function (name: string, host: string) {
 414   const query: Sequelize.FindOptions<AccountAttributes> = {
 415     where: {
 416       name
 417     },
 418     include: [
 419       {
 420         model: Account['sequelize'].models.Pod,
 421         required: true,
 422         where: {
 423           host
 424         }
 425       }
 426     ]
 427   }
 428
 429   return Account.findOne(query)
 430 }
 431
 432 loadByUrl = function (url: string, transaction?: Sequelize.Transaction) {
 433   const query: Sequelize.FindOptions<AccountAttributes> = {
 434     where: {
 435       url
 436     },
 437     transaction
 438   }
 439
 440   return Account.findOne(query)
 441 }
 442
 443 loadAccountByPodAndUUID = function (uuid: string, podId: number, transaction: Sequelize.Transaction) {
 444   const query: Sequelize.FindOptions<AccountAttributes> = {
 445     where: {
 446       podId,
 447       uuid
 448     },
 449     transaction
 450   }
 451
 452   return Account.find(query)
 453 }