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, 220 deletions

diff --git a/server/models/oauth/oauth-token.ts b/server/models/oauth/oauth-token.ts
deleted file mode 100644
index f72423190..000000000
--- a/server/models/oauth/oauth-token.ts
+++ /dev/null
@@ -1,220 +0,0 @@
-import { Transaction } from 'sequelize'
-import {
-  AfterDestroy,
-  AfterUpdate,
-  AllowNull,
-  BelongsTo,
-  Column,
-  CreatedAt,
-  ForeignKey,
-  Model,
-  Scopes,
-  Table,
-  UpdatedAt
-} from 'sequelize-typescript'
-import { TokensCache } from '@server/lib/auth/tokens-cache'
-import { MUserAccountId } from '@server/types/models'
-import { MOAuthTokenUser } from '@server/types/models/oauth/oauth-token'
-import { AttributesOnly } from '@shared/typescript-utils'
-import { logger } from '../../helpers/logger'
-import { AccountModel } from '../account/account'
-import { ActorModel } from '../actor/actor'
-import { UserModel } from '../user/user'
-import { OAuthClientModel } from './oauth-client'
-
-export type OAuthTokenInfo = {
-  refreshToken: string
-  refreshTokenExpiresAt: Date
-  client: {
-    id: number
-  }
-  user: MUserAccountId
-  token: MOAuthTokenUser
-}
-
-enum ScopeNames {
-  WITH_USER = 'WITH_USER'
-}
-
-@Scopes(() => ({
-  [ScopeNames.WITH_USER]: {
-    include: [
-      {
-        model: UserModel.unscoped(),
-        required: true,
-        include: [
-          {
-            attributes: [ 'id' ],
-            model: AccountModel.unscoped(),
-            required: true,
-            include: [
-              {
-                attributes: [ 'id', 'url' ],
-                model: ActorModel.unscoped(),
-                required: true
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-}))
-@Table({
-  tableName: 'oAuthToken',
-  indexes: [
-    {
-      fields: [ 'refreshToken' ],
-      unique: true
-    },
-    {
-      fields: [ 'accessToken' ],
-      unique: true
-    },
-    {
-      fields: [ 'userId' ]
-    },
-    {
-      fields: [ 'oAuthClientId' ]
-    }
-  ]
-})
-export class OAuthTokenModel extends Model<Partial<AttributesOnly<OAuthTokenModel>>> {
-
-  @AllowNull(false)
-  @Column
-  accessToken: string
-
-  @AllowNull(false)
-  @Column
-  accessTokenExpiresAt: Date
-
-  @AllowNull(false)
-  @Column
-  refreshToken: string
-
-  @AllowNull(false)
-  @Column
-  refreshTokenExpiresAt: Date
-
-  @Column
-  authName: string
-
-  @CreatedAt
-  createdAt: Date
-
-  @UpdatedAt
-  updatedAt: Date
-
-  @ForeignKey(() => UserModel)
-  @Column
-  userId: number
-
-  @BelongsTo(() => UserModel, {
-    foreignKey: {
-      allowNull: false
-    },
-    onDelete: 'cascade'
-  })
-  User: UserModel
-
-  @ForeignKey(() => OAuthClientModel)
-  @Column
-  oAuthClientId: number
-
-  @BelongsTo(() => OAuthClientModel, {
-    foreignKey: {
-      allowNull: false
-    },
-    onDelete: 'cascade'
-  })
-  OAuthClients: OAuthClientModel[]
-
-  @AfterUpdate
-  @AfterDestroy
-  static removeTokenCache (token: OAuthTokenModel) {
-    return TokensCache.Instance.clearCacheByToken(token.accessToken)
-  }
-
-  static loadByRefreshToken (refreshToken: string) {
-    const query = {
-      where: { refreshToken }
-    }
-
-    return OAuthTokenModel.findOne(query)
-  }
-
-  static getByRefreshTokenAndPopulateClient (refreshToken: string) {
-    const query = {
-      where: {
-        refreshToken
-      },
-      include: [ OAuthClientModel ]
-    }
-
-    return OAuthTokenModel.scope(ScopeNames.WITH_USER)
-                          .findOne(query)
-                          .then(token => {
-                            if (!token) return null
-
-                            return {
-                              refreshToken: token.refreshToken,
-                              refreshTokenExpiresAt: token.refreshTokenExpiresAt,
-                              client: {
-                                id: token.oAuthClientId
-                              },
-                              user: token.User,
-                              token
-                            } as OAuthTokenInfo
-                          })
-                          .catch(err => {
-                            logger.error('getRefreshToken error.', { err })
-                            throw err
-                          })
-  }
-
-  static getByTokenAndPopulateUser (bearerToken: string): Promise<MOAuthTokenUser> {
-    const query = {
-      where: {
-        accessToken: bearerToken
-      }
-    }
-
-    return OAuthTokenModel.scope(ScopeNames.WITH_USER)
-                          .findOne(query)
-                          .then(token => {
-                            if (!token) return null
-
-                            return Object.assign(token, { user: token.User })
-                          })
-  }
-
-  static getByRefreshTokenAndPopulateUser (refreshToken: string): Promise<MOAuthTokenUser> {
-    const query = {
-      where: {
-        refreshToken
-      }
-    }
-
-    return OAuthTokenModel.scope(ScopeNames.WITH_USER)
-      .findOne(query)
-      .then(token => {
-        if (!token) return undefined
-
-        return Object.assign(token, { user: token.User })
-      })
-  }
-
-  static deleteUserToken (userId: number, t?: Transaction) {
-    TokensCache.Instance.deleteUserToken(userId)
-
-    const query = {
-      where: {
-        userId
-      },
-      transaction: t
-    }
-
-    return OAuthTokenModel.destroy(query)
-  }
-}