Updates for staging

.drone.yml

@@ -0,0 +1,237 @@
+kind: pipeline
+type: docker
+name: Test Pipeline
+
+workspace:
+  path: /drone/grow
+
+steps:
+- name: yarn install
+  image: node:latest
+  commands:
+  - yarn install
+- name: Code Style Checks
+  image: node:latest
+  commands:
+  - yarn prettier
+- name: Lint
+  image: node:latest
+  commands:
+  - yarn lint
+- name: Unit Tests
+  image: node:latest
+  commands:
+  - yarn test
+- name: Send Test Status Notification
+  image: plugins/webhook
+  settings:
+    urls: https://lab.mifi.dev/hooks/9p65zpagctgkmndo8nwwm4199r
+    content_type: application/json
+    template: |
+      {
+        "icon_url":"https://emojipedia-us.s3.dualstack.us-west-1.amazonaws.com/thumbs/120/apple/198/freezing-face_1f976.png",
+        "text": "[{{ repo.name }} - Build # {{ build.number }}] Code Quality Checks {{ build.status }} {{#success build.status}}:tada:{{else}}:poop:{{/success}}",
+        "username":"DroneBot"
+      }
+  when:
+    status:
+      - success
+      - failure
+- name: Build
+  image: node:latest
+  commands:
+  - yarn build
+- name: Send Build Status Notifications
+  image: plugins/webhook
+  settings:
+    urls: https://lab.mifi.dev/hooks/9p65zpagctgkmndo8nwwm4199r
+    content_type: application/json
+    template: |
+      {
+        "icon_url":"https://emojipedia-us.s3.dualstack.us-west-1.amazonaws.com/thumbs/120/apple/198/freezing-face_1f976.png",
+        "text": "[{{ repo.name }} - Build # {{ build.number }}] Build package {{ build.status }} {{#success build.status}}:tada:{{else}}:poop:{{/success}}",
+        "username":"DroneBot"
+      }
+  when:
+    status:
+      - success
+      - failure
+
+trigger:
+  branch:
+  - main
+  event:
+  - pull_request
+  - push
+
+---
+kind: pipeline
+type: docker
+name: Publish Pipeline
+group: publish
+
+workspace:
+  path: /drone/grow
+
+steps:
+- name: Build Package
+  image: node:latest
+  commands:
+    - yarn install
+    - yarn build
+- name: Publish NPM
+  image: plugins/npm
+  failure: ignore
+  settings:
+    username:
+      from_secret: registry_username
+    password:
+      from_secret: registry_password
+    registry: https://git.mifi.dev/api/packages/mifi/npm
+    token:
+    - from_secret: gitea_token
+  volumes:
+  - name: npmrc
+    path: /drone/grow/.npmrc
+- name: Report NPM Publish Status
+  image: plugins/webhook
+  settings:
+    urls: https://lab.mifi.dev/hooks/ccw34hdf7tgbjmzp96nptn938r
+    content_type: application/json
+    template: |
+      {
+        "icon_url":"https://emojipedia-us.s3.dualstack.us-west-1.amazonaws.com/thumbs/120/apple/198/freezing-face_1f976.png",
+        "text": "[{{ repo.name }} - New npm package release {{tag}} from # {{ build.number }}] Deploy {{ build.status }} {{#success build.status}}:tada:{{else}}:poop:{{/success}}",
+        "username":"DroneBot"
+      }
+  when:
+    status:
+      - success
+      - failure
+- name: Publish Image
+  image: docker
+  commands:
+    - docker build -f docker-compose.staging.yml -t git.mifi.dev/mifi/mifi/auth:latest .
+    - docker push git.mifi.dev/mifi/mifi/auth:latest
+  volumes:
+  - name: dockersock
+    path: /var/run/docker.sock
+  - name: dockerconfig
+    path: /drone/grow/.docker/config.json
+# - name: Publish Image
+#   image: plugins/docker
+#   settings:
+#     auto_tag: true
+#     squash: true
+#     repo: git.mifi.dev/mifi/auth
+#     context: mifi
+#     registry: git.mifi.dev
+#     username:
+#       from_secret: registry_username
+#     password:
+#       from_secret: registry_password
+#     ssh-agent-key:
+#       from_secret: gitea_token
+  volumes:
+  - name: dockersock
+    path: /var/run/docker.sock
+  - name: dockerconfig
+    path: /drone/grow/.docker/config.json
+- name: Report Image Publish Status
+  image: plugins/webhook
+  settings:
+    urls: https://lab.mifi.dev/hooks/ccw34hdf7tgbjmzp96nptn938r
+    content_type: application/json
+    template: |
+      {
+        "icon_url":"https://emojipedia-us.s3.dualstack.us-west-1.amazonaws.com/thumbs/120/apple/198/freezing-face_1f976.png",
+        "text": "[{{ repo.name }} - New docker image release {{tag}} from # {{ build.number }}] Deploy {{ build.status }} {{#success build.status}}:tada:{{else}}:poop:{{/success}}",
+        "username":"DroneBot"
+      }
+  when:
+    status:
+      - success
+      - failure
+
+volumes:
+- name: dockerconfig
+  host:
+    path: /volume1/docker/dockerconfig.json
+- name: dockersock
+  host:
+    path: /var/run/docker.sock
+- name: npmrc
+  host:
+    path: /volume1/docker/beethoven/labs-auth/.npmrc
+
+depends_on:
+  - Test Pipeline
+
+trigger:
+  branch:
+  - main
+  event:
+  - push
+  - tag
+
+---
+kind: pipeline
+type: docker
+name: Deploy Pipeline
+
+workspace:
+  path: /drone/grow
+
+steps:
+- name: Deploy Container
+  image: docker
+  privileged: true
+  commands:
+    - docker compose -f docker-compose.staging.yml pull
+    - docker compose -f docker-compose.staging.yml build --no-cache
+    - docker compose -f docker-compose.staging.yml rm --stop
+    - docker compose -f docker-compose.staging.yml up --wait
+  volumes:
+  - name: env
+    path: /drone/grow/staging.env
+  - name: dockersock
+    path: /var/run/docker.sock
+  - name: dockerconfig
+    path: /drone/grow/.docker/config.json
+- name: Send Status Notifications
+  image: plugins/webhook
+  privileged: true
+  settings:
+    urls: https://lab.mifi.dev/hooks/ccw34hdf7tgbjmzp96nptn938r
+    content_type: application/json
+    template: |
+      {
+        "icon_url":"https://emojipedia-us.s3.dualstack.us-west-1.amazonaws.com/thumbs/120/apple/198/freezing-face_1f976.png",
+        "text": "[{{ repo.name }} - Build # {{ build.number }}] Deploy {{ build.status }} {{#success build.status}}:tada:{{else}}:poop:{{/success}}",
+        "username":"DroneBot"
+      }
+  when:
+    status:
+      - success
+      - failure
+
+volumes:
+- name: dockerconfig
+  host:
+    path: /volume1/docker/dockerconfig.json
+- name: dockersock
+  host:
+    path: /var/run/docker.sock
+- name: env
+  host:
+    path: /volume1/docker/beethoven/labs-auth/staging.env
+
+depends_on:
+  - Test Pipeline
+
+trigger:
+  branch:
+  - main
+  event:
+  - push
+  - tag

.eslintrc.js

@@ -0,0 +1,19 @@
+/* eslint-env node */
+module.exports = {
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+        'plugin:import/errors',
+        'plugin:prettier/recommended',
+        'prettier',
+    ],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    settings: {
+        'import/parsers': {
+            '@typescript-eslint/parser': [".ts", ".tsx"],
+        },
+        'import/resolver': 'typescript',
+    },
+    root: true,
+};

.prettierrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parser: 'typescript',
+    printWidth: 120,
+    trailingComma: 'all',
+    tabWidth: 4,
+    singleQuote: true,
+};

Dockerfile

@@ -0,0 +1,28 @@
+# FROM node:20-alpine AS build
+# RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
+# WORKDIR /home/node/app
+# COPY package*.json .
+# COPY dist/lib .
+# USER node
+# RUN yarn install --frozen-lockfile --production
+# COPY --chown=node:node node_modules ./node_modules
+# CMD ["node", "dist/lib/server/index.js"]
+
+FROM node:20-alpine AS build
+WORKDIR /home/node/app
+COPY package*.json ./
+COPY tsconfig.json ./
+COPY lib ./lib
+RUN ls -a
+RUN yarn install
+RUN yarn build:production
+
+## this is stage two , where the app actually runs
+FROM node:20-alpine AS containerize
+WORKDIR /home/node/app
+COPY package*.json ./
+RUN yarn install --frozen-lockfile --production
+COPY --from=0 /home/node/app/dist .
+EXPOSE 9001
+EXPOSE 27017
+CMD ["node","server/index.js"]

babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+        ['@babel/preset-env', { targets: { node: 'current' } }],
+        '@babel/preset-typescript',
+    ],
+};

dev.env

@@ -0,0 +1,31 @@
+HOST=localhost
+PORT=9001
+
+ROUTE_PREFIX=/auth
+
+LOGIN_ROUTE=/login
+RESET_ROUTE=/reset
+
+DB_ADMIN_USERNAME=root
+DB_ADMIN_PASSWORD=password
+DB_USERNAME=user
+DB_PASSWORD=password
+DB_NAME=auth
+
+MONGO_INITDB_ROOT_USERNAME=$DB_ADMIN_USERNAME
+MONGO_INITDB_ROOT_PASSWORD=$DB_ADMIN_PASSWORD
+MONGO_INITDB_DATABASE=$DB_NAME
+
+SESSION_KEY=shjhakjfhfjdshjksdhfdshfhfduyeyb73te4
+
+JWT_AUDIENCE=Grow.io
+JWT_ISSUER=Grow Latch
+JWT_SECRET=Th!sIs a d3v3lopm3nt server SEcr¢T.
+
+LOGIN_VALID_TIME=12H
+RESET_VALID_MINUTES=15
+DEFAULT_TOKEN_DAYS=1
+
+CONTAINER_PREFIX=dev
+SERVICE_NAME=auth-service
+DB_TYPE=mongo

docker-compose.dev.yml

@@ -0,0 +1,32 @@
+version: '3.8'
+
+services:
+    auth-service_mongo:
+        env_file: dev.env
+        container_name: ${CONTAINER_PREFIX:-dev}-auth-service_mongo
+        ports:
+            - 27017:27017
+        networks:
+            - labs-net
+        volumes:
+            - /var/tmp/labs:/data/db
+            - ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
+        restart: unless-stopped
+        image: mongo:latest
+    auth-service:
+        env_file: dev.env
+        build: .
+        container_name: ${CONTAINER_PREFIX:-dev}-auth-service
+        ports:
+            - 9001:9001
+        environment:
+            - DB_HOST=${CONTAINER_PREFIX:-dev}-auth-service_mongo
+        networks:
+            - labs-net
+        restart: unless-stopped
+        image: node:20-alpine
+        depends_on:
+            - auth-service_mongo
+networks:
+    labs-net:
+        name: labs-net

docker-compose.staging.yml

@@ -0,0 +1,36 @@
+version: '3.8'
+
+services:
+    auth-service_mongo:
+        container_name: ${CONTAINER_PREFIX:-mifi}-auth-service_mongo
+        env_file: staging.env
+        networks:
+            - docknet
+        volumes:
+            - '/volume1/docker/labs/auth/mongo:/data/db'
+        restart: unless-stopped
+        image: mongo:latest
+    auth-service:
+        env_file: staging.env
+        build: .
+        container_name: ${CONTAINER_PREFIX:-mifi}-auth-service
+        environment:
+            - DB_HOST=${CONTAINER_PREFIX:-mifi}-auth-service_mongo
+        labels:
+            - 'traefik.enable=true'
+            - 'traefik.http.routers.grow.rule=Host(`${HOST}`) && Path(`${ROUTE_PREFIX}`)'
+            - 'traefik.http.routers.grow.entrypoints=websecure'
+            - 'traefik.http.routers.grow.tls=true'
+            - 'traefik.http.routers.grow.tls.certresolver=letsencrypt'
+            - 'traefik.http.routers.grow.service=grow-service'
+            - 'traefik.http.services.grow-service.loadbalancer.server.port=${PORT}'
+        networks:
+            - docknet
+        restart: unless-stopped
+        image: node:20-alpine
+        depends_on:
+            - auth-service_mongo
+networks:
+    docknet:
+        name: docknet
+        external: true

jest.config.ts

