@openaddresses/batch-schema 9.3.0 → 10.0.0

package/lib/middleware.js

@@ -1,159 +0,0 @@
-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';
-import Generic from '@openaddresses/batch-generic';
-
-const ajv = addFormats(new Ajv({
-    strict: false,
-    allErrors: true,
-    useDefaults: true,
-    removeAdditional: true,
-    coerceTypes: 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
-     * and optionally serialize Generic object to JSON
-     *
-     * @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) {
-                if (obj instanceof Generic && typeof obj.serialize === 'function') {
-                    obj = obj.serialize();
-                }
-
-                if (res.statusCode === null || res.statusCode === 200) {
-                    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/openapi.js

@@ -1,96 +0,0 @@
-/**
- * @class
- */
-export default class Docs {
-    constructor(info) {
-        this.base = {
-            openapi: '3.0.3',
-            info: info || {
-                title: 'OpenAPI Schema',
-                version: '1.0.0'
-            },
-            paths: {}
-        };
-    }
-
-    push(parsed, schemas) {
-        let path = [];
-        const method = parsed[0].toLowerCase();
-
-        for (let sec of parsed[1].split('/')) {
-            for (const lit of ['.', '-']) { // These chars are used literally and can't be part of a param name
-                const mini = [];
-                for (const s of sec.split(lit)) {
-                    if (s[0] === ':') mini.push(`{${s}}`);
-                    else mini.push(s);
-                }
-                sec = mini.join(lit);
-            }
-            path.push(sec);
-        }
-        path = path.join('/');
-
-
-        if (!this.base.paths[path]) this.base.paths[path] = {};
-
-        if (this.base.paths[path][method]) throw new Error(`Duplicate Path: ${parsed.join(' ')}`);
-
-        const document = {
-            summary: schemas.description || 'No Description',
-            tags: [schemas.group || 'Default'],
-            parameters: [],
-            responses: {
-                200: {
-                    description: 'Successful Response'
-                }
-            }
-        };
-
-        for (const key in schemas) {
-            if (key[0] === ':') {
-                document.parameters.push({
-                    in: 'path',
-                    name: key,
-                    schema: {
-                        type: schemas[key]
-                    },
-                    required: true
-                });
-            }
-        }
-
-        if (schemas.query && schemas.query.type === 'object') {
-            for (const name in (schemas.query.properties || {})) {
-                const query = schemas.query.properties[name];
-                document.parameters.push({
-                    in: 'query',
-                    name,
-                    schema: query,
-                    required: query.required || (schemas.query.required || []).includes(name),
-                    description: query.description || 'No Description'
-                });
-            }
-        }
-
-        if (schemas.res) {
-            document.responses['200'].content = {
-                'application/json': {
-                    schema: schemas.res
-                }
-            };
-        }
-
-        if (schemas.body) {
-            document.requestBody = {
-                required: true,
-                content: {
-                    'application/json': {
-                        schema: schemas.body
-                    }
-                }
-            };
-        }
-
-        this.base.paths[path][method] = document;
-    }
-}

package/lib/param.js

@@ -1,29 +0,0 @@
-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,254 +0,0 @@
-import { Validator } from 'express-json-validator-middleware';
-import $RefParser from '@apidevtools/json-schema-ref-parser';
-import fs from 'node:fs';
-import path from 'node:path';
-import morgan from 'morgan';
-import bodyparser from 'body-parser';
-
-import SchemaRoute from '../routes/schema.js';
-import Param from './param.js';
-import Docs from './openapi.js';
-import Middleware from './middleware.js';
-
-/**
- * @class
- *
- * @param {Object} router Express Router Object
- * @param {Object} opts Options Object
- * @param {String} opts.schemas Schemas Path
- * @param {boolean|string} [opts.logging=true] disable logging with false
- * @param {number} [opts.limit=50] body size limit in mb
- *
- * @param {URL} [opts.apidoc] apidoc file location
- */
-export default class Schemas {
-    constructor(router, opts = {}) {
-        if (!router) throw new Error('Router Param Required');
-
-        if (!opts.schemas) {
-            this.schemas_path = new URL('../schema/', import.meta.url).pathname;
-        } else {
-            if (opts.schemas instanceof URL) opts.schemas = opts.schemas.pathname;
-            else opts.schemas = String(opts.schemas);
-
-            this.schemas_path = opts.schemas;
-        }
-
-        this.validator = new Validator({
-            removeAdditional: true,
-            useDefaults: true,
-            allErrors: true
-        });
-
-        this.router = router;
-
-        if (opts.morgan !== false) this.router.use(morgan('combined'));
-        this.router.use(bodyparser.urlencoded({ extended: true }));
-        this.jsonparser = bodyparser.json({ limit: `${opts.limit}mb` });
-
-        this.schemas = new Map();
-        this.validate = this.validator.validate;
-
-        this.docs = new Docs();
-    }
-
-    async api() {
-        await SchemaRoute(this);
-    }
-
-    /**
-     * Load routes directory. All .js files in the given directory will be loaded (ES Module)
-     * and the default method run
-     *
-     * @param {String}  dirpath     Directory to load
-     * @param {object}  config      Config Object
-     * @param {Object}  opts        Options Object
-     * @param {boolean} opts.silent     Squelch StdOut
-     */
-    async load(dirpath, config, opts = {}) {
-        if (dirpath instanceof URL) dirpath = dirpath.pathname;
-        else dirpath = String(dirpath);
-
-        const routes = [];
-
-        // Load dynamic routes directory
-        for (const r of fs.readdirSync(dirpath)) {
-            if (!opts.silent) console.log(`ok - loaded routes/${r}`);
-            if (!['.ts', '.js'].includes(path.parse(r).ext)) continue;
-            routes.push((await import(path.resolve(dirpath, r))).default(this, config));
-        }
-
-        await Promise.all(routes);
-    }
-
-    /**
-     * Load a blueprint into the router
-     *
-     * @param {Object}  bp_class    Blueprint Class with blueprint() fn
-     * @param {object}  config      Config Object
-     * @param {Object}  opts        Options Object
-     * @param {boolean} opts.silent     Squelch StdOut
-     */
-    async blueprint(bp_class, config, opts = {}) {
-        if (!opts.silent) console.log(`ok - loaded ${bp_class.name}`);
-        await bp_class.blueprint(this, config);
-    }
-
-    check(url, schemas, fns) {
-        if (typeof url !== 'string') throw new Error('URL should be string');
-
-        if (schemas === null) schemas = {};
-        if (typeof schemas !== 'object') throw new Error('Schemas should be object');
-
-        // 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`);
-            if (!Param[schemas[match]]) throw new Error(`${schemas[match]} is not a supported type for ${match}`);
-        }
-
-        if (!fns.length) throw new Error('At least 1 route function should be defined');
-    }
-
-    async get(url, schemas, ...fns) {
-        this.check(url, schemas, fns);
-        this.router.get(...await this.generic(`GET ${url}`, schemas), ...fns);
-    }
-
-    async delete(url, schemas, ...fns) {
-        this.check(url, schemas, fns);
-        this.router.delete(...await this.generic(`DELETE ${url}`, schemas), ...fns);
-    }
-
-    async post(url, schemas, ...fns) {
-        this.check(url, schemas, fns);
-        this.router.post(...await this.generic(`POST ${url}`, schemas), ...fns);
-    }
-
-    async patch(url, schemas, ...fns) {
-        this.check(url, schemas, fns);
-        this.router.patch(...await this.generic(`PATCH ${url}`, schemas), ...fns);
-    }
-
-    async put(url, schemas, ...fns) {
-        this.check(url, schemas, fns);
-        this.router.put(...await this.generic(`PUT ${url}`, schemas), ...fns);
-    }
-
-    async generic(url, schemas = {}) {
-        if (!schemas) schemas = {};
-
-        const parsed = url.split(' ');
-        if (parsed.length !== 2) throw new Error('schema.generic() must be of format "<VERB> <URL>"');
-
-        for (const type of ['body', 'query', 'res']) {
-            if (!schemas[type]) continue;
-
-            // TODO: Write schemas to a tmp directory so blueprints & main schemas are in the same place
-            if (typeof schemas[type] === 'object') {
-                schemas[`${type}_url`] = null;
-            } else if (typeof schemas[type] === 'string') {
-                schemas[`${type}_url`] = '../schema/' + schemas[type];
-                try {
-                    schemas[type] = await $RefParser.dereference((new URL(`../schema/${schemas[type]}`, import.meta.url)).pathname);
-                } catch (err) {
-                    schemas[type] = await $RefParser.dereference(`${this.schemas_path}/${schemas[type]}`);
-                }
-            } else {
-                throw new Error(`Unsupported Value in ${type} value for ${url}`);
-            }
-        }
-
-        this.docs.push(parsed, schemas);
-
-        this.schemas.set(parsed.join(' '), schemas);
-
-        const opts = {};
-        if (schemas.query) opts.query = schemas.query;
-        if (schemas.body) opts.body = schemas.body;
-
-        const flow = [parsed[1], []];
-
-        if (schemas.body) flow[1].push(this.jsonparser);
-
-        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(Middleware.param(match, schemas[match]));
-        }
-
-        flow[1].push(this.validate(opts));
-
-        if (schemas.res) flow[1].push(Middleware.res(schemas.res));
-
-        return flow;
-    }
-
-    /**
-     * Convert validation errors into standardized JSON Error Messages
-     */
-    error() {
-        this.router.use(Middleware.error());
-    }
-
-    /**
-     * Return all schemas (body, query, etc) for a given method + url
-     *
-     * @param {String} method HTTP Method
-     * @param {String} url URL
-     *
-     * @returns {Object}
-     */
-    query(method, url) {
-        if (!this.schemas.has(`${method} ${url}`)) {
-            return { body: null, schema: null };
-        }
-
-        const schema = JSON.parse(JSON.stringify(this.schemas.get(`${method} ${url}`)));
-        if (!schema.query) schema.query = null;
-        if (!schema.body) schema.body = null;
-        if (!schema.res) schema.res = null;
-
-        return {
-            query: schema.query,
-            body: schema.body,
-            res: schema.res
-        };
-    }
-
-    /**
-     * Catch all for unmatched routes
-     */
-    not_found() {
-        this.router.all('*', (req, res) => {
-            return res.status(404).json({
-                status: 404,
-                message: 'API endpoint does not exist!',
-                messages: []
-            });
-        });
-    }
-
-    /**
-     * Return a list of endpoints with schemas
-     *
-     * @returns {Object}
-     */
-    list() {
-        const lite = {};
-
-        for (const key of this.schemas.keys()) {
-            lite[key] = {
-                body: !!this.schemas.get(key).body,
-                query: !!this.schemas.get(key).query,
-                res: !!this.schemas.get(key).res
-            };
-        }
-
-        return lite;
-    }
-}

package/schema/req.query.ListSchema.json

@@ -1,25 +0,0 @@
-{
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {
-        "method": {
-            "type": "string",
-            "description": "HTTP Verb",
-            "enum": [
-                "GET",
-                "HEAD",
-                "POST",
-                "PUT",
-                "DELETE",
-                "CONNECT",
-                "OPTIONS",
-                "TRACE",
-                "PATCH"
-            ]
-        },
-        "url": {
-            "type": "string",
-            "description": "URLEncoded URL that you want to fetch"
-        }
-    }
-}

package/schema/res.ListSchema.json

@@ -1,47 +0,0 @@
-{
-    "oneOf": [{
-        "type": "object",
-        "patternProperties": {
-            ".*": {
-                "type": "object",
-                "required": [
-                    "body",
-                    "query",
-                    "res"
-                ],
-                "properties": {
-                    "body": {
-                        "type": "boolean",
-                        "description": "Does the request body have a schema"
-                    },
-                    "query": {
-                        "type": "boolean",
-                        "description": "Do the request query params have a schema"
-                    },
-                    "res": {
-                        "type": "boolean",
-                        "description": "Does the response have a schema"
-                    }
-                }
-            }
-        }
-    }, {
-        "type": "object",
-        "required": [
-            "body",
-            "res",
-            "query"
-        ],
-        "properties": {
-            "body": {
-                "type": ["null", "object"]
-            },
-            "res": {
-                "type": ["null", "object"]
-            },
-            "query": {
-                "type": ["null", "object"]
-            }
-        }
-    }]
-}

package/test/schema.test.js

@@ -1,33 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import test from 'tape';
-
-import glob from 'glob';
-import $RefParser from '@apidevtools/json-schema-ref-parser';
-import Ajv from 'ajv';
-
-const ajv = new Ajv({
-    allErrors: true
-});
-
-for (const source of glob.sync('../schema/**/*.json')) {
-    test(`schema/${path.parse(source).base}`, async (t) => {
-        try {
-            const file = fs.readFileSync(source);
-            t.ok(file.length, 'file loaded');
-
-            JSON.parse(file);
-        } catch (err) {
-            t.error(err, 'no JSON errors');
-        }
-
-        try {
-            const schema = await $RefParser.dereference(source);
-
-            ajv.compile(schema);
-        } catch (err) {
-            t.error(err, 'no errors');
-        }
-        t.end();
-    });
-}