WIP - Migrate backend to Deno

.flowconfig

@@ -7,6 +7,10 @@
 # - https://flowtype.org/docs/objects.html
 # - https://flowtype.org/docs/functions.html
 .*/Gruntfile.js
+# Backend files use TypeScript instead of Flow since they run using Deno.
+.*/backend/.*
+# Shared files must be imported by Deno backend files, so they better not contain Flowtype annotations.
+.*/shared/.*
 .*/dist/.*
 .*/contracts/.*
 .*/frontend/assets/.*

.travis.yml

@@ -9,6 +9,14 @@ env:
 branches:
   only:
     - master # https://github.com/okTurtles/group-income/issues/58
+before_install:
+  # https://blog.travis-ci.com/2021-02-01-rundeno
+  - pwd
+  - curl -fsSL https://deno.land/x/install/install.sh | sh
+  - ls -l $HOME/.deno
+  - export DENO_INSTALL="$HOME/.deno"
+  - export PATH="$DENO_INSTALL/bin:$PATH"
+  - deno run https://deno.land/std/examples/welcome.ts   
 cache:
   # Caches $HOME/.npm when npm ci is default script command
   # Caches node_modules in all other cases

Gruntfile.js

@@ -5,7 +5,7 @@
 //
 // Ensures:
 //
-// - Babel support is available on the backend, in Mocha tests, etc.
+// - Babel support is available in Mocha tests, etc.
 // - Environment variables are set to different values depending
 //   on whether we're in a production environment or otherwise.
 //
@@ -14,7 +14,7 @@
 const util = require('util')
 const chalk = require('chalk')
 const crypto = require('crypto')
-const { exec, fork } = require('child_process')
+const { exec, spawn } = require('child_process')
 const execP = util.promisify(exec)
 const { copyFile, readFile } = require('fs/promises')
 const fs = require('fs')
@@ -66,7 +66,7 @@ const {
   EXPOSE_SBP = ''
 } = process.env
 
-const backendIndex = './backend/index.js'
+const backendIndex = './backend/index.ts'
 const distAssets = 'dist/assets'
 const distCSS = 'dist/assets/css'
 const distDir = 'dist'
