Migrate server to ESM

Sorry for the very big commit that may lead to git log issues and merge
conflicts, but it's a major step forward:

 * Server can be faster at startup because imports() are async and we can
   easily lazy import big modules
 * Angular doesn't seem to support ES import (with .js extension), so we
   had to correctly organize peertube into a monorepo:
    * Use yarn workspace feature
    * Use typescript reference projects for dependencies
    * Shared projects have been moved into "packages", each one is now a
      node module (with a dedicated package.json/tsconfig.json)
    * server/tools have been moved into apps/ and is now a dedicated app
      bundled and published on NPM so users don't have to build peertube
      cli tools manually
    * server/tests have been moved into packages/ so we don't compile
      them every time we want to run the server
 * Use isolatedModule option:
   * Had to move from const enum to const
     (https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums)
   * Had to explictely specify "type" imports when used in decorators
 * Prefer tsx (that uses esbuild under the hood) instead of ts-node to
   load typescript files (tests with mocha or scripts):
     * To reduce test complexity as esbuild doesn't support decorator
       metadata, we only test server files that do not import server
       models
     * We still build tests files into js files for a faster CI
 * Remove unmaintained peertube CLI import script
 * Removed some barrels to speed up execution (less imports)

1 files changed, 0 insertions, 236 deletions

