@openaddresses/batch-schema 5.0.0 → 7.0.0

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ## Version History
 
+### v7.0.0
+
+- :rocket: Remove PublicError class to it's own package
+- :rocket: `Schema` is now exposed as the default
+
+### v6.0.0
+
+- :rocket: Remove additional properties if they are not present in `res` and `additionalProperties: false` is set
+
+### v5.1.0
+
+- :rocket: Support `URL` in `Schema.load`
+
 ### v5.0.0
 
 - :tada: Logging and body parsing enabled by default

package/index.js

@@ -1,7 +1,3 @@
 import Schema from './lib/schema.js';
-import Err from './lib/error.js';
 
-export {
-    Schema,
-    Err
-};
+export default Schema;

package/lib/middleware.js

@@ -0,0 +1,148 @@
+import Err from '@openaddresses/batch-error';
+import Param from './param.js';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { ValidationError } from 'express-json-validator-middleware';
+
+const ajv = addFormats(new Ajv({
+    allErrors: true,
+    removeAdditional: true
+}));
+
+/**
+ * @class
+ */
+export default class Middleware {
+    /**
+     * Express middleware to identify express params that should be integers/number/booleans
+     * according to the schema and attempt to cast them as such to ensure they pass the schema
+     *
+     * @param {String} match Express Param
+     * @param {String} type Type to coerce it to
+     *
+     * @returns {Function}
+     */
+    static param(match, type) {
+        return function (req, res, next) {
+            try {
+                Param[type](req, match.replace(':', ''));
+            } catch (err) {
+                return Err.respond(err, res);
+            }
+
+            return next();
+        };
+    }
+
+    /**
+     * Express middleware to identify query params that should be integers/booleans according to the schema
+     * and attempt to cast them as such to ensure they pass the schema
+     *
+     * @param {Object} schema JSON Schema
+     *
+     * @returns {Function}
+     */
+    static query(schema) {
+        return function (req, res, next) {
+            for (const key in req.query) {
+                if (!schema.properties[key] || !schema.properties[key].type) continue;
+
+                // For easier processing use consistent array format IE: `type: ["integer", "boolean"]` vs type: "integer"
+                if (!Array.isArray(schema.properties[key].type)) {
+                    schema.properties[key].type = [schema.properties[key].type];
+                }
+
+                for (const type of schema.properties[key].type) {
+                    if (type === 'array') {
+                        req.query[key] = req.query[key].split(',');
+
+                        if (schema.properties[key].items && schema.properties[key].items.type === 'number') {
+                            req.query[key] = req.query[key].map((k) => {
+                                return Number(k);
+                            });
+                        } else if (schema.properties[key].items && schema.properties[key].items.type === 'integer') {
+                            req.query[key] = req.query[key].map((k) => {
+                                return parseInt(k);
+                            });
+                        } else if (schema.properties[key].items && schema.properties[key].items.type === 'boolean') {
+                            req.query[key] = req.query[key].map((k) => {
+                                if (k === 'true') {
+                                    return true;
+                                } else if (k === 'false') {
+                                    return false;
+                                }
+                            });
+                        }
+                    } else if (type === 'integer' && !isNaN(parseInt(req.query[key]))) {
+                        req.query[key] = parseInt(req.query[key]);
+                    } else if (type === 'number' && !isNaN(Number(req.query[key]))) {
+                        req.query[key] = Number(req.query[key]);
+                    } else if (type === 'boolean') {
+                        if (req.query[key] === 'true') {
+                            req.query[key] = true;
+                        } else if (req.query[key] === 'false') {
+                            req.query[key] = false;
+                        }
+                    }
+                }
+            }
+
+            for (const key in schema.properties) {
+                if (req.query[key] === undefined && schema.properties[key].default !== undefined) {
+                    req.query[key] = schema.properties[key].default;
+                }
+            }
+
+            return next();
+        };
+    }
+
+    /**
+     * Express middleware to validate the response body
+     *
+     * @param {Object} schema JSON Schema
+     *
+     * @returns {Function}
+     */
+    static res(schema) {
+        const validate = ajv.compile(schema);
+
+        return function (req, res, next) {
+            const json = res.json;
+            res.json = function(obj) {
+                validate(obj);
+
+                json.call(this, obj);
+            };
+            next();
+        };
+    }
+
+    /**
+     * Convert validation errors into standardized JSON Error Messages
+     *
+     * @returns {Function}
+     */
+    static error() {
+        return function(err, req, res, next) {
+            if (err instanceof ValidationError) {
+                let errs = [];
+                if (err.validationErrors.body) {
+                    errs = errs.concat(err.validationErrors.body);
+                }
+
+                if (err.validationErrors.query) {
+                    errs = errs.concat(err.validationErrors.query);
+                }
+
+                return Err.respond(
+                    new Err(400, null, 'validation error'),
+                    res,
+                    errs
+                );
+            } else {
+                next(err);
+            }
+        };
+    }
+}

package/lib/param.js

