@volcanicminds/backend 0.1.0

package/lib/index.ts

@@ -0,0 +1,253 @@
+'use strict'
+
+import dotenv from 'dotenv'
+dotenv.config()
+
+import yn from './util/yn'
+import logger from './util/logger'
+import * as mark from './util/mark'
+import * as loaderRoles from './loader/roles'
+import * as loaderRouter from './loader/router'
+
+import Fastify, { FastifyInstance } from 'fastify'
+import swagger from '@fastify/swagger'
+import swaggerUI from '@fastify/swagger-ui'
+
+import cors from '@fastify/cors'
+import helmet from '@fastify/helmet'
+import compress from '@fastify/compress'
+import rateLimit from '@fastify/rate-limit'
+
+import { ApolloServer } from '@apollo/server'
+import fastifyApollo, { fastifyApolloHandler, fastifyApolloDrainPlugin } from '@as-integrations/fastify'
+import { myContextFunction, MyContext } from './apollo/context'
+import resolvers from './apollo/resolvers'
+import typeDefs from './apollo/type-defs'
+
+const begin = new Date().getTime()
+mark.print(logger)
+
+export interface global {}
+declare global {
+  var log: any
+  var roles: Roles
+}
+
+global.log = logger
+global.roles = loaderRoles.load()
+
+declare module 'fastify' {
+  export interface FastifyRequest {
+    user?: AuthenticatedUser
+  }
+}
+
+async function attachApollo(fastify: FastifyInstance) {
+  log.info('Attach ApolloServer to Fastify')
+  const apollo = new ApolloServer<MyContext>({
+    typeDefs,
+    resolvers,
+    plugins: [fastifyApolloDrainPlugin(fastify)]
+  })
+
+  await apollo.start()
+
+  return apollo
+}
+
+async function addApolloRouting(fastify: FastifyInstance, apollo: ApolloServer<MyContext> | null) {
+  if (apollo) {
+    log.info('Add graphql routes')
+    await fastify.register(fastifyApollo(apollo), {
+      context: myContextFunction
+    })
+
+    // // OR
+    // fastify.post(
+    //   '/graphql-alt',
+    //   fastifyApolloHandler(apollo, {
+    //     context: myContextFunction
+    //   })
+    // )
+  }
+}
+
+async function addFastifyRouting(fastify: FastifyInstance) {
+  log.info('Add fastify routes')
+
+  fastify.addHook('onSend', async (req, reply) => {
+    log.debug('onSend')
+  })
+
+  fastify.addHook('onResponse', async (req, reply) => {
+    log.debug('onResponse')
+  })
+
+  fastify.addHook('onTimeout', async (req, reply) => {
+    log.debug('onTimeout')
+  })
+
+  fastify.addHook('onReady', async () => {
+    log.debug('onReady')
+  })
+
+  fastify.addHook('onClose', async (instance) => {
+    log.debug('onClose')
+  })
+
+  fastify.addHook('onError', async (req, reply, error) => {
+    log.debug(`onError ${error}`)
+  })
+
+  fastify.addHook('onRequest', async (req, reply) => {
+    log.debug(`onRequest ${req.method} ${req.url}`)
+    req.user = {
+      id: 306,
+      name: 'Huseyin',
+      roles: ['admin', 'public']
+    }
+  })
+
+  fastify.addHook('preParsing', async (req) => {
+    log.debug(`preParsing ${req.method} ${req.url}`)
+    req.user = {
+      id: 42,
+      name: 'Jane Doe',
+      roles: ['admin', 'public']
+    }
+  })
+
+  const routes = loaderRouter.load()
+  routes && loaderRouter.apply(fastify, routes)
+}
+
+async function addFastifySwagger(fastify: FastifyInstance) {
+  const { NODE_ENV, SWAGGER, SWAGGER_TITLE, SWAGGER_DESCRIPTION, SWAGGER_VERSION } = process.env
+  const loadSwagger = yn(SWAGGER, false)
+
+  if (loadSwagger && NODE_ENV !== 'production') {
+    log.info('Add swagger plugin')
+
+    await fastify.register(swagger, {
+      swagger: {
+        info: {
+          title: SWAGGER_TITLE || 'API Documentation',
+          description: SWAGGER_DESCRIPTION || 'List of available APIs and schemes to use',
+          version: SWAGGER_VERSION || '0.1.0'
+        },
+        consumes: ['application/json'],
+        produces: ['application/json']
+      }
+    })
+
+    await fastify.register(swaggerUI, {
+      routePrefix: '/documentation',
+      uiConfig: {
+        docExpansion: 'list',
+        deepLinking: true,
+        defaultModelsExpandDepth: 1
+      },
+      uiHooks: {
+        onRequest: function (request, reply, next) {
+          next()
+        },
+        preHandler: function (request, reply, next) {
+          next()
+        }
+      },
+      staticCSP: true,
+      transformStaticCSP: (header) => header
+    })
+
+    await fastify.put(
+      '/some-route/:id',
+      {
+        schema: {
+          description: 'post some data',
+          tags: ['user', 'code'],
+          deprecated: true,
+          summary: 'qwerty',
+          params: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'string',
+                description: 'user id'
+              }
+            }
+          },
+          body: {
+            type: 'object',
+            properties: {
+              hello: { type: 'string' },
+              obj: {
+                type: 'object',
+                properties: {
+                  some: { type: 'string' }
+                }
+              }
+            }
+          },
+          response: {
+            201: {
+              description: 'Successful response',
+              type: 'object',
+              properties: {
+                hello: { type: 'string' }
+              }
+            },
+            default: {
+              description: 'Default response',
+              type: 'object',
+              properties: {
+                foo: { type: 'string' }
+              }
+            }
+          }
+        }
+      },
+      (req, reply) => {}
+    )
+  }
+}
+const opts = yn(process.env.LOG_FASTIFY, false) ? { logger: logger } : {}
+Fastify(opts).then(async (fastify) => {
+  const { HOST: host = '0.0.0.0', PORT: port = '2230', GRAPHQL } = process.env
+  const { SRV_CORS, SRV_HELMET, SRV_RATELIMIT, SRV_COMPRESS } = process.env
+
+  const loadApollo = yn(GRAPHQL, true)
+  const addPluginCors = yn(SRV_CORS, true)
+  const addPluginHelmet = yn(SRV_HELMET, true)
+  const addPluginRateLimit = yn(SRV_RATELIMIT, true)
+  const addPluginCompress = yn(SRV_COMPRESS, true)
+
+  log.t && log.trace(`Attach Apollo Server ${loadApollo}`)
+  log.t && log.trace(`Add plugin CORS: ${addPluginCors}`)
+  log.t && log.trace(`Add plugin HELMET: ${!loadApollo ? addPluginHelmet : 'Not usable with Apollo'}`)
+  log.t && log.trace(`Add plugin COMPRESS: ${addPluginCompress}`)
+  log.t && log.trace(`Add plugin RATELIMIT: ${addPluginRateLimit}`)
+
+  const apollo = loadApollo ? await attachApollo(fastify) : null
+  // Helmet is not usable with Apollo Server
+  !loadApollo && addPluginHelmet && (await fastify.register(helmet))
+
+  // Usable with Apollo Server
+  addPluginRateLimit && (await fastify.register(rateLimit))
+  addPluginCors && (await fastify.register(cors))
+  addPluginCompress && (await fastify.register(compress))
+
+  await addFastifySwagger(fastify)
+  await addApolloRouting(fastify, apollo)
+  await addFastifyRouting(fastify)
+
+  fastify
+    .listen({
+      port: Number(port),
+      host: host
+    })
+    .then((address) => {
+      const elapsed = (new Date().getTime() - begin) / 100
+      log.info(`All stuff loaded in ${elapsed} sec`)
+      log.info(`🚀 Server ready at ${address}`)
+    })
+})