@@ -0,0 +1,195 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+export default {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/75/3cyx0pq133n7gk3ysqf0mj4r0000gn/T/jest_dx",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  // coverageProvider: "babel",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};

lib/auth.ts

@@ -1,16 +0,0 @@
-import passport from 'koa-passport';
-
-import Users from 'grow-db/lib/models/users';
-import { User } from 'grow-db/lib/schemas/user';
-
-passport.serializeUser((user: User, done) => { done(null, user._id); });
-
-passport.deserializeUser(async (id, done) => {
-    const user = await Users.findById(id);
-
-    if (user) {
-        done(null, user);
-    }
-
-    done('user not found', null);
-});

lib/constants/auth.ts

@@ -0,0 +1,8 @@
+export enum Status {
+    ACTIVE,
+    BLOCK_HARD,
+    BLOCK_SOFT,
+    DELETED,
+    INACTIVE,
+    UNVERIFIED,
+}

lib/constants/db.ts

@@ -0,0 +1,5 @@
+export const DB_HOST = process.env.DB_HOST || 'not_set';
+export const DB_PORT = process.env.DB_PORT || 27017;
+export const DB_USERNAME = process.env.DB_USERNAME || 'not_set';
+export const DB_PASSWORD = process.env.DB_PASSWORD || 'not_set';
+export const DB_NAME = process.env.DB_NAME || 'not_set';

lib/constants/env.ts

@@ -0,0 +1,16 @@
+export const PACKAGE_NAME = '@mifi/auth';
+export const PORT = process.env.PORT || 9000;
+
+export const SESSION_KEY = process.env.SESSION_KEY || 'secret-key';
+
+export const JWT_AUDIENCE = process.env.JWT_AUDIENCE || 'mifi.dev';
+export const JWT_ISSUER = process.env.JWT_ISSUER || PACKAGE_NAME;
+export const JWT_SECRET = process.env.JWT_SECRET || 'secret';
+
+export const LOGIN_VALID_TIME = process.env.LOGIN_VALID_TIME || '12H'; // ###D|H|M
+export const RESET_VALID_MINUTES = process.env.RESET_VALID_MINUTES || 24;
+export const DEFAULT_TOKEN_DAYS = process.env.DEFAULT_TOKEN_DAYS || 365;
+
+export const ROUTE_PREFIX = process.env.ROUTE_PREFIX || '/auth';
+export const LOGIN_ROUTE = process.env.LOGIN_ROUTE || '/login';
+export const RESET_ROUTE = process.env.RESET_ROUTE || '/reset';

lib/constants/errors.ts

@@ -0,0 +1,12 @@
+export enum ErrorCodes {
+    RESET_REQUEST_DATA = 'RESET_REQUEST_DATA',
+}
+
+export const ErrorMessages = {
+    [ErrorCodes.RESET_REQUEST_DATA]: 'A valid username and password must be provided',
+};
+
+export const getErrorBody = (code: ErrorCodes) => ({
+    code,
+    message: ErrorMessages[code],
+});

lib/controllers/auth.ts

@@ -1,231 +0,0 @@
-// const errors = require('restify-errors');
-
-// const config = require('../config');
-
-// const handlePassportResponse = (req, res, next) => (err, user, info) => {
-//     if (err) {
-//       return next(err);
-//     }
-
-//     const isVerifiedUser = user &&
-//       user.isRegistrationVerified();
-
-//     if (user && isVerifiedUser) {
-//       return res.send({ ...user.toAuthJSON() });
-//     } else if (user && !isVerifiedUser){
-//       return res.send({
-//         registrationSuccess: true,
-//         nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.'
-//       });
-//     }
-
-//     return res.send(400, info);
-// };
-
-// module.exports = function (server, auth) {
-//   const { passport } = auth;
-
-//   /* Local Auth */
-// 	server.post('/auth', (req, res, next) => {
-//     const { body: { username = null, password = null } = {} } = req;
-
-//     if (!username || !password) {
-//       let errors = {};
-
-//       if (!username) {
-//         errors.username = 'is required';
-//       }
-
-//       if (!password) {
-//         errors.password = 'is required';
-//       }
-
-//       return res.send(422, { errors });
-//     }
-
-//     const callback = handlePassportResponse(req, res, next);
-//     return passport.authenticate('local', { session: false }.then(callback)(req, res, next);
-// 	});
-
-// 	/**
-// 	 * SERVICES
-// 	 */
-
-//   /* Google */
-// 	server.get(
-// 	  '/auth/google',
-// 	  passport.authenticate('google', { scope: 'profile email', session: false }),
-// 	);
-
-// 	server.get(
-// 	  '/auth/google/callback',
-// 	  (req, res, next) => {
-//       const callback = handlePassportResponse(req, res, next);
-//       return passport.authenticate(
-//         'google',
-//         { failureRedirect: '/login' },
-//         callback,
-//       )(req, res, next);
-//     },
-// 	);
-
-//   /* Facebook */
-// 	server.get(
-// 	  '/auth/facebook/login',
-// 	  passport.authenticate('facebook', {
-// 	    scope: ['email', 'public_profile'],
-// 	    session: false,
-// 	  }),
-// 	);
-
-// 	server.get(
-// 	  '/auth/facebook/loggedin',
-// 	  (req, res, next) => {
-//       const callback = handlePassportResponse(req, res, next);
-//       return passport.authenticate(
-//         'facebook',
-//         { failureRedirect: '/login' },
-//         callback,
-//       )(req, res, next);
-// 	  }
-// 	);
-
-// 	server.get(
-// 	  '/auth/facebook/link',
-// 	  auth.secure,
-//     (req, res, next) => {
-//       req.user.record.setLinkCheckBit((err, linkCheckBit) => {
-//         passport.authenticate('facebookLink', {
-//           scope: ['email', 'public_profile'],
-//           session: false,
-//           state: linkCheckbit,
-//         })(req, res, next);
-//       });
-//     },
-// 	);
-//
-// 	server.get(
-// 	  '/auth/facebook/linked',
-// 	  (req, res, next) => {
-// 	    const linkCheckBit = req.query.state;
-//
-//       return passport.authenticate(
-//         'facebook',
-//         { failureRedirect: '/profile' },
-//         (err, profile) => {
-//           if (err) {
-//             return next(err);
-//           }
-//
-//           User.linkFacebookProfile(linkCheckBit, profile, (err, user) => {
-//             if (err) {
-//               return next(err);
-//             }
-//
-//             if (!user) {
-//               return next(err, false, 'Linking the account to Facebook was unsuccessful, please try again.');
-//             }
-//
-//             res.send({
-//               success: true,
-//               info: 'Facerbook account successfully linked',
-//             });
-//           });
-//         },
-//       )(req, res, next);
-// 	  }
-// 	);
-};
-
-import Koa from 'koa';
-import Router from 'koa-router';
-import { StatusCodes } from 'http-status-codes';
-
-import Users from 'grow-db/lib/models/users';
-
-const handlePassportResponse = (ctx: Koa.Context) => (err, user, info) => {
-    if (err) {
-      return next(err);
-    }
-
-    const isVerifiedUser = user &&
-      user.isRegistrationVerified();
-
-    if (user && isVerifiedUser) {
-      return res.send({ ...user.toAuthJSON() });
-    } else if (user && !isVerifiedUser){
-      return res.send({
-        registrationSuccess: true,
-        nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.'
-      });
-    }
-
-    return res.send(400, info);
-};
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/auth',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.get('/', async (ctx: Koa.Context) => {
-    const data = await Customers.find({}).exec();
-    ctx.body = { data };
-});
-
-
-router.get('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findById(ctx.params.customer_id).populate('person').exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { data };
-});
-
-router.delete('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndDelete(ctx.params.customer_id).exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Koa.Context) => {
-    const data = await Customers.create(ctx.body);
-    data.save();
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Koa.Context) => {
-  const { body: { username = null, password = null } = {} } = ctx;
-
-  if (!username || !password) {
-    let errors = {};
-
-    if (!username) {
-      errors.username = 'is required';
-    }
-
-    if (!password) {
-      errors.password = 'is required';
-    }
-
-    ctx.status = StatusCodes.UNPROCESSABLE_ENTITY;
-    ctx.throw(422, { errors });
-  }
-
-  const callback = handlePassportResponse(req, res, next);
-  return passport.authenticate('local', { session: false }, callback)(req, res, next);
-});
-
-
-router.patch('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndUpdate(ctx.params.customer_id);
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});

lib/database/database.connection.ts

@@ -1,11 +0,0 @@
-import mongoose from 'mongoose';
-
-const DB_USER = process.env.DB_USER || 'test';
-const DB_PASS = process.env.DB_PASSWORD || 'test';
-const DB_HOST = process.env.DB_HOST || 'mongodb';
-const DB_PORT = process.env.DB_PORT || 27017;
-const DB_NAME = process.env.DB_NAME || 'auth';
-
-export const connection = mongoose.connect(
-    `${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT}/${DB_NAME}`
-);

lib/db/index.ts

@@ -0,0 +1,5 @@
+import mongoose from 'mongoose';
+
+import { DB_HOST, DB_NAME, DB_PASSWORD, DB_PORT, DB_USERNAME } from '../constants/db';
+
+export const connection = mongoose.connect(`mongodb://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT}/${DB_NAME}`);

lib/db/schema/auth.ts

@@ -0,0 +1,146 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
+
+import { Strategy } from './strategy';
+import { STRATEGIES } from '../../constants/strategies';
+import { TokenProps, verify as verifyJwt } from '../../utils/jwt';
+import { encrypt, verify as verifyPassword } from '../../utils/password';
+import { generateLoginToken, generateResetToken } from '../../utils/tokens';
+import { getPasswordResetPath } from '../../utils/links';
+import { Status } from '../../constants/auth';
+
+export type Auth = {
+    is2FA?: boolean;
+    record: StringSchemaDefinition;
+    username: string;
+};
+
+export type AuthPrivate = Auth & {
+    status: Status;
+    strategies: Types.ArraySubdocument<Strategy>;
+};
+
+export interface AuthMethods {
+    authenticate(password: string): boolean;
+    getAuthStrategy(method?: STRATEGIES): Strategy | false;
+    getResetLink(route: string): Promise<string | undefined>;
+    getResetToken(): Promise<string | undefined>;
+    getToken(props?: Omit<TokenProps, 'sub'> | void): string;
+    isActive(): boolean;
+    setPassword(password: string): Promise<boolean>;
+}
+
+export interface AuthModel extends Model<AuthPrivate, void, AuthMethods> {
+    authenticate(username: string, password?: string): string | false;
+    findByUsername(username: string): Promise<AuthModel & AuthPrivate>;
+    isUsernameAvailable(username: string): Promise<boolean>;
+    findUserForReset(strategy: STRATEGIES, token: string): Promise<Strategy | undefined>;
+    resetPassword(token: string, password: string): Promise<string | false>;
+}
+
+export const AuthSchema = new Schema<AuthPrivate, AuthModel, AuthMethods>(
+    {
+        is2FA: { type: Boolean, default: false },
+        record: { type: Types.ObjectId },
+        strategies: { type: Array<Strategy>, required: true },
+        status: { type: Number, enum: Object.values(Status), default: Status.UNVERIFIED },
+        username: { type: String, required: true, unique: true },
+    },
+    {
+        minimize: true,
+        timestamps: true,
+    },
+);
+
+AuthSchema.methods = {
+    authenticate(password: string) {
+        const strategy = this.getAuthStrategy(STRATEGIES.LOCAL);
+        return !!strategy && verifyPassword(password, strategy.key);
+    },
+
+    getAuthStrategy(method = STRATEGIES.LOCAL) {
+        return this.strategies.filter((strategy: Strategy) => strategy.method === method).pop() || false;
+    },
+
+    getToken(props = {}) {
+        return generateLoginToken(this._id, this.status);
+    },
+
+    async getResetLink(route) {
+        const token = await this.getResetToken();
+        if (token) {
+            const resetUrl = getPasswordResetPath(token);
+            console.log('[sendPasswordReset] resetUrl:', resetUrl);
+            return resetUrl;
+        }
+    },
+
+    async getResetToken() {
+        const { key, token } = generateResetToken(this._id);
+        this.resetCheckBit = key;
+        await this.save().catch(() => undefined);
+        return token;
+    },
+
+    isActive() {
+        return this.status === Status.ACTIVE;
+    },
+
+    async setPassword(password) {
+        const key = encrypt(password);
+        const hasLocalStrategy = !!this.getAuthStrategy(STRATEGIES.LOCAL);
+        const strategy = {
+            key,
+            method: STRATEGIES.LOCAL,
+            resetToken: undefined,
+        };
+
+        if (hasLocalStrategy) {
+            await this.model('User')
+                .findOneAndUpdate(
+                    { _id: this._id, 'strategies.method': STRATEGIES.LOCAL },
+                    { $set: { 'strategies.$': strategy } },
+                    { upsert: true },
+                )
+                .catch();
+            return true;
+        }
+        this.credentials.push(strategy);
+        await this.save().catch(() => false);
+        return true;
+    },
+};
+
+AuthSchema.statics = {
+    authenticate: async function (username, password) {
+        const auth = await this.findByUsername(username);
+        if (auth && auth.authenticate(password)) {
+            return auth.record;
+        }
+        return false;
+    },
+
+    async findByUsername(username) {
+        return this.findOne({ username });
+    },
+
+    async isUsernameAvailable(username) {
+        return !this.findByUsername(username);
+    },
+
+    async resetPassword(token, password) {
+        const decoded = verifyJwt(token);
+        const { sub, key } = decoded as JwtPayload;
+        const auth = await this.findOne({
+            _id: sub,
+            'strategies.resetToken': key,
+        }).catch();
+        if (auth) {
+            await auth.setPassword(password).catch();
+            return auth.getToken();
+        }
+        return false;
+    },
+};
+
+export type AuthSchema = InferSchemaType<typeof AuthSchema>;

