adapt-authoring-auth-local 2.1.0 → 2.2.0

package/lib/LocalAuthModule.js

@@ -1,6 +1,5 @@
 import _ from 'lodash'
 import { AbstractAuthModule } from 'adapt-authoring-auth'
-import apidefs from './apidefs.js'
 import { compare, getRandomHex, validate } from './utils.js'
 import { formatDistanceToNowStrict as toNow } from 'date-fns'
 import PasswordUtils from './PasswordUtils.js'
@@ -20,52 +19,18 @@ class LocalAuthModule extends AbstractAuthModule {
 
   /** @override */
   async setValues () {
+    await super.setValues()
     /** @ignore */ this.userSchema = 'localauthuser'
-    /** @ignore */ this.type = 'local'
-    /** @ignore */ this.routes = [
-      {
-        route: '/invite',
-        handlers: { post: this.inviteHandler.bind(this) },
-        meta: apidefs.invite
-      }, {
-        route: '/registersuper',
-        internal: true,
-        handlers: { post: this.registerSuperHandler.bind(this) },
-        meta: apidefs.registersuper
-      }, {
-        route: '/changepass',
-        handlers: { post: this.changePasswordHandler.bind(this) },
-        meta: apidefs.changepass
-      }, {
-        route: '/forgotpass',
-        handlers: { post: this.forgotPasswordHandler.bind(this) },
-        meta: apidefs.forgotpass
-      }, {
-        route: '/validatepass',
-        handlers: { post: this.validatePasswordHandler.bind(this) },
-        meta: apidefs.validatepass
-      }
-    ]
   }
 
   /** @override */
   async init () {
     await super.init()
-    this.secureRoute('/invite', 'post', ['register:users'])
-    this.secureRoute('/validatepass', 'post', ['read:me'])
-    this.unsecureRoute('/registersuper', 'post')
-    this.unsecureRoute('/changepass', 'post')
-    this.unsecureRoute('/forgotpass', 'post')
-    // add API metadata
-    this.router.routes.find(r => r.route === '/').meta = apidefs.root
-    this.router.routes.find(r => r.route === '/register').meta = apidefs.register
-
-    const users = await this.app.waitForModule('users')
     /**
      * Local reference to the current UsersModule instance for convenience
      * @type {UsersModule}
      */
-    this.users = users
+    this.users = await this.app.waitForModule('users')
   }
 
   /** @override */

package/lib/PasswordUtils.js

@@ -1,7 +1,7 @@
 import { App } from 'adapt-authoring-core'
 import bcrypt from 'bcryptjs'
 import { compare, getRandomHex, validate } from './utils.js'
-import { promisify } from 'util'
+import { promisify } from 'node:util'
 
 /** @ignore */ const passwordResetsCollectionName = 'passwordresets'
 /**

package/lib/utils/compare.js

@@ -1,6 +1,6 @@
 import { App } from 'adapt-authoring-core'
 import bcrypt from 'bcryptjs'
-import { promisify } from 'util'
+import { promisify } from 'node:util'
 
 /**
  * Compares a plain password to a hash

package/lib/utils/getRandomHex.js

@@ -1,5 +1,5 @@
-import crypto from 'crypto'
-import { promisify } from 'util'
+import crypto from 'node:crypto'
+import { promisify } from 'node:util'
 
 /**
  * Creates a random hex string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-auth-local",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Module which implements username/password (local) authentication",
   "homepage": "https://github.com/adapt-security/adapt-authoring-auth-local",
   "license": "GPL-3.0",
@@ -22,7 +22,7 @@
     "adapt-authoring-mailer": "^1.0.2",
     "adapt-authoring-mongodb": "^3.0.0",
     "adapt-authoring-roles": "^1.1.3",
-    "adapt-authoring-server": "^2.0.0",
+    "adapt-authoring-server": "^2.1.0",
     "adapt-authoring-users": "^1.0.2"
   },
   "devDependencies": {

package/routes.json

@@ -0,0 +1,234 @@
+{
+  "type": "local",
+  "routes": [
+    {
+      "route": "/",
+      "override": true,
+      "handlers": { "post": "authenticateHandler" },
+      "meta": {
+        "post": {
+          "summary": "Authenticate with the API",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string", "required": true },
+                    "password": { "type": "string", "required": true },
+                    "persistSession": { "type": "boolean" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": { "204": {} }
+        }
+      }
+    },
+    {
+      "route": "/register",
+      "override": true,
+      "handlers": { "post": "registerHandler" },
+      "meta": {
+        "post": {
+          "summary": "Register a new user",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string", "required": true },
+                    "firstName": { "type": "string", "required": true },
+                    "lastName": { "type": "string", "required": true },
+                    "password": { "type": "string", "required": true },
+                    "roles": {
+                      "type": "array",
+                      "items": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": { "$ref": "#components/schemas/localauthuser" }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/invite",
+      "handlers": { "post": "inviteHandler" },
+      "permissions": { "post": ["register:users"] },
+      "meta": {
+        "post": {
+          "summary": "Invite a new user",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": { "204": {} }
+        }
+      }
+    },
+    {
+      "route": "/registersuper",
+      "internal": true,
+      "handlers": { "post": "registerSuperHandler" },
+      "permissions": { "post": null },
+      "meta": {
+        "post": {
+          "summary": "Register a new super user",
+          "description": "Only one user can be registered in this way, and if a super user already exists the request will fail.",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string", "required": true },
+                    "password": { "type": "string", "required": true }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": { "$ref": "#components/schemas/localauthuser" }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/changepass",
+      "handlers": { "post": "changePasswordHandler" },
+      "permissions": { "post": null },
+      "meta": {
+        "post": {
+          "summary": "Change the password of a user",
+          "description": "Can be used with or without authentication. If authenticated, an email/password combination will be acepted. If unauthenticated, a valid reset token and password must be specified.",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string" },
+                    "password": { "type": "string" },
+                    "token": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": { "204": {} }
+        }
+      }
+    },
+    {
+      "route": "/forgotpass",
+      "handlers": { "post": "forgotPasswordHandler" },
+      "permissions": { "post": null },
+      "meta": {
+        "post": {
+          "summary": "Trigger a password reset",
+          "description": "Generates a password reset and emails this to the user with instructions on updating their password.",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "email": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "$schema": "https://json-schema.org/draft/2020-12/schema",
+                    "type": "object",
+                    "properties": {
+                      "message": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "route": "/validatepass",
+      "handlers": { "post": "validatePasswordHandler" },
+      "permissions": { "post": ["read:me"] },
+      "meta": {
+        "post": {
+          "summary": "Validate password",
+          "description": "Checks that a password passes the required complexity specified in the application's configuration settings.",
+          "requestBody": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$schema": "https://json-schema.org/draft/2020-12/schema",
+                  "type": "object",
+                  "properties": {
+                    "password": { "type": "string", "required": true }
+                  }
+                }
+              }
+            }
+          },
+          "responses": {
+            "200": {
+              "content": {
+                "application/json": {
+                  "schema": {
+                    "$schema": "https://json-schema.org/draft/2020-12/schema",
+                    "type": "object",
+                    "properties": {
+                      "message": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/LocalAuthModule.spec.js

@@ -122,6 +122,12 @@ mock.module('adapt-authoring-auth', {
 
       getConfig (key) { return authlocalConfig[key] }
 
+      async setValues () {
+        this.type = undefined
+        this.routes = undefined
+        this.userSchema = 'user'
+      }
+
       async init () {}
 
       async register (data) { return { _id: 'new-user-id', ...data } }
@@ -215,111 +221,23 @@ describe('LocalAuthModule', () => {
       assert.equal(instance.userSchema, 'localauthuser')
     })
 
-    it('should set type to local', async () => {
-      const instance = new LocalAuthModule()
-      await instance.setValues()
-      assert.equal(instance.type, 'local')
-    })
-
-    it('should define 5 routes', async () => {
-      const instance = new LocalAuthModule()
-      await instance.setValues()
-      assert.equal(instance.routes.length, 5)
-    })
-
-    it('should include the expected route paths', async () => {
-      const instance = new LocalAuthModule()
-      await instance.setValues()
-      const paths = instance.routes.map(r => r.route)
-      assert.deepEqual(paths, ['/invite', '/registersuper', '/changepass', '/forgotpass', '/validatepass'])
-    })
-
-    it('should mark registersuper as internal', async () => {
+    it('should call super.setValues()', async () => {
       const instance = new LocalAuthModule()
       await instance.setValues()
-      const superRoute = instance.routes.find(r => r.route === '/registersuper')
-      assert.equal(superRoute.internal, true)
-    })
-
-    it('should define post handlers for all routes', async () => {
-      const instance = new LocalAuthModule()
-      await instance.setValues()
-      for (const route of instance.routes) {
-        assert.equal(typeof route.handlers.post, 'function')
-      }
-    })
-
-    it('should define meta for all routes', async () => {
-      const instance = new LocalAuthModule()
-      await instance.setValues()
-      for (const route of instance.routes) {
-        assert.ok(route.meta)
-      }
+      // super.setValues() initialises type and routes to undefined;
+      // in production, loadRouteConfig fills them from routes.json
+      assert.equal(instance.type, undefined)
+      assert.equal(instance.routes, undefined)
     })
   })
 
   describe('#init()', () => {
-    it('should secure the invite route', async () => {
-      const instance = new LocalAuthModule()
-      instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
-      await instance.init()
-      assert.ok(secureRouteCalls.some(c => c[0] === '/invite' && c[1] === 'post'))
-    })
-
-    it('should secure the validatepass route with read:me permission', async () => {
-      const instance = new LocalAuthModule()
-      instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
-      await instance.init()
-      const call = secureRouteCalls.find(c => c[0] === '/validatepass')
-      assert.ok(call)
-      assert.deepEqual(call[2], ['read:me'])
-    })
-
-    it('should secure the invite route with register:users permission', async () => {
-      const instance = new LocalAuthModule()
-      instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
-      await instance.init()
-      const call = secureRouteCalls.find(c => c[0] === '/invite')
-      assert.ok(call)
-      assert.deepEqual(call[2], ['register:users'])
-    })
-
-    it('should unsecure registersuper, changepass, and forgotpass routes', async () => {
-      const instance = new LocalAuthModule()
-      instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
-      await instance.init()
-      const unsecuredPaths = unsecureRouteCalls.map(c => c[0])
-      assert.ok(unsecuredPaths.includes('/registersuper'))
-      assert.ok(unsecuredPaths.includes('/changepass'))
-      assert.ok(unsecuredPaths.includes('/forgotpass'))
-    })
-
     it('should set the users property', async () => {
       const instance = new LocalAuthModule()
       instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
       await instance.init()
       assert.equal(instance.users, mockUsers)
     })
-
-    it('should set meta on root and register routes', async () => {
-      const instance = new LocalAuthModule()
-      instance.app = mockApp
-      instance.router = { routes: [{ route: '/', meta: null }, { route: '/register', meta: null }] }
-      await instance.setValues()
-      await instance.init()
-      assert.ok(instance.router.routes.find(r => r.route === '/').meta)
-      assert.ok(instance.router.routes.find(r => r.route === '/register').meta)
-    })
   })
 
   describe('#authenticate()', () => {

package/lib/apidefs.js

@@ -1,195 +0,0 @@
-export default {
-  changepass: {
-    post: {
-      summary: 'Change the password of a user',
-      description: 'Can be used with or without authentication. If authenticated, an email/password combination will be acepted. If unauthenticated, a valid reset token and password must be specified.',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string' },
-                password: { type: 'string' },
-                token: { type: 'string' }
-              }
-            }
-          }
-        }
-      },
-      responses: { 204: {} }
-    }
-  },
-  forgotpass: {
-    post: {
-      summary: 'Trigger a password reset',
-      description: 'Generates a password reset and emails this to the user with instructions on updating their password.',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string' }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          content: {
-            'application/json': {
-              schema: {
-                $schema: 'https://json-schema.org/draft/2020-12/schema',
-                type: 'object',
-                properties: {
-                  message: { type: 'string' }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  invite: {
-    post: {
-      summary: 'Invite a new user',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string' }
-              }
-            }
-          }
-        }
-      },
-      responses: { 204: {} }
-    }
-  },
-  register: {
-    post: {
-      summary: 'Register a new user',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string', required: true },
-                firstName: { type: 'string', required: true },
-                lastName: { type: 'string', required: true },
-                password: { type: 'string', required: true },
-                roles: {
-                  type: 'array',
-                  items: { type: 'string' }
-                }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          content: {
-            'application/json': {
-              schema: { $ref: '#components/schemas/localauthuser' }
-            }
-          }
-        }
-      }
-    }
-  },
-  registersuper: {
-    post: {
-      summary: 'Register a new super user',
-      description: 'Only one user can be registered in this way, and if a super user already exists the request will fail.',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string', required: true },
-                password: { type: 'string', required: true }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          content: {
-            'application/json': {
-              schema: { $ref: '#components/schemas/localauthuser' }
-            }
-          }
-        }
-      }
-    }
-  },
-  root: {
-    post: {
-      summary: 'Authenticate with the API',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                email: { type: 'string', required: true },
-                password: { type: 'string', required: true },
-                persistSession: { type: 'boolean' }
-              }
-            }
-          }
-        }
-      },
-      responses: { 204: {} }
-    }
-  },
-  validatepass: {
-    post: {
-      summary: 'Validate password',
-      description: 'Checks that a password passes the required complexity specified in the application\'s configuration settings.',
-      requestBody: {
-        content: {
-          'application/json': {
-            schema: {
-              $schema: 'https://json-schema.org/draft/2020-12/schema',
-              type: 'object',
-              properties: {
-                password: { type: 'string', required: true }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          content: {
-            'application/json': {
-              schema: {
-                $schema: 'https://json-schema.org/draft/2020-12/schema',
-                type: 'object',
-                properties: {
-                  message: { type: 'string' }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}