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

diff --git a/server/lib/activitypub/share.ts b/server/lib/activitypub/share.ts
deleted file mode 100644
index 792a73f2a..000000000
--- a/server/lib/activitypub/share.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import { map } from 'bluebird'
-import { Transaction } from 'sequelize'
-import { getServerActor } from '@server/models/application/application'
-import { logger, loggerTagsFactory } from '../../helpers/logger'
-import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
-import { VideoShareModel } from '../../models/video/video-share'
-import { MChannelActorLight, MVideo, MVideoAccountLight, MVideoId } from '../../types/models/video'
-import { fetchAP, getAPId } from './activity'
-import { getOrCreateAPActor } from './actors'
-import { sendUndoAnnounce, sendVideoAnnounce } from './send'
-import { checkUrlsSameHost, getLocalVideoAnnounceActivityPubUrl } from './url'
-
-const lTags = loggerTagsFactory('share')
-
-async function shareVideoByServerAndChannel (video: MVideoAccountLight, t: Transaction) {
-  if (!video.hasPrivacyForFederation()) return undefined
-
-  return Promise.all([
-    shareByServer(video, t),
-    shareByVideoChannel(video, t)
-  ])
-}
-
-async function changeVideoChannelShare (
-  video: MVideoAccountLight,
-  oldVideoChannel: MChannelActorLight,
-  t: Transaction
-) {
-  logger.info(
-    'Updating video channel of video %s: %s -> %s.', video.uuid, oldVideoChannel.name, video.VideoChannel.name,
-    lTags(video.uuid)
-  )
-
-  await undoShareByVideoChannel(video, oldVideoChannel, t)
-
-  await shareByVideoChannel(video, t)
-}
-
-async function addVideoShares (shareUrls: string[], video: MVideoId) {
-  await map(shareUrls, async shareUrl => {
-    try {
-      await addVideoShare(shareUrl, video)
-    } catch (err) {
-      logger.warn('Cannot add share %s.', shareUrl, { err })
-    }
-  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
-}
-
-export {
-  changeVideoChannelShare,
-  addVideoShares,
-  shareVideoByServerAndChannel
-}
-
-// ---------------------------------------------------------------------------
-
-async function addVideoShare (shareUrl: string, video: MVideoId) {
-  const { body } = await fetchAP<any>(shareUrl)
-  if (!body?.actor) throw new Error('Body or body actor is invalid')
-
-  const actorUrl = getAPId(body.actor)
-  if (checkUrlsSameHost(shareUrl, actorUrl) !== true) {
-    throw new Error(`Actor url ${actorUrl} has not the same host than the share url ${shareUrl}`)
-  }
-
-  const actor = await getOrCreateAPActor(actorUrl)
-
-  const entry = {
-    actorId: actor.id,
-    videoId: video.id,
-    url: shareUrl
-  }
-
-  await VideoShareModel.upsert(entry)
-}
-
-async function shareByServer (video: MVideo, t: Transaction) {
-  const serverActor = await getServerActor()
-
-  const serverShareUrl = getLocalVideoAnnounceActivityPubUrl(serverActor, video)
-  const [ serverShare ] = await VideoShareModel.findOrCreate({
-    defaults: {
-      actorId: serverActor.id,
-      videoId: video.id,
-      url: serverShareUrl
-    },
-    where: {
-      url: serverShareUrl
-    },
-    transaction: t
-  })
-
-  return sendVideoAnnounce(serverActor, serverShare, video, t)
-}
-
-async function shareByVideoChannel (video: MVideoAccountLight, t: Transaction) {
-  const videoChannelShareUrl = getLocalVideoAnnounceActivityPubUrl(video.VideoChannel.Actor, video)
-  const [ videoChannelShare ] = await VideoShareModel.findOrCreate({
-    defaults: {
-      actorId: video.VideoChannel.actorId,
-      videoId: video.id,
-      url: videoChannelShareUrl
-    },
-    where: {
-      url: videoChannelShareUrl
-    },
-    transaction: t
-  })
-
-  return sendVideoAnnounce(video.VideoChannel.Actor, videoChannelShare, video, t)
-}
-
-async function undoShareByVideoChannel (video: MVideo, oldVideoChannel: MChannelActorLight, t: Transaction) {
-  // Load old share
-  const oldShare = await VideoShareModel.load(oldVideoChannel.actorId, video.id, t)
-  if (!oldShare) return new Error('Cannot find old video channel share ' + oldVideoChannel.actorId + ' for video ' + video.id)
-
-  await sendUndoAnnounce(oldVideoChannel.Actor, oldShare, video, t)
-  await oldShare.destroy({ transaction: t })
-}