package/lib/loader/roles.ts

@@ -0,0 +1,13 @@
+import { roles as configRoles } from '../config/roles'
+
+export function load() {
+  const roles: {
+    [key in RoleKey]?: Role
+  } = {}
+
+  configRoles.forEach((role) => {
+    roles[role.code as RoleKey] = role
+  })
+
+  return { ...roles } as Roles
+}

package/lib/loader/router.ts

@@ -0,0 +1,179 @@
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+const glob = require('glob')
+const path = require('path')
+const methods = ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'PATCH', 'OPTIONS']
+
+export function load(): ConfiguredRoute[] {
+  const check = true,
+    print = true,
+    load = true
+
+  const validRoutes: ConfiguredRoute[] = []
+  const patterns = [`${__dirname}/../api/**/routes.{ts,js}`, `${process.cwd()}/src/api/**/routes.{ts,js}`]
+
+  patterns.forEach((pattern) => {
+    check && log.i && log.info('Looking for ' + pattern)
+    glob.sync(pattern).forEach((f: string, index: number, values: string[]) => {
+      const base = path.dirname(f)
+      const dir = path.basename(base)
+      const file = path.join(dir, path.basename(f))
+
+      // allow array or structure
+      const routesjs = require(f)
+      const { routes = [], config: defaultConfig = {} } = routesjs?.default
+
+      // adjust default config
+      if (!defaultConfig.enable) defaultConfig.enable = true
+      if (defaultConfig.deprecated == null) defaultConfig.deprecated = false
+      if (defaultConfig.controller == null) defaultConfig.controller = 'controller'
+
+      check && log.i && log.info(`Load ${file} with ${routes.length} routes defined`)
+      print && log.d && log.debug(`Valid routes loaded from ${file}`)
+
+      routes.forEach((route: Route, index: number) => {
+        const errors = []
+        const { method: methodCase, path: pathName = '/', handler, config, middlewares = [], roles = [] } = route
+
+        // specific route config
+        const {
+          title = '',
+          description = '',
+          enable = defaultConfig.enable || true,
+          deprecated = defaultConfig.deprecated || false,
+          version = defaultConfig.version || '',
+          params,
+          body,
+          response
+        } = config || {}
+
+        // adjust something
+        const endpoint = `${dir}${pathName.replace(/\/+$/, '')}`
+        const method = methodCase.toUpperCase()
+        const num = index + 1
+        const handlerParts = handler.split('.')
+
+        if (enable) {
+          if (!pathName.startsWith('/')) {
+            errors.push(`Error in [${file}] bad path [${pathName}] at route n. ${num}`)
+          }
+
+          if (!methods.includes(method)) {
+            errors.push(`Error in [${file}] bad method [${method}] at route n. ${num}`)
+          }
+
+          if (handlerParts.length !== 2) {
+            errors.push(`Error in [${file}] bad handler [${handler}] at route n. ${num}`)
+          }
+
+          const key = method + endpoint + version
+          if (validRoutes.some((r) => `${r.method}${r.path}${r.doc?.version}` === key)) {
+            errors.push(`Error in [${file}] duplicated path [${pathName}] at route n. ${num}`)
+          }
+
+          if (errors.length > 0) {
+            check && log.e && errors.forEach((error) => log.error(error))
+          }
+        }
+
+        if (errors.length == 0) {
+          enable && print
+            ? log.d &&
+              log.debug(
+                `* Method [${method}] path ${endpoint} handler ${handler}, has middleware? ${
+                  (middlewares && middlewares.length) || 'no'
+                }`
+              )
+            : !enable
+            ? log.w && log.warn(`* Method [${method}] path ${endpoint} handler ${handler} disabled. Skip.`)
+            : log.i && log.info(`* Method [${method}] path ${endpoint} handler ${handler} enabled.`)
+
+          validRoutes.push({
+            handler,
+            method,
+            path: '/' + endpoint,
+            middlewares,
+            roles,
+            enable,
+            base,
+            file: path.join(base, defaultConfig.controller, handlerParts[0]),
+            func: handlerParts[1],
+            // swagger
+            doc: {
+              summary: title,
+              description,
+              deprecated,
+              version,
+              params,
+              body,
+              response
+            }
+          })
+        }
+      })
+    })
+  })
+
+  return validRoutes
+}
+
+function normalizeMiddlewarePath(base: string, middleware: string = '') {
+  const key = 'global.'
+  const idx = middleware.indexOf(key)
+  return idx == 0
+    ? path.resolve(__dirname + '/../middleware/' + middleware.substring(key.length))
+    : path.resolve(base + '/middleware/' + middleware)
+}
+
+export function apply(server: any, routes: ConfiguredRoute[]): void {
+  log.t && log.trace(`Apply ${routes.length} routes to server with pid ${process.pid}`)
+
+  routes.forEach(async ({ handler, method, path, middlewares, roles, enable, base, file, func, doc }) => {
+    if (enable) {
+      log.t && log.trace(`Add path ${method} ${path} on handle ${handler}`)
+
+      const allMiddlewares =
+        middlewares?.length > 0 ? middlewares.map((m) => require(normalizeMiddlewarePath(base, m))) : []
+
+      server.route({
+        method: method,
+        path: path,
+        schema: doc,
+        // preHandler: allMiddlewares,
+        handler: (request: FastifyRequest, reply: FastifyReply) => {
+          try {
+            if (roles?.length > 0) {
+              const userRoles = request.user?.roles || []
+              const resolvedRole = roles.filter((r) => userRoles.includes(r.code))
+              if (!resolvedRole || resolvedRole.length === 0) {
+                log.w && log.warn(`Not allowed to call ${method.toUpperCase()} ${path}`)
+                return reply.code(403).send()
+              }
+            }
+            return require(file + '.ts')[func](request, reply)
+          } catch (err) {
+            log.e && log.error(`Cannot find ${file}.js or method ${func}: ${err}`)
+            return reply.code(500).send(`Invalid handler ${handler}`)
+          }
+        }
+      })
+
+      // server[method](path, (request: FastifyRequest, reply: FastifyReply) => {
+      //   try {
+      //     if (roles?.length > 0) {
+      //       const userRoles = request.user?.roles || []
+      //       const resolvedRole = roles.filter((r) => userRoles.includes(r.code))
+      //       if (!resolvedRole || resolvedRole.length === 0) {
+      //         log.w && log.warn(`Not allowed to call ${method.toUpperCase()} ${path}`)
+      //         return reply.code(403).send()
+      //       }
+      //     }
+      //     return require(file + '.ts')[func](request, reply)
+      //   } catch (err) {
+      //     log.e && log.error(`Cannot find ${file}.js or method ${func}: ${err}`)
+      //     return reply.code(500).send(`Invalid handler ${handler}`)
+      //   }
+      // })
+    }
+  })
+}