@@ -0,0 +1,29 @@
+import Err from '@openaddresses/batch-error';
+
+/**
+ * @class
+ */
+export default class Param {
+    static integer(req, name) {
+        req.params[name] = parseInt(req.params[name]);
+        if (isNaN(req.params[name])) {
+            throw new Err(400, null, `${name} param must be an integer`);
+        }
+    }
+
+    static number(req, name) {
+        req.params[name] = Number(req.params[name]);
+        if (isNaN(req.params[name])) {
+            throw new Err(400, null, `${name} param must be numeric`);
+        }
+    }
+
+    static boolean(req, name) {
+        if (!['true', 'false'].includes(req.params[name])) throw new Error(`${name} param must be a boolean`);
+        req.params[name] = req.params[name] === true ? true : false;
+    }
+
+    static string(req, name) {
+        req.params[name] = String(req.params[name]);
+    }
+}

package/lib/schema.js

@@ -1,41 +1,13 @@
 import { Validator } from 'express-json-validator-middleware';
-import { ValidationError } from 'express-json-validator-middleware';
 import $RefParser from 'json-schema-ref-parser';
 import fs from 'fs';
 import path from 'path';
 import morgan from 'morgan';
 import bodyparser from 'body-parser';
 
-import Err from './error.js';
 import SchemaRoute from '../routes/schema.js';
