lets give it a whirl

Author: dwelch2344

.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: NPM (GitHub) Publish
+
+on:
+  release:
+    types: [created]
+
+# on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 12
+          # registry-url: https://npm.pkg.github.com/
+          scope: '@hexlyoss'
+      - run: npm install
+      - run: git describe --exact-match --tags $(git log -n1 --pretty='%h') | xargs npm version --allow-same-version
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPMJS_PUBLISH_SECRET}}

.gitignore

@@ -0,0 +1,5 @@
+.history
+node_modules
+.env
+.envrc
+.vscode

index.js

@@ -0,0 +1,9 @@
+const log = require('./lib/log')
+const express = require('./lib/express')
+const security = require('./lib/security')
+
+module.exports = {
+  log,
+  express,
+  security
+}

lib/express.js

@@ -0,0 +1,35 @@
+const express = require('express')
+const bodyParser = require('body-parser')
+const cors = require('cors')
+const passport = require('passport')
+
+const log = require('./log').manager.createLogger(__filename)
+
+const initExpress = async (settings) => {
+  const s = settings || {}
+  const app = express()
+  app.use(cors())
+  app.use(bodyParser.json())
+  app.use(passport.initialize());
+  s.passport && s.passport.session && app.use(passport.session())
+  app.use(passport.authenticate(['basic', 'jwt', 'anonymous'], { session: false }))
+  return app
+}
+
+function wrapper (callback) {
+  return function (req, res, next) {
+    callback(req, res, next)
+      .catch(error => {
+        log.warn(`Unhandled Express Route Error at path=[${req.path}]: `, error)
+        next({
+          message: 'Internal Server Error',
+          error
+        })
+      })
+  }
+}
+
+module.exports = {
+  wrapper,
+  initExpress
+}

lib/log.js

@@ -0,0 +1,106 @@
+// TODO research async stacktraces
+// https://medium.com/@nodejs/introducing-node-js-12-76c41a1b3f3f
+
+const util = require('util')
+const SimpleLogger = require('simple-node-logger')
+const { AbstractAppender } = SimpleLogger
+
+const localOrTest = !!(['localhost', 'test'].find(e => e === process.env.NODE_ENV))
+const CWD = process.cwd()
+
+let level
+if (process.env.LOGGER_LEVEL) {
+  level = process.env.LOGGER_LEVEL
+} else {
+  level = localOrTest ? 'debug' : 'info'
+}
+
+const printer = output => localOrTest
+  ? process.stdout.write(util.inspect(output, false, null, true) + '\n')
+  : process.stdout.write(util.inspect(output, { breakLength: Infinity }) + '\n')
+
+const JSONAppender = function () {
+  var appender = this;
+
+  var opts = {
+    typeName: 'JSONAppender',
+    timestampFormat: 'YYYY-MM-DD HH:mm:ss.SSS'
+  };
+
+  AbstractAppender.extend(this, opts);
+
+  // format and write all entry/statements
+  this.write = function (entry) {
+    const msg = Array.isArray(entry.msg) ? [...entry.msg] : entry.msg
+
+    // if we monkey patched our line numbers, let's use that as the source
+    // so that VSCode will give us nice clickable links
+    let source
+    if (localOrTest && msg.length && msg[0].__hexLine) {
+      source = './' + msg.shift().__hexLine
+    } else {
+      source = entry.category
+    }
+
+    if (Array.isArray(msg)) {
+      const last = msg.length - 1
+      if (msg[last] instanceof Error) {
+        const err = msg[last]
+        msg[last] = `Error: ${err.message}\n${err.stack}`
+      }
+    }
+
+    const output = {
+      ts: appender.formatTimestamp(entry.ts),
+      source,
+      level: entry.level,
+      message: msg
+    }
+    printer(output)
+  };
+};
+
+const timestampFormat = 'YYYY-MM-DD HH:mm:ss.SSS'
+const appender = new JSONAppender({ timestampFormat })
+
+const manager = SimpleLogger.createLogManager({
+  level,
+  timestampFormat: 'YYYY-MM-DD HH:mm:ss.SSS',
+  errorEventName: 'error',
+  appenders: [appender]
+})
+
+// If we're local or test, let's
+// monkey patch our loggers to include line numbers
+if (localOrTest) {
+  // const REGEX = /.*(?<source>[^)]*):\d+\)/
+  const pattern = `.*${CWD}/(?<source>[^\\)]*):\\d+\\)?`
+
+  const REGEX = new RegExp(pattern)
+  const orig = manager.createLogger.bind(manager)
+  manager.createLogger = (...args) => {
+    const logger = orig(...args)
+    const origLog = logger.log.bind(logger)
+    logger.log = (...logArgs) => {
+      const stack = new Error().stack
+      const find = stack.split('\n')[3].match(REGEX)
+      if (find && find.groups) {
+        logArgs[1].splice(0, 0, { __hexLine: find.groups.source })
+      } else {
+
+      }
+
+      origLog(...logArgs)
+    }
+    return logger
+  }
+}
+
+const createLogger = (...args) => manager.createLogger(...args)
+
+module.exports = {
+  JSONAppender,
+  manager,
+  createLogger,
+  defaultLevel: level
+}

lib/security.js

@@ -0,0 +1,86 @@
+
+const Config = require('config')
+const passport = require('passport')
+const { BasicStrategy } = require('passport-http')
+const { Strategy: AnonymousStrategy } = require('passport-anonymous')
+
+const JwtStrategy = require('passport-jwt').Strategy;
+const ExtractJwt = require('passport-jwt').ExtractJwt
+
+const log = require('./log').createLogger(__filename)
+
+const initSecurity = (config = {}) => {
+  const pp = config.passport || {}
+  initPassport(pp)
+}
+
+const initPassport = ( config = {} ) => {
+  const { validateBasic } = config
+
+  if( validateBasic ){
+    log.info('Configuring basic strategy')
+    passport.use(new BasicStrategy(
+      async (username, password, done) => {
+        try {
+          let user = await validateBasic(username, password)
+          done(null, user)
+        }catch(err){
+          done(err)
+        }
+      }
+    ));
+  }
+
+  const legacySecret = Config.get('security.jwt.legacy')
+  if( legacySecret ){
+    var opts = {}
+    opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken();
+    opts.secretOrKey = legacySecret;
+    // opts.issuer = 'accounts.examplesoft.com';
+    // opts.audience = 'yoursite.net';
+    passport.use(new JwtStrategy(opts, async (claims, done) => {
+      // legacy token
+      const p = {
+        authenticated: true
+      }
+      if (claims.aud === 'postgraphile') {
+        Object.assign(p, {
+          type: 'member',
+          anonymous: false,
+          identity: claims.identityId,
+          member: claims.memberId,
+          tenant: claims.tenantId,
+          audit: claims.auditId
+        })
+      }
+
+      done(null, p)
+    }));
+  }else{
+    log.warn('No legacy secret provided')
+  }
+
+  passport.use(new AnonymousStrategy())
+}
+
+const createApolloContextFromExpress = (apolloServerArgs) => {
+  const { req, res } = apolloServerArgs
+
+  const context = {}
+  const { user } = req
+  Object.assign(context, {
+    user,
+    express: {
+      request: req,
+      response: res,
+      arguments: args
+    }
+  })
+  return context
+}
+
+module.exports = {
+  initSecurity,
+  initPassport,
+  createApolloContextFromExpress
+}