diff --git a/server/models/account/account-blocklist.ts b/server/models/account/account-blocklist.ts
deleted file mode 100644
index f6212ff6e..000000000
--- a/server/models/account/account-blocklist.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-import { FindOptions, Op, QueryTypes } from 'sequelize'
-import { BelongsTo, Column, CreatedAt, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
-import { handlesToNameAndHost } from '@server/helpers/actors'
-import { MAccountBlocklist, MAccountBlocklistFormattable } from '@server/types/models'
-import { AttributesOnly } from '@shared/typescript-utils'
-import { AccountBlock } from '../../../shared/models'
-import { ActorModel } from '../actor/actor'
-import { ServerModel } from '../server/server'
-import { createSafeIn, getSort, searchAttribute } from '../shared'
-import { AccountModel } from './account'
-
-@Table({
-  tableName: 'accountBlocklist',
-  indexes: [
-    {
-      fields: [ 'accountId', 'targetAccountId' ],
-      unique: true
-    },
-    {
-      fields: [ 'targetAccountId' ]
-    }
-  ]
-})
-export class AccountBlocklistModel extends Model<Partial<AttributesOnly<AccountBlocklistModel>>> {
-
-  @CreatedAt
-  createdAt: Date
-
-  @UpdatedAt
-  updatedAt: Date
-
-  @ForeignKey(() => AccountModel)
-  @Column
-  accountId: number
-
-  @BelongsTo(() => AccountModel, {
-    foreignKey: {
-      name: 'accountId',
-      allowNull: false
-    },
-    as: 'ByAccount',
-    onDelete: 'CASCADE'
-  })
-  ByAccount: AccountModel
-
-  @ForeignKey(() => AccountModel)
-  @Column
-  targetAccountId: number
-
-  @BelongsTo(() => AccountModel, {
-    foreignKey: {
-      name: 'targetAccountId',
-      allowNull: false
-    },
-    as: 'BlockedAccount',
-    onDelete: 'CASCADE'
-  })
-  BlockedAccount: AccountModel
-
-  static isAccountMutedByAccounts (accountIds: number[], targetAccountId: number) {
-    const query = {
-      attributes: [ 'accountId', 'id' ],
-      where: {
-        accountId: {
-          [Op.in]: accountIds
-        },
-        targetAccountId
-      },
-      raw: true
-    }
-
-    return AccountBlocklistModel.unscoped()
-                                .findAll(query)
-                                .then(rows => {
-                                  const result: { [accountId: number]: boolean } = {}
-
-                                  for (const accountId of accountIds) {
-                                    result[accountId] = !!rows.find(r => r.accountId === accountId)
-                                  }
-
-                                  return result
-                                })
-  }
-
-  static loadByAccountAndTarget (accountId: number, targetAccountId: number): Promise<MAccountBlocklist> {
-    const query = {
-      where: {
-        accountId,
-        targetAccountId
-      }
-    }
-
-    return AccountBlocklistModel.findOne(query)
-  }
-
-  static listForApi (parameters: {
-    start: number
-    count: number
-    sort: string
-    search?: string
-    accountId: number
-  }) {
-    const { start, count, sort, search, accountId } = parameters
-
-    const getQuery = (forCount: boolean) => {
-      const query: FindOptions = {
-        offset: start,
-        limit: count,
-        order: getSort(sort),
-        where: { accountId }
-      }
-
-      if (search) {
-        Object.assign(query.where, {
-          [Op.or]: [
-            searchAttribute(search, '$BlockedAccount.name$'),
-            searchAttribute(search, '$BlockedAccount.Actor.url$')
-          ]
-        })
-      }
-
-      if (forCount !== true) {
-        query.include = [
-          {
-            model: AccountModel,
-            required: true,
-            as: 'ByAccount'
-          },
-          {
-            model: AccountModel,
-            required: true,
-            as: 'BlockedAccount'
-          }
-        ]
-      } else if (search) { // We need some joins when counting with search
-        query.include = [
-          {
-            model: AccountModel.unscoped(),
-            required: true,
-            as: 'BlockedAccount',
-            include: [
-              {
-                model: ActorModel.unscoped(),
-                required: true
-              }
-            ]
-          }
-        ]
-      }
-
-      return query
-    }
-
-    return Promise.all([
-      AccountBlocklistModel.count(getQuery(true)),
-      AccountBlocklistModel.findAll(getQuery(false))
-    ]).then(([ total, data ]) => ({ total, data }))
-  }
-
-  static listHandlesBlockedBy (accountIds: number[]): Promise<string[]> {
-    const query = {
-      attributes: [ 'id' ],
-      where: {
-        accountId: {
-          [Op.in]: accountIds
-        }
-      },
-      include: [
-        {
-          attributes: [ 'id' ],
-          model: AccountModel.unscoped(),
-          required: true,
-          as: 'BlockedAccount',
-          include: [
-            {
-              attributes: [ 'preferredUsername' ],
-              model: ActorModel.unscoped(),
-              required: true,
-              include: [
-                {
-                  attributes: [ 'host' ],
-                  model: ServerModel.unscoped(),
-                  required: true
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    }
-
-    return AccountBlocklistModel.findAll(query)
-      .then(entries => entries.map(e => `${e.BlockedAccount.Actor.preferredUsername}@${e.BlockedAccount.Actor.Server.host}`))
-  }
-
-  static getBlockStatus (byAccountIds: number[], handles: string[]): Promise<{ name: string, host: string, accountId: number }[]> {
-    const sanitizedHandles = handlesToNameAndHost(handles)
-
-    const localHandles = sanitizedHandles.filter(h => !h.host)
-                                         .map(h => h.name)
-
-    const remoteHandles = sanitizedHandles.filter(h => !!h.host)
-                                          .map(h => ([ h.name, h.host ]))
-
-    const handlesWhere: string[] = []
-
-    if (localHandles.length !== 0) {
-      handlesWhere.push(`("actor"."preferredUsername" IN (:localHandles) AND "server"."id" IS NULL)`)
-    }
-
-    if (remoteHandles.length !== 0) {
-      handlesWhere.push(`(("actor"."preferredUsername", "server"."host") IN (:remoteHandles))`)
-    }
-
-    const rawQuery = `SELECT "accountBlocklist"."accountId", "actor"."preferredUsername" AS "name", "server"."host" ` +
-      `FROM "accountBlocklist" ` +
-      `INNER JOIN "account" ON "account"."id" = "accountBlocklist"."targetAccountId" ` +
-      `INNER JOIN "actor" ON "actor"."id" = "account"."actorId" ` +
-      `LEFT JOIN "server" ON "server"."id" = "actor"."serverId" ` +
-      `WHERE "accountBlocklist"."accountId" IN (${createSafeIn(AccountBlocklistModel.sequelize, byAccountIds)}) ` +
-      `AND (${handlesWhere.join(' OR ')})`
-
-    return AccountBlocklistModel.sequelize.query(rawQuery, {
-      type: QueryTypes.SELECT as QueryTypes.SELECT,
-      replacements: { byAccountIds, localHandles, remoteHandles }
-    })
-  }
-
-  toFormattedJSON (this: MAccountBlocklistFormattable): AccountBlock {
-    return {
-      byAccount: this.ByAccount.toFormattedJSON(),
-      blockedAccount: this.BlockedAccount.toFormattedJSON(),
-      createdAt: this.createdAt
-    }
-  }
-}