oasis/src/index.js

#!/usr/bin/env node

'use strict'

// Koa application to provide HTTP interface.

const cli = require('./cli')
const config = cli()

if (config.debug) {
  process.env.DEBUG = 'oasis,oasis:*'
}

// HACK: We must get the CLI config and then delete environment variables.
// This hides arguments from other upstream modules who might parse them.
//
// Unfortunately some modules think that our CLI options are meant for them,
// and since there's no way to disable that behavior (!) we have to hide them
// manually by setting the args property to an empty array.
process.argv = []

const http = require('./http')

const debug = require('debug')('oasis')
const fs = require('fs').promises
const koaBody = require('koa-body')
const { nav, ul, li, a } = require('hyperaxe')
const open = require('open')
const path = require('path')
const pull = require('pull-stream')
const requireStyle = require('require-style')
const router = require('koa-router')()
const ssbMentions = require('ssb-mentions')
const ssbRef = require('ssb-ref')
const { themeNames } = require('@fraction/base16-css')

const ssb = require('./ssb')

// Create "cooler"-style interface from SSB connection.
// This handle is passed to the models for their convenience.
const cooler = ssb({ offline: config.offline })

const {
  about,
  blob,
  friend,
  meta,
  post,
  vote
} = require('./models')(cooler)

const {
  authorView,
  commentView,
  listView,
  markdownView,
  metaView,
  publicView,
  replyView,
  searchView
} = require('./views')

let sharp

try {
  sharp = require('sharp')
} catch (e) {
  // Optional dependency
}

const defaultTheme = 'atelier-sulphurPool-light'.toLowerCase()

// TODO: refactor
const start = async () => {
  const filePath = path.join(__dirname, '..', 'README.md')
  config.readme = await fs.readFile(filePath, 'utf8')
}
start()