lib/db/schema/strategy.ts

@@ -1,5 +1,5 @@
 import { InferSchemaType, Schema, Types } from 'mongoose';
-import { STRATEGIES } from '../constants/strategies';
+import { STRATEGIES } from '../../constants/strategies';
 
 export const Strategy = new Schema(
     {

lib/middleware/errorHandler.ts

@@ -1,13 +0,0 @@
-import { StatusCodes } from "http-status-codes";
-import { Context, Next } from "koa";
-
-export const errorHandler = async (ctx: Context, next: Next) => {
-    try {
-        await next();
-    } catch (error: any) {
-        ctx.status = error.statusCode || error.status || StatusCodes.INTERNAL_SERVER_ERROR;
-        error.status = ctx.status;
-        ctx.body = { error };
-        ctx.app.emit('error', error, ctx);
-    }
-};

lib/schema/auth.ts

@@ -1,134 +0,0 @@
-import { JwtPayload } from 'jsonwebtoken';
-import { Document, InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';
-
-import { Strategy } from './strategy';
-import { STRATEGIES } from '../constants/strategies';
-import { TokenProps, sign, verify as verifyJwt } from '../utils/jwt';
-import { encrypt, verify as verifyPassword } from '../utils/password';
-import { generateResetToken } from '../utils/tokens';
-
-export type Auth = {
-    is2FA?: boolean;
-    record: StringSchemaDefinition;
-    username: string;
-}
-
-export type AuthPrivate = Auth & {
-    strategies: Types.ArraySubdocument<Strategy>;
-}
-
-export interface AuthMethods {
-    authenticate(password: string): boolean;
-    getAuthStrategy(method?: STRATEGIES): Strategy | false;
-    getResetLink(route: string): Promise<string | undefined>;
-    getResetToken(): Promise<string | undefined>;
-    getToken(props?: Omit<TokenProps, 'sub'>): string;
-    setPassword(password: string): Promise<boolean>;
-}
-
-export interface AuthModel extends Model<AuthPrivate, {}, AuthMethods> {
-    authenticate(password: any): boolean;
-    findByUsername(username: string): Promise<AuthModel & AuthPrivate>;
-    isUsernameAvailable(username: string): Promise<boolean>;
-    findUserForReset(strategy: STRATEGIES, token: string): Promise<Strategy | undefined>;
-    resetPassword(token: string, password: string): Promise<boolean>;
-} 
-
-export const AuthSchema = new Schema<AuthPrivate, AuthModel, AuthMethods>(
-    {
-        is2FA: { type: Boolean, default: false },
-        record: { type: Types.ObjectId },
-        strategies: { type: Types.ArraySubdocument<Strategy>, required: true },
-        username: { type: String, required: true, unique: true },
-    },
-    {
-        minimize: true,
-        timestamps: true,
-    },
-);
-
-AuthSchema.methods = {
-    authenticate: function(password: string) {
-        const strategy = this.getAuthStrategy(STRATEGIES.LOCAL);
-        return !!strategy && verifyPassword(password, strategy.key);
-    },
-
-    getAuthStrategy: function(method = STRATEGIES.LOCAL) {
-        return this.strategies.filter((strategy: Strategy) => strategy.method === method).pop() || false;
-    },
-
-    getToken: function(props = {}) {
-        return sign({
-            sub: this._id,
-            ...props,
-        });
-    },
-
-    getResetLink: async function (route) {
-        const resetToken = await this.getResetToken();
-        if (resetToken) {
-            let resetRoute = route;
-            resetRoute = resetRoute.replace(':user_id', this._id);
-            resetRoute = resetRoute.replace(':reset_token?', resetToken);
-            const resetUrl = `${process.env.URL}${resetRoute}`;
-            console.log('[sendPasswordReset] resetUrl:', resetUrl);
-            return resetUrl;
-        }
-    },
-
-    getResetToken: async function () {
-        const { key, token } = generateResetToken(this._id);
-        this.resetCheckBit = key;
-        await this.save().catch(() => undefined);
-        return token;
-    },
-    
-    setPassword: async function (password) {
-        const key = encrypt(password);
-        const hasLocalStrategy = !!this.getAuthStrategy(STRATEGIES.LOCAL);
-        const strategy = {
-            key,
-            method: STRATEGIES.LOCAL,
-            resetToken: undefined,
-        };
-  
-        if (hasLocalStrategy) {
-            await this.model('User').findOneAndUpdate(
-                { _id: this._id, 'strategies.method': STRATEGIES.LOCAL },
-                { $set: { 'strategies.$': strategy } },
-                { upsert: true },
-            ).catch();
-            return true;
-        }
-        this.credentials.push(strategy);
-        await this.save().catch(() => false);
-        return true;
-    },
-};
-
-AuthSchema.statics = {
-    // authenticateAndGetRecordLocator: async function (username, password) {
-    //     const auth = await this.findByUserName(username);
-    //     if (auth && auth.authenticate(password)) {
-    //         return auth?.record;
-    //     }
-    //     return false;
-    // },
-
-    findByUsername: async function (username) {
-        return this.findOne({ username });
-    },
-
-    isUsernameAvailable: async function (username) {
-        return !!!this.findByUsername(username);
-    },
-
-    resetPassword: async function (token, password) {
-        const decoded = verifyJwt(token);
-        const { sub, key } = decoded as JwtPayload;
-        const auth = await this.findOne({ _id: sub, 'strategies.resetToken': key }).catch();
-        return !!auth && auth.setPassword(password);
-    },
-};
-
-export type AuthSchema = InferSchemaType<typeof AuthSchema>;

lib/server.ts

@@ -1,12 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import app from './app';
-import { connection } from './database/database.connection';
-
-const PORT: number = Number(process.env.PORT) || 9000;
-
-connection.then(
-    () => app.listen(PORT),
-    (err) => console.error('ERROR!', err),
-);

lib/server/app.ts

@@ -1,25 +1,30 @@
 import Koa from 'koa';
-import bodyParser from 'koa-bodyparser';
+import bodyparser from 'koa-bodyparser';
 import cookie from 'koa-cookie';
-import passport from 'koa-passport';
 import session from 'koa-session';
 
+import passport from './passport';
 import { performanceLogger, perfromanceTimer } from './middleware/performance';
 import { errorHandler } from './middleware/errorHandler';
+import { authRouter } from './controllers/auth';
+import { SESSION_KEY } from '../constants/env';
 
 const app: Koa = new Koa();
 
 app.use(errorHandler);
 app.use(perfromanceTimer);
 app.use(performanceLogger);
-app.use(bodyParser());
+app.use(bodyparser());
 app.use(cookie());
 
-app.keys = [process.env.SESSION_KEYS as string];
+app.keys = [SESSION_KEY];
 app.use(session({}, app));
 
-app.use(passport.initialize())
-app.use(passport.session())
+app.use(passport.initialize());
+app.use(passport.session());
+
+app.use(authRouter.routes());
+app.use(authRouter.allowedMethods());
 
 // Application error logging.
 app.on('error', console.error);

lib/server/controllers/auth.ts

@@ -0,0 +1,54 @@
+import Koa from 'koa';
+import Router from 'koa-router';
+import { StatusCodes } from 'http-status-codes';
+
+import { ROUTE_PREFIX as prefix, RESET_ROUTE } from '../../constants/env';
+import Auth from '../../db/model/auth';
+import { sign } from '../../utils/jwt';
+import passport from '../passport';
+import { ErrorCodes, getErrorBody } from '../../constants/errors';
+
+const routerOpts: Router.IRouterOptions = { prefix };
+const router: Router = new Router(routerOpts);
+
+router.get('/info', (ctx) => {
+    ctx.body = {
+        service: process.env.SERVICE_NAME,
+    };
+});
+
+router.post('/', async (ctx) => {
+    const data = (await Auth.create(ctx.body)).save();
+    ctx.body = { success: true, data: { ...data, strategies: undefined } };
+});
+
+router.post('/login', async (ctx, next) => {
+    return passport.authenticate('local', (err, user) => {
+        if (user === false) {
+            ctx.body = { token: null };
+            ctx.throw(StatusCodes.UNAUTHORIZED);
+        }
+        ctx.body = { token: sign(user) };
+        return ctx.login(user);
+    })(ctx, next);
+});
+
+router.post(process.env.RESET_ROUTE || RESET_ROUTE, async (ctx, next) => {
+    const { token = null, password = null } = ctx.request.body as { token?: string; password?: string };
+    if (token && password) {
+        const loginToken = await Auth.resetPassword(token, password).catch();
+        ctx.body({ token: loginToken });
+        next();
+    }
+    ctx.body = { success: false, ...getErrorBody(ErrorCodes.RESET_REQUEST_DATA) };
+});
+
+router.patch('/:record', (ctx: Koa.Context) => {
+    const data = Auth.findOneAndUpdate({ record: ctx.params.record });
+    if (!data) {
+        ctx.throw(StatusCodes.NOT_FOUND);
+    }
+    ctx.body = { success: true, data };
+});
+
+export { router as authRouter };

lib/server/index.ts

@@ -0,0 +1,11 @@
+import app from './app';
+import { connection } from '../db';
+import { PORT } from '../constants/env';
+
+connection.then(
+    () => {
+        app.listen(PORT);
+        console.log('LISTENING', process.env);
+    },
+    (err) => console.error('SERVER ERROR!', { err, env: process.env }),
+);

lib/server/middleware/authenication.ts

@@ -0,0 +1,12 @@
+import { Middleware } from 'koa';
+import { LOGIN_ROUTE } from '../../constants/env';
+
+export const authenticated = (): Middleware => {
+    return (ctx, next) => {
+        if (ctx.isAuthenticated()) {
+            return next();
+        } else {
+            ctx.redirect(process.env.LOGIN_ROUTE || LOGIN_ROUTE);
+        }
+    };
+};

lib/server/middleware/errorHandler.ts

@@ -1,5 +1,5 @@
-import { StatusCodes } from "http-status-codes";
-import { Context, Next } from "koa";
+import { StatusCodes } from 'http-status-codes';
+import { Context, Next } from 'koa';
 
 export const errorHandler = async (ctx: Context, next: Next) => {
     try {

lib/server/middleware/performance.ts

@@ -1,13 +1,12 @@
-import { Next } from 'koa';
-import { KoaContext } from '../types/KoaContext';
+import { Context, Next } from 'koa';
 
-export const performanceLogger = async (ctx: KoaContext, next: Next) => {
+export const performanceLogger = async (ctx: Context, next: Next) => {
     await next();
     const rt = ctx.response.get('X-Response-Time');
     console.log(`${ctx.method} ${ctx.url} - ${rt}`);
 };
 
-export const perfromanceTimer = async (ctx: KoaContext, next: Next) => {
+export const perfromanceTimer = async (ctx: Context, next: Next) => {
     const start = Date.now();
     await next();
     const ms = Date.now() - start;

lib/server/passport/index.ts

@@ -0,0 +1,23 @@
+import passport from 'koa-passport';
+
+import Auth from '../../db/model/auth';
+import { Auth as AuthRecord } from '../../db/schema/auth';
+import LocalStrategy from './strategies/local';
+import JwtStrategy from './strategies/jwt';
+
+passport.serializeUser((user, done) => done(null, (user as AuthRecord).record));
+
+passport.deserializeUser(async (id, done) => {
+    const user = await Auth.findOne({ record: id });
+
+    if (user) {
+        done(null, user);
+    }
+
+    done('user not found', null);
+});
+
+passport.use(LocalStrategy);
+passport.use(JwtStrategy);
+
+export default passport;

lib/server/passport/strategies/jwt.ts

@@ -0,0 +1,22 @@
+// eslint-disable-next-line import/named
+import { ExtractJwt, Strategy as JwtStrategy } from 'passport-jwt';
+
+import Auth from '../../../db/model/auth';
+import { JWT_SECRET } from '../../../constants/env';
+
+const opts = {
+    jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+    secretOrKey: JWT_SECRET,
+    issuer: process.env.JWT_ISSUER,
+    audience: process.env.JWT_AUDIENCE,
+};
+
+export default new JwtStrategy(opts, async (jwt_payload, done) => {
+    const auth = await Auth.findOne({ record: jwt_payload.sub }).catch();
+
+    if (auth) {
+        return done(null, auth);
+    }
+
+    return done(null, false);
+});

lib/server/passport/strategies/local.ts

@@ -0,0 +1,17 @@
+// eslint-disable-next-line import/named
+import { Strategy as LocalStrategy } from 'passport-local';
+
+import Auth from '../../../db/model/auth';
+
+export default new LocalStrategy(async (username: string, password: string, done: any) => {
+    const user = await Auth.findOne({
+        where: {
+            username,
+        },
+    }).catch();
+    if (user && user.authenticate(password)) {
+        done(null, user);
+    } else {
+        done(null, false);
+    }
+});

lib/strategies/local.ts

@@ -1,20 +0,0 @@
-import passport from 'koa-passport';
-import { Strategy } from 'passport-local';
-import bcrypt from 'bcrypt';
-
-import Auth from '../model/auth';
-import { AuthSchema } from '../schema/auth';
-
-export const LocalStrategy = passport.use(new Strategy(async (username, password, done) => {
-    const user = await Auth.findOne({
-        where: {
-            username,
-        }
-    }).catch();
-    if (user && user.authenticate(password)) {
-        done(null, user);
-    } else {
-        done(null, false);
-    }
-  }
-));

lib/utils/auth.ts

@@ -1,12 +1,12 @@
-import Auth from '../model/auth';
-import { AuthDocument, AuthModel, AuthPrivate } from '../schema/auth';
+import Auth from '../db/model/auth';
+import { AuthModel, AuthPrivate } from '../db/schema/auth';
 import { sign } from './jwt';
 
 export const getAuthenticationBundle = async (username: string, password: string) => {
     const auth = await Auth.findByUsername(username).catch();
-    const isAuthenticated = !!auth && (auth as AuthModel).authenticate(password);
-    const token = isAuthenticated ? (auth as AuthModel).getToken() : sign();
-    const record = isAuthenticated ? (auth as AuthPrivate).record : null;
+    const isAuthenticated = !!auth && (<AuthModel>auth).authenticate(password);
+    const record = isAuthenticated ? <string>(<AuthPrivate>auth).record : null;
+    const token = sign(record || undefined);
     return {
         record,
         token,

lib/utils/jwt.ts

@@ -1,5 +1,5 @@
-import jwt, { JwtPayload } from 'jsonwebtoken';
-
+import jwt from 'jsonwebtoken';
+import { JWT_AUDIENCE, JWT_ISSUER, JWT_SECRET } from '../constants/env';
 export interface TokenProps {
     aud?: string;
     exp?: number | Date;
@@ -12,20 +12,24 @@ export type SignProps = string | TokenProps | void;
 
 export const sign = (props: SignProps) => {
     const today = new Date();
-    const { sub = null, ...rest }: TokenProps = typeof props === 'string' || typeof props === 'undefined' ? { sub: props || null } : props;
-    let exp = rest.exp; 
+    const { sub = null, ...rest }: TokenProps =
+        typeof props === 'string' || typeof props === 'undefined' ? { sub: props || null } : props;
+    let { exp } = rest;
     if (!exp) {
         exp = new Date(today);
         exp.setDate(today.getDate() + parseInt(process.env.JWT_DAYS_VALID as string));
         exp = exp.getTime() / 1000;
     }
-    return jwt.sign({
-        aud: rest.aud || process.env.JWT_AUDIENCE,
+    return jwt.sign(
+        {
             exp,
-        iat: today.getTime(),
-        iss: rest.iss || process.env.JWT_ISSUER,
             sub,
-    }, process.env.JWT_SECRET || 'secret');
+            aud: rest.aud || JWT_AUDIENCE,
+            iat: today.getTime(),
+            iss: rest.iss || JWT_ISSUER,
+        },
+        JWT_SECRET,
+    );
 };
 
-export const verify = (token: string) => jwt.verify(token, process.env.JWT_SECRET || 'secret');
+export const verify = (token: string) => jwt.verify(token, JWT_SECRET);

lib/utils/links.ts

@@ -0,0 +1,3 @@
+import { RESET_ROUTE, ROUTE_PREFIX } from '../constants/env';
+
+export const getPasswordResetPath = (token: string) => `${ROUTE_PREFIX}${RESET_ROUTE}?t=${token}`;

lib/utils/password.ts

@@ -1,12 +1,12 @@
-import crypto from 'crypto';
+import { pbkdf2Sync, randomBytes } from 'crypto';
 
 export const encrypt = (password: string) => {
-    const salt = crypto.randomBytes(16).toString('hex');
-    const hash = crypto.pbkdf2Sync(password, salt, 10000, 512, 'sha512').toString('hex');
+    const salt = randomBytes(16).toString('hex');
+    const hash = pbkdf2Sync(password, salt, 10000, 512, 'sha512').toString('hex');
     return `${salt}:${hash}`;
 };
 
 export const verify = (test: string, secret: string) => {
     const [salt, hash] = secret.split(':');
-    return crypto.pbkdf2Sync(test, salt, 10000, 512, 'sha512').toString('hex') === hash;
+    return pbkdf2Sync(test, salt, 10000, 512, 'sha512').toString('hex') === hash;
 };

lib/utils/tokens.ts

@@ -1,13 +1,34 @@
 import crypto from 'crypto';
 
-import { sign } from "./jwt";
+import { sign } from './jwt';
+import { LOGIN_VALID_TIME, RESET_VALID_MINUTES } from '../constants/env';
+import { Status } from '../constants/auth';
+
+const parseLoginValid = () => {
+    const [number, unit] = process.env.LOGIN_VALID_TIME || LOGIN_VALID_TIME;
+    return [
+        unit === 'd' ? parseInt(number) : 1,
+        unit === 'h' ? parseInt(number) : (unit === 'm' && 1) || 24,
+        unit === 'm' ? parseInt(number) : 60,
+    ];
+};
+
+export const generateLoginToken = (sub: string, status: Status) => {
+    const [days, hours, mins] = parseLoginValid();
+    return sign({
+        sub,
+        status,
+        exp: Date.now() + days * hours * mins * 60 * 1000,
+    });
+};
 
 export const generateResetToken = (sub: string) => {
+    const hoursValid = <number>(process.env.RESET_VALID_HOURS || RESET_VALID_MINUTES);
     const key = crypto.randomBytes(16).toString('hex');
     const token = sign({
         sub,
         key,
-        exp: (Date.now() + (24 * 60 * 60 * 1000)),
+        exp: Date.now() + hoursValid * 60 * 60 * 1000,
     });
     return { key, token };
 };

mongo-init.js

@@ -0,0 +1,12 @@
+/* eslint-disable no-undef */
+db = db.getSiblingDB(process.env.DB_NAME);
+db.createUser({
+    user: process.env.DB_USERNAME,
+    pwd: process.env.DB_PASSWORD,
+    roles: [
+        {
+            role: 'readWrite',
+            db: process.env.DB_NAME,
+        },
+    ],
+});

nodemon.json

@@ -1,5 +0,0 @@
-{
-    "watch": ["src"],
-    "exec": "yarn run serve",
-    "ext": "ts"
-}

package.json

@@ -1,21 +1,26 @@
 {
-  "name": "@mifi/grow-api",
-  "version": "0.0.1",
-  "main": "server.js",
+  "name": "@mifi/auth",
+  "version": "0.0.27",
   "author": "mifi (Mike Fitzpatrick)",
   "license": "MIT",
   "scripts": {
     "build": "tsc",
-    "lint": "tslint --project tsconfig.json --format stylish",
-    "prettier:fix": "prettier-eslint --eslint-config-path ./.eslintrc.js --write '**/*.ts'",
-    "serve": "ts-node src/server.ts",
-    "start": "nodemon"
+    "build:production": "tsc -p .",
+    "format": "prettier:fix && lint:fix",
+    "lint": "eslint --ext .ts,.tsx lib/",
+    "lint:fix": "eslint --fix --ext .ts,.tsx lib/",
+    "prettier": "prettier --check 'lib/**/*.ts'",
+    "prettier:fix": "prettier --write 'lib/**/*.ts'",
+    "serve": "node dist/lib/server/index.js",
+    "start": "nodemon",
+    "test": "jest --passWithNoTests"
   },
   "devDependencies": {
+    "@babel/core": "^7.21.8",
+    "@babel/preset-env": "^7.21.5",
+    "@babel/preset-typescript": "^7.21.5",
     "@tsconfig/node16": "^1.0.3",
-    "@types/crypto-js": "^4.1.1",
-    "@types/dotenv": "^8.2.0",
-    "@types/http-status-codes": "^1.2.0",
+    "@types/jest": "^29.5.1",
     "@types/jsonwebtoken": "^9.0.1",
     "@types/koa": "^2.13.5",
     "@types/koa-bodyparser": "^4.3.10",
@@ -24,7 +29,6 @@
     "@types/koa-router": "^7.4.4",
     "@types/koa-session": "^5.10.6",
     "@types/luxon": "^3.2.0",
-    "@types/mongoose": "^5.11.97",
     "@types/node": "^18.14.0",
     "@types/passport": "^1.0.12",
     "@types/passport-facebook": "^2.1.11",
@@ -32,20 +36,27 @@
     "@types/passport-google-oauth": "^1.0.42",
     "@types/passport-jwt": "^3.0.8",
     "@types/passport-local": "^1.0.35",
-    "jest": "^29.4.2",
+    "@typescript-eslint/eslint-plugin": "^5.59.2",
+    "@typescript-eslint/parser": "^5.59.2",
+    "babel-jest": "^29.5.0",
+    "eslint": "^8.39.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^15.0.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.0.0",
+    "jest": "^29.5.0",
     "nodemon": "^2.0.20",
     "prettier": "^2.8.4",
     "prettier-eslint": "^15.0.1",
     "prettier-eslint-cli": "^7.1.0",
     "reflect-metadata": "^0.1.13",
     "ts-node": "^10.9.1",
-    "tslint": "^6.1.3",
-    "tslint-config-airbnb": "^5.11.2",
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@mifi/grow-db": "0.0.1",
-    "crypto": "^1.0.1",
+    "@simplewebauthn/server": "^7.2.0",
     "dotenv": "^16.0.3",
     "http-status-codes": "^2.2.0",
     "jsonwebtoken": "^9.0.0",
@@ -61,12 +72,13 @@
     "passport-facebook": "^3.0.0",
     "passport-fido2-webauthn": "^0.1.0",
     "passport-google-oauth": "^2.0.0",
+    "passport-http-bearer": "^1.0.1",
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0"
   },
   "description": "",
   "repository": {
     "type": "git",
-    "url": "https://git.mifi.dev/mifi/grow-api.git"
+    "url": "https://git.mifi.dev/mifi/auth.git"
   }
 }

src/app/app.ts

@@ -1,27 +0,0 @@
-import Koa from 'koa';
-import bodyParser from 'koa-bodyparser';
-import cookie from 'koa-cookie';
-import passport from 'koa-passport';
-import session from 'koa-session';
-
-import { performanceLogger, perfromanceTimer } from '../middleware/performance';
-import { errorHandler } from '../middleware/errorHandler';
-
-const app: Koa = new Koa();
-
-app.use(errorHandler);
-app.use(perfromanceTimer);
-app.use(performanceLogger);
-app.use(bodyParser());
-app.use(cookie());
-
-app.keys = [process.env.SESSION_KEYS as string];
-app.use(session({}, app));
-
-app.use(passport.initialize())
-app.use(passport.session())
-
-// Application error logging.
-app.on('error', console.error);
-
-export default app;

src/auth.ts

@@ -1,16 +0,0 @@
-import passport from 'koa-passport';
-
-import Users from 'grow-db/lib/models/users';
-import { User } from 'grow-db/lib/schemas/user';
-
-passport.serializeUser((user: User, done) => { done(null, user._id); });
-
-passport.deserializeUser(async (id, done) => {
-    const user = await Users.findById(id);
-
-    if (user) {
-        done(null, user);
-    }
-
-    done('user not found', null);
-});

src/controllers/auth.ts

@@ -1,231 +0,0 @@
-// const errors = require('restify-errors');
-
-// const config = require('../config');
-
-// const handlePassportResponse = (req, res, next) => (err, user, info) => {
-//     if (err) {
-//       return next(err);
-//     }
-
-//     const isVerifiedUser = user &&
-//       user.isRegistrationVerified();
-
-//     if (user && isVerifiedUser) {
-//       return res.send({ ...user.toAuthJSON() });
-//     } else if (user && !isVerifiedUser){
-//       return res.send({
-//         registrationSuccess: true,
-//         nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.'
-//       });
-//     }
-
-//     return res.send(400, info);
-// };
-
-// module.exports = function (server, auth) {
-//   const { passport } = auth;
-
-//   /* Local Auth */
-// 	server.post('/auth', (req, res, next) => {
-//     const { body: { username = null, password = null } = {} } = req;
-
-//     if (!username || !password) {
-//       let errors = {};
-
-//       if (!username) {
-//         errors.username = 'is required';
-//       }
-
-//       if (!password) {
-//         errors.password = 'is required';
-//       }
-
-//       return res.send(422, { errors });
-//     }
-
-//     const callback = handlePassportResponse(req, res, next);
-//     return passport.authenticate('local', { session: false }.then(callback)(req, res, next);
-// 	});
-
-// 	/**
-// 	 * SERVICES
-// 	 */
-
-//   /* Google */
-// 	server.get(
-// 	  '/auth/google',
-// 	  passport.authenticate('google', { scope: 'profile email', session: false }),
-// 	);
-
-// 	server.get(
-// 	  '/auth/google/callback',
-// 	  (req, res, next) => {
-//       const callback = handlePassportResponse(req, res, next);
-//       return passport.authenticate(
-//         'google',
-//         { failureRedirect: '/login' },
-//         callback,
-//       )(req, res, next);
-//     },
-// 	);
-
-//   /* Facebook */
-// 	server.get(
-// 	  '/auth/facebook/login',
-// 	  passport.authenticate('facebook', {
-// 	    scope: ['email', 'public_profile'],
-// 	    session: false,
-// 	  }),
-// 	);
-
-// 	server.get(
-// 	  '/auth/facebook/loggedin',
-// 	  (req, res, next) => {
-//       const callback = handlePassportResponse(req, res, next);
-//       return passport.authenticate(
-//         'facebook',
-//         { failureRedirect: '/login' },
-//         callback,
-//       )(req, res, next);
-// 	  }
-// 	);
-
-// 	server.get(
-// 	  '/auth/facebook/link',
-// 	  auth.secure,
-//     (req, res, next) => {
-//       req.user.record.setLinkCheckBit((err, linkCheckBit) => {
-//         passport.authenticate('facebookLink', {
-//           scope: ['email', 'public_profile'],
-//           session: false,
-//           state: linkCheckbit,
-//         })(req, res, next);
-//       });
-//     },
-// 	);
-//
-// 	server.get(
-// 	  '/auth/facebook/linked',
-// 	  (req, res, next) => {
-// 	    const linkCheckBit = req.query.state;
-//
-//       return passport.authenticate(
-//         'facebook',
-//         { failureRedirect: '/profile' },
-//         (err, profile) => {
-//           if (err) {
-//             return next(err);
-//           }
-//
-//           User.linkFacebookProfile(linkCheckBit, profile, (err, user) => {
-//             if (err) {
-//               return next(err);
-//             }
-//
-//             if (!user) {
-//               return next(err, false, 'Linking the account to Facebook was unsuccessful, please try again.');
-//             }
-//
-//             res.send({
-//               success: true,
-//               info: 'Facerbook account successfully linked',
-//             });
-//           });
-//         },
-//       )(req, res, next);
-// 	  }
-// 	);
-};
-
-import Koa from 'koa';
-import Router from 'koa-router';
-import { StatusCodes } from 'http-status-codes';
-
-import Users from 'grow-db/lib/models/users';
-
-const handlePassportResponse = (ctx: Koa.Context) => (err, user, info) => {
-    if (err) {
-      return next(err);
-    }
-
-    const isVerifiedUser = user &&
-      user.isRegistrationVerified();
-
-    if (user && isVerifiedUser) {
-      return res.send({ ...user.toAuthJSON() });
-    } else if (user && !isVerifiedUser){
-      return res.send({
-        registrationSuccess: true,
-        nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.'
-      });
-    }
-
-    return res.send(400, info);
-};
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/auth',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.get('/', async (ctx: Koa.Context) => {
-    const data = await Customers.find({}).exec();
-    ctx.body = { data };
-});
-
-
-router.get('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findById(ctx.params.customer_id).populate('person').exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { data };
-});
-
-router.delete('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndDelete(ctx.params.customer_id).exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Koa.Context) => {
-    const data = await Customers.create(ctx.body);
-    data.save();
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Koa.Context) => {
-  const { body: { username = null, password = null } = {} } = ctx;
-
-  if (!username || !password) {
-    let errors = {};
-
-    if (!username) {
-      errors.username = 'is required';
-    }
-
-    if (!password) {
-      errors.password = 'is required';
-    }
-
-    ctx.status = StatusCodes.UNPROCESSABLE_ENTITY;
-    ctx.throw(422, { errors });
-  }
-
-  const callback = handlePassportResponse(req, res, next);
-  return passport.authenticate('local', { session: false }, callback)(req, res, next);
-});
-
-
-router.patch('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndUpdate(ctx.params.customer_id);
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});

src/controllers/customers.ts

@@ -1,47 +0,0 @@
-import Koa from 'koa';
-import Router from 'koa-router';
-import { StatusCodes } from 'http-status-codes';
-
-import Customers from 'grow-db/lib/models/customers';
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/customers',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.get('/', async (ctx: Koa.Context) => {
-    const data = await Customers.find({}).exec();
-    ctx.body = { data };
-});
-
-router.get('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findById(ctx.params.customer_id).populate('person').exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { data };
-});
-
-router.delete('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndDelete(ctx.params.customer_id).exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Koa.Context) => {
-    const data = await Customers.create(ctx.body);
-    data.save();
-    ctx.body = { success: true, data };
-});
-
-router.patch('/:customer_id', async (ctx: Koa.Context) => {
-    const data = await Customers.findByIdAndUpdate(ctx.params.customer_id);
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});

src/controllers/login.ts

@@ -1,17 +0,0 @@
-import Koa from 'koa';
-import Router from 'koa-router';
-import { StatusCodes } from 'http-status-codes';
-
-import Users from 'grow-db/lib/models/users';
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/login',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.post('/', async (ctx: Koa.Context) => {
-    const data = await Users.create(ctx.body);
-    data.save();
-    ctx.body = { success: true, data };
-});