-
-/**
- * @class
- */
-class Param {
-    static integer(req, name) {
-        req.params[name] = parseInt(req.params[name]);
-        if (isNaN(req.params[name])) {
-            throw new Err(400, null, `${name} param must be an integer`);
-        }
-    }
-
-    static number(req, name) {
-        req.params[name] = Number(req.params[name]);
-        if (isNaN(req.params[name])) {
-            throw new Err(400, null, `${name} param must be numeric`);
-        }
-    }
-
-    static boolean(req, name) {
-        if (!['true', 'false'].includes(req.params[name])) throw new Error(`${name} param must be a boolean`);
-        req.params[name] = req.params[name] === true ? true : false;
-    }
-
-    static string(req, name) {
-        req.params[name] = String(req.params[name]);
-    }
-}
+import Param from './param.js';
+import Middleware from './middleware.js';
 
 /**
  * @class
@@ -89,6 +61,9 @@ export default class Schemas {
      * @param {boolean} opts.silent     Squelch StdOut
      */
     async load(dirpath, config, opts = {}) {
+        if (dirpath instanceof URL) dirpath = dirpath.pathname;
+        else dirpath = String(dirpath);
+
         // Load dynamic routes directory
         for (const r of fs.readdirSync(dirpath)) {
             if (!opts.silent) console.error(`ok - loaded routes/${r}`);
@@ -161,104 +136,28 @@ export default class Schemas {
 
         const flow = [parsed[1], []];
 
-        if (schemas.query) flow[1].push(Schemas.query(schemas.query));
+        if (schemas.query) flow[1].push(Middleware.query(schemas.query));
 
         // Make sure express params are validated/coerced into proper type
         const matches = url.match(/(:.+?)(?=\/|\.|$)/g);
         if (matches) for (const match of matches) {
             if (!schemas[match]) throw new Error(`${match} type is not defined in schema`);
 
-            flow[1].push(Schemas.param(match, schemas[match]));
+            flow[1].push(Middleware.param(match, schemas[match]));
         }
 
         flow[1].push(this.validate(opts));
 
-        return flow;
-    }
-
-    /**
-     * Express middleware to identify express params that should be integers/number/booleans
-     * according to the schema and attempt to cast them as such to ensure they pass the schema
-     *
-     * @param {String} match Express Param
-     * @param {String} type Type to coerce it to
-     *
-     * @returns {Function}
-     */
-    static param(match, type) {
-        return function (req, res, next) {
+        if (schemas.res) flow[1].push(Middleware.res(schemas.res));
 
-            try {
-                Param[type](req, match.replace(':', ''));
-            } catch (err) {
-                return Err.respond(err, res);
-            }
-
-            return next();
-        };
+        return flow;
     }
 
     /**
-     * Express middleware to identify query params that should be integers/booleans according to the schema
-     * and attempt to cast them as such to ensure they pass the schema
-     *
-     * @param {Object} schema JSON Schema
-     *
-     * @returns {Function}
+     * Convert validation errors into standardized JSON Error Messages
      */
-    static query(schema) {
-        return function (req, res, next) {
-            for (const key in req.query) {
-                if (!schema.properties[key] || !schema.properties[key].type) continue;
-
-                // For easier processing use consistent array format IE: `type: ["integer", "boolean"]` vs type: "integer"
-                if (!Array.isArray(schema.properties[key].type)) {
-                    schema.properties[key].type = [schema.properties[key].type];
-                }
-
-                for (const type of schema.properties[key].type) {
-                    if (type === 'array') {
-                        req.query[key] = req.query[key].split(',');
-
-                        if (schema.properties[key].items && schema.properties[key].items.type === 'number') {
-                            req.query[key] = req.query[key].map((k) => {
-                                return Number(k);
-                            });
-                        } else if (schema.properties[key].items && schema.properties[key].items.type === 'integer') {
-                            req.query[key] = req.query[key].map((k) => {
-                                return parseInt(k);
-                            });
-                        } else if (schema.properties[key].items && schema.properties[key].items.type === 'boolean') {
-                            req.query[key] = req.query[key].map((k) => {
-                                if (k === 'true') {
-                                    return true;
-                                } else if (k === 'false') {
-                                    return false;
-                                }
-                            });
-                        }
-                    } else if (type === 'integer' && !isNaN(parseInt(req.query[key]))) {
-                        req.query[key] = parseInt(req.query[key]);
-                    } else if (type === 'number' && !isNaN(Number(req.query[key]))) {
-                        req.query[key] = Number(req.query[key]);
-                    } else if (type === 'boolean') {
-                        if (req.query[key] === 'true') {
-                            req.query[key] = true;
-                        } else if (req.query[key] === 'false') {
-                            req.query[key] = false;
-                        }
-                    }
-                }
-            }
-
-            for (const key in schema.properties) {
-                if (req.query[key] === undefined && schema.properties[key].default !== undefined) {
-                    req.query[key] = schema.properties[key].default;
-                }
-            }
-
-            return next();
-        };
+    error() {
+        this.router.use(Middleware.error());
     }
 
     /**
@@ -295,32 +194,6 @@ export default class Schemas {
         });
     }
 
-    /**
-     * Convert validation errors into standardized JSON Error Messages
-     */
-    error() {
-        this.router.use((err, req, res, next) => {
-            if (err instanceof ValidationError) {
-                let errs = [];
-                if (err.validationErrors.body) {
-                    errs = errs.concat(err.validationErrors.body);
-                }
-
-                if (err.validationErrors.query) {
-                    errs = errs.concat(err.validationErrors.query);
-                }
-
-                return Err.respond(
-                    new Err(400, null, 'validation error'),
-                    res,
-                    errs
-                );
-            } else {
-                next(err);
-            }
-        });
-    }
-
     /**
      * Return a list of endpoints with schemas
      *

package/package.json

@@ -3,7 +3,7 @@
     "type": "module",
     "root": true,
     "main": "index.js",
-    "version": "5.0.0",
+    "version": "7.0.0",
     "description": "Strongly Validated JSON Schema support for address",
     "repository": "git@github.com:openaddresses/batch-schema",
     "author": "ingalls <nick@ingalls.ca>",
@@ -18,7 +18,9 @@
         "doc": "documentation build index.js -f html -o docs && documentation lint index.js"
     },
     "dependencies": {
+        "@openaddresses/batch-error": "^1.0.1",
         "ajv": "^8.6.3",
+        "ajv-formats": "^2.1.1",
         "body-parser": "^1.20.0",
         "express": "^4.17.1",
         "express-json-validator-middleware": "^3.0.0",

package/routes/schema.js

@@ -1,4 +1,4 @@
-import Err from '../lib/error.js';
+import Err from '@openaddresses/batch-error';
 
 export default async function router(schema) {
     /**

package/schema/res.ListSchema.json

@@ -1,7 +1,6 @@
 {
     "oneOf": [{
         "type": "object",
-        "additionalProperties": false,
         "patternProperties": {
             ".*": {
                 "type": "object",
@@ -10,7 +9,6 @@
                     "query",
                     "res"
                 ],
-                "additionalProperties": false,
                 "properties": {
                     "body": {
                         "type": "boolean",
@@ -34,7 +32,6 @@
             "res",
             "query"
         ],
-        "additionalProperties": false,
         "properties": {
             "body": {
                 "type": ["null", "object"]

package/test/schema.srv.test.js

@@ -1,6 +1,6 @@
 import test from 'tape';
 import express from 'express';
-import { Schema } from '../index.js';
+import Schema from '../index.js';
 
 const app = express();
 const schema = new Schema(express.Router(), {

package/lib/error.js

@@ -1,43 +0,0 @@
-/**
- * @class
- */
-export default class PublicError {
-    constructor(status, err, safe, print = true) {
-        // Wrap postgres errors to ensure stack trace (line nums) are returned
-        if (err && err.severity) err = new Error(err);
-
-        if (print && ![400, 401, 402, 403, 404].includes(status)) console.error(err ? err : 'Error: ' + safe);
-
-        this.status = status;
-        this.err = err;
-        this.safe = safe;
-    }
-
-    static respond(err, res, messages = []) {
-        if (err instanceof PublicError) {
-            res.status(err.status).json({
-                status: err.status,
-                message: err.safe,
-                messages: messages
-            });
-
-        // Duplicate Express supported Error extensions
-        } else if (err instanceof Error && (err.status || err.statusCode)) {
-            res.status(err.status || err.statusCode).json({
-                status: err.status || err.statusCode,
-                message: err.message || 'Generic Error',
-                messages: messages
-            });
-
-        // Handle generic errors
-        } else {
-            console.error(err);
-
-            res.status(500).json({
-                status: 500,
-                message: 'Internal Server Error',
-                messages: messages
-            });
-        }
-    }
-}