router
  .param('imageSize', (imageSize, ctx, next) => {
    const size = Number(imageSize)
    const isInteger = size % 1 === 0
    const overMinSize = size > 2
    const underMaxSize = size <= 256
    ctx.assert(isInteger && overMinSize && underMaxSize, 'Invalid image size')
    return next()
  })
  .param('blobId', (blobId, ctx, next) => {
    ctx.assert(ssbRef.isBlob(blobId), 400, 'Invalid blob link')
    return next()
  })
  .param('message', (message, ctx, next) => {
    ctx.assert(ssbRef.isMsg(message), 400, 'Invalid message link')
    return next()
  })
  .param('feed', (message, ctx, next) => {
    ctx.assert(ssbRef.isFeedId(message), 400, 'Invalid feed link')
    return next()
  })
  .get('/', async (ctx) => {
    ctx.redirect('/public/popular/day')
  })
  .get('/public/popular/:period', async (ctx) => {
    const { period } = ctx.params
    const publicPopular = async ({ period }) => {
      const messages = await post.popular({ period })

      const option = (somePeriod) =>
        li(
          period === somePeriod
            ? a({ class: 'current', href: `./${somePeriod}` }, somePeriod)
            : a({ href: `./${somePeriod}` }, somePeriod)
        )

      const prefix = nav(
        ul(
          option('day'),
          option('week'),
          option('month'),
          option('year')
        )
      )

      return publicView({
        messages,
        prefix
      })
    }
    ctx.body = await publicPopular({ period })
  })
  .get('/public/latest', async (ctx) => {
    const publicLatest = async () => {
      const messages = await post.latest()
      return publicView({ messages })
    }
    ctx.body = await publicLatest()
  })
  .get('/author/:feed', async (ctx) => {
    const { feed } = ctx.params
    const author = async (feedId) => {
      const description = await about.description(feedId)
      const name = await about.name(feedId)
      const image = await about.image(feedId)
      const messages = await post.fromFeed(feedId)
      const relationship = await friend.getRelationship(feedId)

      const avatarUrl = `/image/256/${encodeURIComponent(image)}`

      return authorView({
        feedId,
        messages,
        name,
        description,
        avatarUrl,
        relationship
      })
    }
    ctx.body = await author(feed)
  })
  .get('/search/', async (ctx) => {
    const { query } = ctx.query
    const search = async ({ query }) => {
      if (typeof query === 'string') {
        // https://github.com/ssbc/ssb-search/issues/7
        query = query.toLowerCase()
      }

      const messages = await post.search({ query })

      return searchView({ messages, query })
    }
    ctx.body = await search({ query })
  })
  .get('/inbox', async (ctx) => {
    const inbox = async () => {
      const messages = await post.inbox()

      return listView({ messages })
    }
    ctx.body = await inbox()
  })
  .get('/hashtag/:channel', async (ctx) => {
    const { channel } = ctx.params
    const hashtag = async (channel) => {
      const messages = await post.fromHashtag(channel)

      return listView({ messages })
    }
    ctx.body = await hashtag(channel)
  })
  .get('/theme.css', (ctx) => {
    const theme = ctx.cookies.get('theme') || defaultTheme

    const packageName = '@fraction/base16-css'
    const filePath = `${packageName}/src/base16-${theme}.css`
    ctx.type = 'text/css'
    ctx.body = requireStyle(filePath)
  })
  .get('/profile/', async (ctx) => {
    const profile = async () => {
      const myFeedId = await meta.myFeedId()

      const description = await about.description(myFeedId)
      const name = await about.name(myFeedId)
      const image = await about.image(myFeedId)

      const messages = await post.fromFeed(myFeedId)

      const avatarUrl = `/image/256/${encodeURIComponent(image)}`

      return authorView({
        feedId: myFeedId,
        messages,
        name,
        description,
        avatarUrl,
        relationship: null
      })
    }
    ctx.body = await profile()
  })
  .get('/json/:message', async (ctx) => {
    const { message } = ctx.params
    ctx.type = 'application/json'
    const json = async (message) => {
      const json = await meta.get(message)
      return JSON.stringify(json, null, 2)
    }
    ctx.body = await json(message)
  })
  .get('/blob/:blobId', async (ctx) => {
    const { blobId } = ctx.params
    const getBlob = async ({ blobId }) => {
      const bufferSource = await blob.get({ blobId })

      debug('got buffer source')
      return new Promise((resolve) => {
        pull(
          bufferSource,
          pull.collect(async (err, bufferArray) => {
            if (err) {
              await blob.want({ blobId })
              resolve(Buffer.alloc(0))
            } else {
              const buffer = Buffer.concat(bufferArray)
              resolve(buffer)
            }
          })
        )
      })
    }
    ctx.body = await getBlob({ blobId })

    if (ctx.body.length === 0) {
      ctx.response.status = 404
    } else {
      ctx.set('Cache-Control', 'public,max-age=31536000,immutable')
    }

    // This prevents an auto-download when visiting the URL.
    ctx.attachment(blobId, { type: 'inline' })
  })
  .get('/image/:imageSize/:blobId', async (ctx) => {
    const { blobId, imageSize } = ctx.params
    ctx.type = 'image/png'
    const fakePixel =
      Buffer.from(
        'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
        'base64'
      )
    const fakeImage = (imageSize) =>
      sharp
        ? sharp({
          create: {
            width: imageSize,
            height: imageSize,
            channels: 4,
            background: {
              r: 0, g: 0, b: 0, alpha: 0.5
            }
          }
        })
        : new Promise((resolve) => resolve(fakePixel))
    const image = async ({ blobId, imageSize }) => {
      const bufferSource = await blob.get({ blobId })
      const fakeId = '&0000000000000000000000000000000000000000000=.sha256'

      debug('got buffer source')
      return new Promise((resolve) => {
        if (blobId === fakeId) {
          debug('fake image')
          fakeImage(imageSize).then(result => resolve(result))
        } else {
          debug('not fake image')
          pull(
            bufferSource,
            pull.collect(async (err, bufferArray) => {
              if (err) {
                await blob.want({ blobId })
                const result = fakeImage(imageSize)
                debug({ result })
                resolve(result)
              } else {
                const buffer = Buffer.concat(bufferArray)

                if (sharp) {
                  sharp(buffer)
                    .resize(imageSize, imageSize)
                    .png()
                    .toBuffer()
                    .then((data) => {
                      resolve(data)
                    })
                } else {
                  resolve(buffer)
                }
              }
            })
          )
        }
      })
    }
    ctx.body = await image({ blobId, imageSize: Number(imageSize) })
  })
  .get('/meta/', async (ctx) => {
    const theme = ctx.cookies.get('theme') || defaultTheme
    const getMeta = async ({ theme }) => {
      const status = await meta.status()
      const peers = await meta.peers()

      return metaView({ status, peers, theme, themeNames })
    }
    ctx.body = await getMeta({ theme })
  })
  .get('/likes/:feed', async (ctx) => {
    const { feed } = ctx.params

    const likes = async ({ feed }) => {
      const messages = await post.likes({ feed })
      return listView({ messages })
    }
    ctx.body = await likes({ feed })
  })
  .get('/meta/readme/', async (ctx) => {
    const status = async (text) => {
      return markdownView({ text })
    }
    ctx.body = await status(config.readme)
  })
  .get('/mentions/', async (ctx) => {
    const mentions = async () => {
      const messages = await post.mentionsMe()

      return listView({ messages })
    }
    ctx.body = await mentions()
  })
  .get('/thread/:message', async (ctx) => {
    const { message } = ctx.params
    const thread = async (message) => {
      const messages = await post.fromThread(message)
      debug('got %i messages', messages.length)

      return listView({ messages })
    }

    ctx.body = await thread(message)
  })
  .get('/reply/:message', async (ctx) => {
    const { message } = ctx.params
    const reply = async (parentId) => {
      const rootMessage = await post.get(parentId)
      const myFeedId = await meta.myFeedId()

      debug('%O', rootMessage)
      const messages = [rootMessage]

      return replyView({ messages, myFeedId })
    }
    ctx.body = await reply(message)
  })
  .get('/comment/:message', async (ctx) => {
    const { message } = ctx.params
    const comment = async (parentId) => {
      const parentMessage = await post.get(parentId)
      const myFeedId = await meta.myFeedId()

      const hasRoot = typeof parentMessage.value.content.root === 'string' && ssbRef.isMsg(parentMessage.value.content.root)
      const hasFork = typeof parentMessage.value.content.fork === 'string' && ssbRef.isMsg(parentMessage.value.content.fork)

      const rootMessage = hasRoot
        ? hasFork
          ? parentMessage
          : await post.get(parentMessage.value.content.root)
        : parentMessage

      const messages = await post.threadReplies(rootMessage.key)

      messages.push(rootMessage)

      return commentView({ messages, myFeedId, parentMessage })
    }
    ctx.body = await comment(message)
  })
  .post('/reply/:message', koaBody(), async (ctx) => {
    const { message } = ctx.params
    const text = String(ctx.request.body.text)
    const publishReply = async ({ message, text }) => {
      // TODO: rename `message` to `parent` or `ancestor` or similar
      const mentions = ssbMentions(text).filter((mention) =>
        mention != null
      ) || undefined

      const parent = await post.get(message)
      return post.reply({
        parent,
        message: { text, mentions }
      })
    }
    ctx.body = await publishReply({ message, text })
    ctx.redirect(`/thread/${encodeURIComponent(message)}`)
  })
  .post('/comment/:message', koaBody(), async (ctx) => {
    const { message } = ctx.params
    const text = String(ctx.request.body.text)
    const publishComment = async ({ message, text }) => {
      // TODO: rename `message` to `parent` or `ancestor` or similar
      const mentions = ssbMentions(text).filter((mention) =>
        mention != null
      ) || undefined
      const parent = await meta.get(message)

      return post.comment({
        parent,
        message: { text, mentions }
      })
    }
    ctx.body = await publishComment({ message, text })
    ctx.redirect(`/thread/${encodeURIComponent(message)}`)
  })
  .post('/publish/', koaBody(), async (ctx) => {
    const text = String(ctx.request.body.text)
    const publish = async ({ text }) => {
      const mentions = ssbMentions(text).filter((mention) =>
        mention != null
      ) || undefined

      return post.root({
        text,
        mentions
      })
    }
    ctx.body = await publish({ text })
    ctx.redirect('/')
  })
  .post('/follow/:feed', koaBody(), async (ctx) => {
    const { feed } = ctx.params
    const referer = new URL(ctx.request.header.referer)
    ctx.body = await friend.follow(feed)
    ctx.redirect(referer)
  })
  .post('/unfollow/:feed', koaBody(), async (ctx) => {
    const { feed } = ctx.params
    const referer = new URL(ctx.request.header.referer)
    ctx.body = await friend.unfollow(feed)
    ctx.redirect(referer)
  })
  .post('/like/:message', koaBody(), async (ctx) => {
    const { message } = ctx.params
    // TODO: convert all so `message` is full message and `messageKey` is key
    const messageKey = message

    const voteValue = Number(ctx.request.body.voteValue)

    const encoded = {
      message: encodeURIComponent(message)
    }

    const referer = new URL(ctx.request.header.referer)
    referer.hash = `centered-footer-${encoded.message}`

    const like = async ({ messageKey, voteValue }) => {
      const value = Number(voteValue)
      const message = await post.get(messageKey)

      const isPrivate = message.value.meta.private === true
      const messageRecipients = isPrivate ? message.value.content.recps : []

      const normalized = messageRecipients.map((recipient) => {
        if (typeof recipient === 'string') {
          return recipient
        }

        if (typeof recipient.link === 'string') {
          return recipient.link
        }

        return null
      })

      const recipients = normalized.length > 0 ? normalized : undefined

      return vote.publish({ messageKey, value, recps: recipients })
    }
    ctx.body = await like({ messageKey, voteValue })
    ctx.redirect(referer)
  })
  .post('/theme.css', koaBody(), async (ctx) => {
    const theme = String(ctx.request.body.theme)
    ctx.cookies.set('theme', theme)
    const referer = new URL(ctx.request.header.referer)
    ctx.redirect(referer)
  })

const { host } = config
const { port } = config
const routes = router.routes()

http({ host, port, routes })

const uri = `http://${host}:${port}/`

const isDebugEnabled = debug.enabled
debug.enabled = true
debug(`Listening on ${uri}`)
debug.enabled = isDebugEnabled

if (config.open === true) {
  open(uri)
}