package/lib/middleware/example.ts

@@ -0,0 +1,12 @@
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+const log = global.log
+module.exports = (req: FastifyRequest, res: FastifyReply, next: any) => {
+  try {
+    // TODO: do something and then you can throw an exception or call next()..
+    return next()
+  } catch (err) {
+    log.e && log.error(`Upps, something just happened ${err}`)
+    res.code(403).send(err)
+  }
+}

package/lib/middleware/isAdmin.ts

@@ -0,0 +1,15 @@
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+const log = global.log
+module.exports = (req: FastifyRequest, res: FastifyReply, next: any) => {
+  try {
+    if (!!req.user?.id && (req.user?.roles || []).includes(roles.admin.code)) {
+      log.d && log.trace('isAdmin - user id ' + req.user?.id)
+      return next()
+    }
+    throw new Error('User not valid')
+  } catch (err) {
+    log.e && log.error(`Upps, something just happened ${err}`)
+    res.code(403).send(err)
+  }
+}

package/lib/middleware/isAuthenticated.ts

@@ -0,0 +1,16 @@
+import { FastifyReply, FastifyRequest } from 'fastify'
+
+const log = global.log
+module.exports = (req: FastifyRequest, res: FastifyReply, next: any) => {
+  try {
+    // TODO: do something and then you can throw an exception or call next()..
+    if (!!req.user?.id) {
+      log.d && log.trace('isAuthenticated - user id ' + req.user?.id)
+      return next()
+    }
+    throw new Error('User not authenticated')
+  } catch (err) {
+    log.e && log.error(`Upps, something just happened ${err}`)
+    res.code(403).send(err)
+  }
+}