@@ -378,53 +378,6 @@ module.exports = (grunt) => {
 
   let child = null
 
-  // Useful helper task for `grunt test`.
-  grunt.registerTask('backend:launch', '[internal]', function () {
-    const done = this.async()
-    grunt.log.writeln('backend: launching...')
-    // Provides Babel support for the backend files.
-    require('@babel/register')
-    require(backendIndex).then(done).catch(done)
-  })
-
-  // Used with `grunt dev` only, makes it possible to restart just the server when
-  // backend or shared files are modified.
-  grunt.registerTask('backend:relaunch', '[internal]', function () {
-    const done = this.async() // Tell Grunt we're async.
-    const fork2 = function () {
-      grunt.log.writeln('backend: forking...')
-      child = fork(backendIndex, process.argv, {
-        env: process.env,
-        execArgv: ['--require', '@babel/register']
-      })
-      child.on('error', (err) => {
-        if (err) {
-          console.error('error starting or sending message to child:', err)
-          process.exit(1)
-        }
-      })
-      child.on('exit', (c) => {
-        if (c !== 0) {
-          grunt.log.error(`child exited with error code: ${c}`.bold)
-          // ^C can cause c to be null, which is an OK error.
-          process.exit(c || 0)
-        }
-      })
-      done()
-    }
-    if (child) {
-      grunt.log.writeln('Killing child!')
-      // Wait for successful shutdown to avoid EADDRINUSE errors.
-      child.on('message', () => {
-        child = null
-        fork2()
-      })
-      child.send({ shutdown: 1 })
-    } else {
-      fork2()
-    }
-  })
-
   grunt.registerTask('build', function () {
     const esbuild = this.flags.watch ? 'esbuild:watch' : 'esbuild'
 
@@ -482,8 +435,57 @@ module.exports = (grunt) => {
   })
 
   grunt.registerTask('default', ['dev'])
+
+  grunt.registerTask('deno:start', function () {
+    const done = this.async() // Tell Grunt we're async.
+    child = spawn(
+      'deno',
+      ['run', '--allow-env', '--allow-net', '--allow-read', '--allow-write', '--import-map=import-map.json', backendIndex],
+      {
+        stdio: 'inherit'
+      }
+    )
+    child.on('error', (err) => {
+      if (err) {
+        console.error('Error starting or sending message to child:', err)
+        process.exit(1)
+      }
+    })
+    child.on('exit', (c) => {
+      // ^C can cause c to be null, which is an OK error.
+      if (c === null) {
+        grunt.log.writeln('Backend process exited with null code.')
+        // process.exit(0)
+      } else if (c !== 0) {
+        grunt.log.error(`Backend process exited with error code: ${c}`.bold)
+        process.exit(c)
+      } else {
+        grunt.log.writeln('Backend process exited normally.')
+      }
+    })
+    child.on('close', (code) => {
+      console.log(`Backend process closed with code ${code}`)
+    })
+    child.on('spawn', () => {
+      grunt.log.writeln('Backend process spawned.')
+      done()
+    })
+  })
+
+  grunt.registerTask('deno:stop', function () {
+    if (child) {
+      const killed = child.kill()
+      if (killed) {
+        grunt.log.writeln('Deno backend stopped.')
+        child = null
+      } else {
+        grunt.log.error('Failed to quit dangling child!')
+      }
+    }
+  })
+
   // TODO: add 'deploy' as per https://github.com/okTurtles/group-income/issues/10
-  grunt.registerTask('dev', ['checkDependencies', 'exec:chelDeployAll', 'build:watch', 'backend:relaunch', 'keepalive'])
+  grunt.registerTask('dev', ['checkDependencies', 'exec:chelDeployAll', 'build:watch', 'deno:start', 'keepalive'])
   grunt.registerTask('dist', ['build'])
 
   // --------------------
@@ -547,7 +549,7 @@ module.exports = (grunt) => {
 
     ;[
       [['Gruntfile.js'], [eslint]],
-      [['backend/**/*.js', 'shared/**/*.js'], [eslint, 'backend:relaunch']],
+      [['backend/**/*.ts', 'shared/**/*.js'], [eslint, 'deno:stop', 'deno:start']],
       [['frontend/**/*.html'], ['copy']],
       [['frontend/**/*.js'], [eslint]],
       [['frontend/assets/{fonts,images}/**/*'], ['copy']],
@@ -620,6 +622,19 @@ module.exports = (grunt) => {
     done()
   })
 
+  // Stops the Flowtype server.
+  grunt.registerTask('flow:stop', function () {
+    const done = this.async()
+    exec('./node_modules/.bin/flow stop', (err, stdout, stderr) => {
+      if (!err) {
+        grunt.log.writeln('Flowtype server stopped')
+      } else {
+        grunt.log.error('Could not stop Flowtype server:', err.message)
+      }
+      done(err)
+    })
+  })
+
   // eslint-disable-next-line no-unused-vars
   let killKeepAlive = null
   grunt.registerTask('keepalive', function () {
@@ -628,27 +643,30 @@ module.exports = (grunt) => {
     killKeepAlive = this.async()
   })
 
-  grunt.registerTask('test', ['build', 'exec:chelDeployAll', 'backend:launch', 'exec:test', 'cypress'])
-  grunt.registerTask('test:unit', ['backend:launch', 'exec:test'])
+  grunt.registerTask('test', ['build', 'exec:chelDeployAll', 'deno:start', 'exec:test', 'cypress', 'deno:stop', 'flow:stop'])
+  grunt.registerTask('test:unit', ['deno:start', 'exec:test', 'deno:stop'])
 
   // -------------------------------------------------------------------------
   //  Process event handlers
   // -------------------------------------------------------------------------
 
-  process.on('exit', () => {
+  process.on('exit', (code, signal) => {
+    console.log('[node] Exiting with code:', code, 'signal:', signal)
     // Note: 'beforeExit' doesn't work.
     // In cases where 'watch' fails while child (server) is still running
     // we will exit and child will continue running in the background.
     // This can happen, for example, when running two GIS instances via
     // the PORT_SHIFT envar. If grunt-contrib-watch livereload process
     // cannot bind to the port for some reason, then the parent process
     // will exit leaving a dangling child server process.
-    if (child) {
+    if (child && !child.killed) {
       grunt.log.writeln('Quitting dangling child!')
-      child.send({ shutdown: 2 })
+      child.kill()
     }
-    // Stops the Flowtype server.
-    exec('./node_modules/.bin/flow stop')
+    // Make sure to stop the Flowtype server in case `flow:stop` wasn't called.
+    exec('./node_modules/.bin/flow stop', () => {
+      grunt.log.writeln('Flowtype server stopped in process exit handler')
+    })
   })
 
   process.on('uncaughtException', (err) => {

backend/auth.js → backend/auth.ts

@@ -1,36 +1,37 @@
-// create our auth plugin. see:
+/* globals Deno */
+// Create our auth plugin. See:
 // https://hapijs.com/tutorials/auth
 // https://hapijs.com/tutorials/plugins
 
 import { verify, b64ToStr } from '~/shared/functions.js'
 
-const Boom = require('@hapi/boom')
+const { BadRequest, PermissionDenied } = Deno.errors
 
-exports.plugin = {
+export default {
   name: 'gi-auth',
-  register: function (server: Object, opts: Object) {
+  register (server: Object, opts: Object) {
     server.auth.scheme('gi-auth', function (server, options) {
       return {
-        authenticate: function (request, h) {
+        authenticate (request, h) {
           const { authorization } = request.headers
-          if (!authorization) h.unauthenticated(Boom.unauthorized('Missing authorization'))
+          if (!authorization) h.unauthenticated(new PermissionDenied('Missing authorization'))
 
           let [scheme, json] = authorization.split(/\s+/)
           // NOTE: if you want to add any signature verification, do it here
           // eslint-disable-next-line no-constant-condition
           if (false) {
-            if (!scheme.includes('gi')) h.unauthenticated(Boom.badRequest('Bad authentication'))
+            if (!scheme.includes('gi')) h.unauthenticated(new BadRequest('Bad authentication'))
 
             try {
               json = JSON.parse(b64ToStr(json))
             } catch (e) {
-              return h.unauthenticated(Boom.badRequest('Invalid token format'))
+              return h.unauthenticated(new BadRequest('Invalid token format'))
             }
             // http://hapijs.com/api/#serverauthschemename-scheme
             const isValid = verify(json.msg, json.key, json.sig)
             json.userId = json.key
             const credentials = { credentials: json }
-            if (!isValid) return h.unauthenticated(Boom.unauthorized('Bad credentials'), credentials)
+            if (!isValid) return h.unauthenticated(new PermissionDenied('Bad credentials'), credentials)
             return h.authenticated(credentials)
           } else {
             // remove this if you decide to implement it