src/controllers/people.ts

@@ -1,46 +0,0 @@
-import Koa from 'koa';
-import Router from 'koa-router';
-import { StatusCodes } from 'http-status-codes';
-
-import People from 'grow-db/lib/models/people';
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/people',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.get('/', async (ctx: Koa.Context) => {
-    const data = await People.find({}).exec();
-    ctx.body = { data };
-});
-
-router.get('/:person_id', async (ctx: Koa.Context) => {
-    const data = await People.findById(ctx.params.person_id).populate('person').exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { data };
-});
-
-router.delete('/:person_id', async (ctx: Koa.Context) => {
-    const data = await People.findByIdAndDelete(ctx.params.person_id).exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});
-
-router.post('/', async (ctx: Koa.Context) => {
-    const data = await People.create(ctx.body);
-    data.save();
-    ctx.body = { success: true, data };
-});
-
-router.patch('/:person_id', async (ctx: Koa.Context) => {
-    const data = await People.findByIdAndUpdate(ctx.params.person_id);
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});

src/controllers/reset.js

@@ -1,68 +0,0 @@
-const errors = require('restify-errors');
-const jwt = require('jsonwebtoken');
-
-const config = require('../config');
-const User = require('../models/user');
-
-const {
-  api: { url },
-  security: { reset: { route, tokenPlaceholder } },
-} = config;
-
-const routes = {
-  resetWithToken: `${route}/${tokenPlaceholder}([A-Za-z0-9_]+\.{3})`,
-  getTestToken: `${route}/generate`,
-};
-
-module.exports = function (server, auth) {
-	server.get(routes.getTestToken, auth.secure, function (req, res, next) {
-    const { record: user } = req.user;
-    const resetToken = user.generateResetToken();
-    const resetUrl = `${url}${route}/${resetToken}`;
-
-    res.send({ resetToken, resetUrl });
-    next();
-	});
-
-	server.post(routes.resetWithToken, auth.bypass, function (req, res, next) {
-    const { reset_token } = req.params;
-    const { password } = req.body;
-
-    if (!reset_token) {
-      return next(
-        new errors.InvalidContentError('A reset token was not provided.'),
-      );
-    }
-
-    if (!password) {
-      return next(
-        new errors.InvalidContentError('Password cannot be empty.'),
-      );
-    }
-
-    User.verifyTokenAndResetPassword(reset_token, password, (err, user, info) => {
-      if (err) {
-        console.error(err);
-        return next(
-          new errors.InvalidContentError(err),
-        );
-      }
-
-      if (!user) {
-        console.error(err);
-        res.send({
-          success: false,
-          info: 'Password reset failed. ' + info,
-        });
-        return next();
-      }
-
-      res.send({
-        success: true,
-        info: 'Password reset successful.',
-        ...user.toAuthJSON()
-      });
-      next();
-    });
-	});
-};