package/lib/types/global.d.ts

@@ -0,0 +1,66 @@
+export {}
+
+declare global {
+  interface AuthenticatedUser {
+    id: number
+    name: string
+    roles: string[]
+  }
+
+  interface Role {
+    code: string
+    name: string
+    description: string
+  }
+
+  declare enum RoleKey {
+    public = 'public',
+    admin = 'admin',
+    backoffice = 'backoffice'
+  }
+
+  declare type Roles = {
+    [key in RoleKey]: Role
+  }
+
+  interface RouteConfig {
+    title: string
+    description: string
+    enable: boolean
+    deprecated: boolean
+    version: string
+    params?: any
+    body?: any
+    response?: any
+  }
+
+  interface Route {
+    method: string
+    path: string
+    handler: string
+    roles: Role[]
+    config?: RouteConfig
+    middlewares: string[]
+  }
+
+  interface ConfiguredRoute {
+    enable: boolean
+    method: any
+    path: string
+    handler: any
+    file: string
+    func: any
+    base: string
+    middlewares: string[]
+    roles: Role[]
+    doc: {
+      summary?: string
+      description?: string
+      deprecated?: boolean
+      version?: string
+      params?: any
+      body?: any
+      response?: any
+    }
+  }
+}

package/lib/util/logger.ts

