@openaddresses/batch-schema 3.1.3 → 4.2.0

package/lib/schema.js

@@ -1,6 +1,8 @@
 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 Err from './error.js';
 import SchemaRoute from '../routes/schema.js';
@@ -35,15 +37,12 @@ class Param {
 
 /**
  * @class
+ *
+ * @param {Object} router Express Router Object
+ * @param {Object} opts Options Object
+ * @param {String} opts.schemas Schemas Path
  */
 export default class Schemas {
-    /**
-     * @constructor
-     *
-     * @param {Object} router Express Router Object
-     * @param {Object} opts Options Object
-     * @param {String} opts.schemas Schemas Path
-     */
     constructor(router, opts = {}) {
         if (!router) throw new Error('Router Param Required');
 
@@ -68,6 +67,23 @@ export default class Schemas {
         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 = {}) {
+        // Load dynamic routes directory
+        for (const r of fs.readdirSync(dirpath)) {
+            if (!opts.silent) console.error(`ok - loaded routes/${r}`);
+            await (await import(path.resolve(dirpath, r))).default(this, config);
+        }
+    }
+
     check(url, schemas, fns) {
         if (typeof url !== 'string') throw new Error('URL should be string');
 
@@ -180,11 +196,13 @@ export default class Schemas {
      */
     static query(schema) {
         return function (req, res, next) {
-            for (const key of Object.keys(req.query)) {
+            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];
+                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 === 'integer' && !isNaN(parseInt(req.query[key]))) {
@@ -203,8 +221,8 @@ export default class Schemas {
                 }
             }
 
-            for (const key of Object.keys(schema.properties)) {
-                if (req.query[key] === undefined && schema.properties[key].default) {
+            for (const key in schema.properties) {
+                if (req.query[key] === undefined && schema.properties[key].default !== undefined) {
                     req.query[key] = schema.properties[key].default;
                 }
             }

package/package.json

@@ -3,27 +3,30 @@
     "type": "module",
     "root": true,
     "main": "index.js",
-    "version": "3.1.3",
+    "version": "4.2.0",
     "description": "Strongly Validated JSON Schema support for address",
     "repository": "git@github.com:openaddresses/batch-schema",
     "author": "ingalls <nick@ingalls.ca>",
     "license": "MIT",
     "private": false,
+    "engines": {
+        "node": ">= 18"
+    },
     "scripts": {
         "test": "tape test/**.test.js",
-        "lint": "eslint index.js lib/**.js routes/**.js test/**.js"
+        "lint": "eslint index.js lib/**.js routes/**.js test/**.js",
+        "doc": "documentation build index.js -f html -o docs && documentation lint index.js"
     },
     "dependencies": {
         "ajv": "^8.6.3",
         "express": "^4.17.1",
-        "express-json-validator-middleware": "^2.2.1",
-        "glob": "^7.2.0",
-        "got": "^11.8.2",
+        "express-json-validator-middleware": "^3.0.0",
+        "glob": "^8.0.0",
         "json-schema-ref-parser": "^9.0.9",
-        "request": "^2.88.2",
         "tape": "^5.3.1"
     },
     "devDependencies": {
+        "documentation": "^13.2.5",
         "eslint": "^8.0.1",
         "eslint-plugin-node": "^11.0.0"
     }

package/test/schema.srv.test.js

@@ -1,7 +1,6 @@
 import test from 'tape';
 import express from 'express';
 import { Schema } from '../index.js';
-import got from 'got';
 
 const app = express();
 const schema = new Schema(express.Router(), {
@@ -24,11 +23,10 @@ test('start', (t) => {
 
 test('GET: api/schema', async (t) => {
     try {
-        const res = await got('http://localhost:2000/api/schema', {
-            validateStatus: false
-        }).json();
+        const res = await fetch('http://localhost:2000/api/schema');
+        const body = await res.json();
 
-        t.deepEquals(res, {
+        t.deepEquals(body, {
             'GET /schema':{
                 body: false,
                 query: true,
@@ -44,22 +42,25 @@ test('GET: api/schema', async (t) => {
 
 test('GET: api/schema?method=FAKE', async (t) => {
     try {
-        await got('http://localhost:2000/api/schema?method=fake');
-        t.fail('4xx status code should throw');
-    } catch (err) {
-        t.deepEquals(JSON.parse(err.response.body), {
+        const res = await fetch('http://localhost:2000/api/schema?method=fake');
+
+        t.notOk(res.ok);
+
+        t.deepEquals(await res.json(), {
             status: 400,
             message: 'validation error',
             messages: [{
                 keyword: 'enum',
-                dataPath: '.method',
+                instancePath: '/method',
                 schemaPath: '#/properties/method/enum',
                 params: {
                     allowedValues: ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'OPTIONS', 'TRACE', 'PATCH']
                 },
-                message: 'should be equal to one of the allowed values'
+                message: 'must be equal to one of the allowed values'
             }]
         });
+    } catch (err) {
+        t.error(err);
     }
 
     t.end();
@@ -67,28 +68,30 @@ test('GET: api/schema?method=FAKE', async (t) => {
 
 test('GET: api/schema?method=GET', async (t) => {
     try {
-        await got('http://localhost:2000/api/schema?method=GET');
-        t.fail('4xx status code should throw');
-    } catch (err) {
-        t.deepEquals(JSON.parse(err.response.body), {
+        const res = await fetch('http://localhost:2000/api/schema?method=GET');
+        t.notOk(res.ok);
+        t.deepEquals(await res.json(), {
             status: 400,
             message: 'url & method params must be used together',
             messages: []
         });
+    } catch (err) {
+        t.error(err);
     }
 
     t.end();
 });
 test('GET: api/schema?url=123', async (t) => {
     try {
-        await got('http://localhost:2000/api/schema?url=123');
-        t.fail('4xx status code should throw');
-    } catch (err) {
-        t.deepEquals(JSON.parse(err.response.body), {
+        const res = await fetch('http://localhost:2000/api/schema?url=123');
+        t.notOk(res.ok);
+        t.deepEquals(await res.json(), {
             status: 400,
             message: 'url & method params must be used together',
             messages: []
         });
+    } catch (err) {
+        t.error(err);
     }
 
     t.end();
@@ -96,10 +99,10 @@ test('GET: api/schema?url=123', async (t) => {
 
 test('GET: api/schema?method=GET&url=/schema', async (t) => {
     try {
-        const res = await got('http://localhost:2000/api/schema?method=GET&url=/schema');
+        const res = await fetch('http://localhost:2000/api/schema?method=GET&url=/schema');
 
-        t.equals(res.statusCode, 200, 'http: 200');
-        t.deepEquals(Object.keys(JSON.parse(res.body)).sort(), ['query', 'body', 'res'].sort());
+        t.equals(res.status, 200, 'http: 200');
+        t.deepEquals(Object.keys(await res.json()).sort(), ['query', 'body', 'res'].sort());
 
     } catch (err) {
         t.error(err, 'no error');