src/controllers/signup.js

@@ -1,106 +0,0 @@
-const errors = require('restify-errors');
-
-const User = require('../models/user');
-
-module.exports = function (server, auth) {
-  const { passport } = auth;
-
-	server.post('/signup', auth.basic, (req, res, next) => {
-    const { body: { user = null } = {} } = req;
-
-    let errors = {};
-    let errorCount = 0;
-    if (!user) {
-      errors.user = 'is required - can\'t make something from nothing...';
-      errorCount++;
-    }
-
-    if (errorCount) {
-      return res.send(422, { errors });
-    }
-
-    User.register(user, (err, user, info) => {
-      if (err) {
-        next(err);
-      }
-
-      if (info) {
-        res.send(200, {
-          success: false,
-          nextSteps: 'Please fix the problems indicated and try again.',
-          ...info
-        });
-
-        return next();
-      }
-
-      res.send(200, {
-        success: true,
-        nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.',
-      });
-
-      next();
-    });
-	});
-
-	server.get('/signup/validate/email/:email', auth.basic, (req, res, next) => {
-    const email = decodeURI(req.params.email);
-
-    User.findOne({ email }, (err, user) => {
-      if (err) {
-        return next(err);
-      }
-
-      res.send(200, { available: !!!user });
-      next();
-    });
-	});
-
-	server.get('/signup/validate/nom/:nom_de_bid', auth.basic, (req, res, next) => {
-    const nomDeBid = decodeURI(req.params.nom_de_bid);
-
-    User.findOne({ nomDeBid }, (err, user) => {
-      if (err) {
-        return next(err);
-      }
-
-      res.send(200, { available: !!!user });
-      next();
-    });
-	});
-
-  server.post('/signup/verify/resend', auth.basic, (req, res, next) => {
-    const { body: { email = null } = {} } = req;
-
-    User.resendVerificationEmail(email, (err, user, info) =>  {
-      if (err) {
-        next(err);
-      }
-
-      if (!user) {
-        res.send(200, {
-          success: false,
-          nextSteps: 'There was no user located with the email address provided. Please try again.',
-        });
-
-        return next();
-      }
-
-      if (user && info.success) {
-        res.send(200, {
-          success: true,
-          nextSteps: 'Check your email for our confirmation email, you will not be able to login without confirming.',
-        });
-
-        return next();
-      }
-
-      res.send(200, {
-        success: false,
-        nextSteps: 'There was a problem resending the verification email. Please try again later.',
-      });
-
-      next();
-    });
-  });
-};