@@ -0,0 +1,71 @@
+'use strict'
+
+/**
+ * Minimal logger thanks to Pino
+ */
+
+// log.debug('test log test log test log')
+// log.error('test log test log test log')
+// log.warn('test log test log test log')
+// log.info('test log test log test log')
+// log.fatal('test log test log test log')
+// log.trace('test log test log test log')
+
+import pino from 'pino'
+import yn from './yn'
+
+const logLevels = ['fatal', 'error', 'warn', 'info', 'debug', 'trace']
+
+const { LOG_LEVEL, LOG_COLORIZE, LOG_TIMESTAMP, LOG_TIMESTAMP_READABLE } = process.env
+
+function getLogLevel(): string {
+  const lvl = LOG_LEVEL?.toLowerCase()
+  return LOG_LEVEL && logLevels.includes(lvl!) ? lvl! : 'debug'
+}
+
+const logColorize = yn(LOG_COLORIZE, true)
+const logTimestamp = yn(LOG_TIMESTAMP, true)
+const logTimestampReadable = yn(LOG_TIMESTAMP_READABLE, true)
+
+const loggerConfig = {
+  level: getLogLevel(),
+  timestamp: logTimestamp,
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      translateTime: logTimestampReadable ? 'yyyymmdd HH:MM:ss.l' : false,
+      colorize: logColorize
+    }
+  }
+}
+
+let logger = pino(loggerConfig)
+const logLevel = logger.levels.values[loggerConfig.level]
+
+// Level:	trace	debug	info	warn	error	fatal	silent
+// Value:	10	20	30	40	50	60	Infinity
+
+const loggerExt = Object.assign(logger, {
+  t: logLevel < 11,
+  d: logLevel < 21,
+  i: logLevel < 31,
+  w: logLevel < 41,
+  e: logLevel < 51,
+  f: logLevel < 61,
+  getLogLevel: getLogLevel,
+  loggerConfig: loggerConfig,
+  updateLevel: () => {
+    loggerExt.t = loggerExt.levelVal < 11
+    loggerExt.d = loggerExt.levelVal < 21
+    loggerExt.i = loggerExt.levelVal < 31
+    loggerExt.w = loggerExt.levelVal < 41
+    loggerExt.e = loggerExt.levelVal < 51
+    loggerExt.f = loggerExt.levelVal < 61
+  }
+})
+
+loggerExt.on('level-change', () => {
+  log.trace('Log level changed')
+})
+
+export default loggerExt

package/lib/util/mark.ts

@@ -0,0 +1,25 @@
+const pkg = require('../../package.json')
+
+/**
+ * Minimal mark printed at startup
+ */
+
+export function print(logg: any = log): void {
+  logg.i && logg.info('Ciao')
+  logg.i && logg.info(`              ,--.                  ,--.      `)
+  logg.i && logg.info(`.--.  ,--,---.|  |,---.,--,--,--,--\\\`--',---. `)
+  logg.i && logg.info(` \\  ''  | .-. |  / .--' ,-.  |      ,--/ .--' `)
+  logg.i && logg.info(`  \\    /' '-' |  \\ \`--\\ '-'  |  ||  |  \\ \`--. `)
+  logg.i && logg.info(`   \`--'  \`---'\`--'\`---'\`--\`--\`--''--\`--'\`---' `)
+  logg.i && logg.info('')
+  logg.t && logg.trace(`Package ${pkg.name}`)
+  logg.i && logg.info(`License ${pkg.license}`)
+  logg.i && logg.info(`Version ${pkg.version}`)
+  logg.i && logg.info(`Codename ${pkg.codename}`)
+  logg.i && logg.info(`Environment ${process.env.NODE_ENV}`)
+  logg.t && logg.trace(`Platform ${process.platform} ${process.arch}`)
+  logg.t && logg.trace(`Root path ${process.cwd()}`)
+  logg.t && logg.trace(`Node ${process.version}`)
+  logg.t && logg.trace(`Release ${JSON.stringify(process.release)}`)
+  logg.t && logg.trace(`Versions ${JSON.stringify(process.versions)}`)
+}

package/lib/util/yn.ts

@@ -0,0 +1,19 @@
+'use strict'
+
+export default function yn(value: any, defaultValue: boolean): boolean {
+  if (value === undefined || value === null) {
+    return defaultValue
+  }
+
+  const val = String(value).trim()
+
+  if (/^(?:y|yes|true|1|on)$/i.test(val)) {
+    return true
+  }
+
+  if (/^(?:n|no|false|0|off)$/i.test(val)) {
+    return false
+  }
+
+  return defaultValue || false
+}

package/nodemon.json

@@ -0,0 +1,15 @@
+{
+  "watch": [
+    "lib"
+  ],
+  "verbose": true,
+  "ext": "js,ts,json,jsonc",
+  "ignore": [
+    ".git",
+    "coverage",
+    "dist",
+    "lib/**/*.spec.ts",
+    "node_modules"
+  ],
+  "exec": "ts-node ./lib/index.ts"
+}