src/controllers/strains.ts

@@ -1,49 +0,0 @@
-import { Context } from 'koa';
-import Router from 'koa-router';
-import {  } from 'koa-bodyparser';
-import { StatusCodes } from 'http-status-codes';
-
-import Strains from 'grow-db/lib/models/strains';
-import { Strain } from 'grow-db/lib/schemas/strain';
-
-const routerOpts: Router.IRouterOptions = {
-    prefix: '/strains',
-};
-
-const router: Router = new Router(routerOpts);
-
-router.get('/', async (ctx: Context) => {
-    const data = await Strains.find({}).exec();
-    ctx.body = { data };
-});
-
-router.get('/:strain_id', async (ctx) => {
-    const data = await Strains.findById(ctx.params.strain_id).populate('person').exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { data };
-});
-
-router.delete('/:strain_id', async (ctx: Context) => {
-    const data = await Strains.findByIdAndDelete(ctx.params.strain_id).exec();
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});
-
-
-router.post('/', async (ctx: Context) => {
-    const data = await Strains.create(ctx.request.body);
-    data.save();
-    ctx.body = { success: true, data };
-});
-
-router.patch('/:strain_id', async (ctx) => {
-    const data = await Strains.findByIdAndUpdate(ctx.params.strain_id, <Strain>ctx.request.body, { lean: true, returnDocument: 'after' });
-    if (!data) {
-        ctx.throw(StatusCodes.NOT_FOUND);
-    }
-    ctx.body = { success: true, data };
-});

src/database/database.connection.ts

@@ -1,5 +0,0 @@
-import mongoose from 'mongoose';
-
-export const connection = mongoose.connect(
-    `${process.env.DB_USER}:${process.env.DB_PASSWORD}@mongodb:27017/${process.env.DB_NAME}`
-);

src/middleware/performance.ts

@@ -1,15 +0,0 @@
-import { Next } from 'koa';
-import { KoaContext } from '../types/KoaContext';
-
-export const performanceLogger = async (ctx: KoaContext, next: Next) => {
-    await next();
-    const rt = ctx.response.get('X-Response-Time');
-    console.log(`${ctx.method} ${ctx.url} - ${rt}`);
-};
-
-export const perfromanceTimer = async (ctx: KoaContext, next: Next) => {
-    const start = Date.now();
-    await next();
-    const ms = Date.now() - start;
-    ctx.set('X-Response-Time', `${ms}ms`);
-};

src/server.ts

@@ -1,12 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import app from './app/app';
-import { connection } from './database/database.connection';
-
-const PORT: number = Number(process.env.PORT) || 9000;
-
-connection.then(
-    () => app.listen(PORT),
-    (err) => console.error('ERROR!', err),
-);

src/types/KoaContext.ts

@@ -1,12 +0,0 @@
-import { Context, Request } from 'koa';
-
-interface KoaRequest<RequestBody = any> extends Request {
-    body?: RequestBody;
-}
-
-export interface KoaContext<RequestBody = any, ResponseBody = any> extends Context {
-    request: KoaRequest<RequestBody>;
-    body: ResponseBody;
-}
-
-export interface KoaResponseContext<ResponseBody> extends KoaContext<any, ResponseBody> {};

tsconfig.json

@@ -6,7 +6,7 @@
         "emitDecoratorMetadata": true,
         "noImplicitAny": true,
         "outDir": "./dist/",
-        "rootDirs": ["src", "../"],
+        "rootDirs": ["lib"],
         "sourceMap": true
     }
 }

tslint.json

@@ -1,6 +0,0 @@
-{
-    "extends": "tslint-config-airbnb",
-    "rules": {
-      "import-name": false
-    }
-}