@bedrockio/yada 1.0.0

package/babel.config.json

@@ -0,0 +1,17 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "16.13.0"
+        },
+        "loose": true,
+        "modules": "cjs"
+      }
+    ]
+  ],
+  "ignore": [
+    "**/__tests__/*.js"
+  ]
+}

package/jest.config.json

@@ -0,0 +1,5 @@
+{
+  "transformIgnorePatterns": [
+    "/.*/"
+  ]
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bedrockio/yada",
+  "version": "1.0.0",
+  "description": "Validation library inspired by Joi.",
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build": "scripts/build",
+    "lint": "eslint"
+  },
+  "type": "module",
+  "repository": "https://github.com/bedrockio/yada",
+  "author": "Andrew Plummer <plummer.andrew@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "validator": "^13.7.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.19.6",
+    "@babel/preset-env": "^7.19.4",
+    "@bedrockio/prettier-config": "^1.0.2",
+    "eslint": "^8.26.0",
+    "eslint-plugin-bedrock": "^1.0.17",
+    "jest": "^29.2.2",
+    "prettier": "^2.7.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "prettier": "@bedrockio/prettier-config",
+  "volta": {
+    "node": "18.13.0",
+    "yarn": "1.22.19"
+  }
+}

package/scripts/build

@@ -0,0 +1,4 @@
+#!/bin/bash
+rm -rf dist
+babel src -d dist/cjs --delete-dir-on-start
+echo "{ \"type\": \"commonjs\" }" > dist/cjs/package.json

package/src/Schema.js

@@ -0,0 +1,262 @@
+import {
+  isSchemaError,
+  ValidationError,
+  AssertionError,
+  LocalizedError,
+  ArrayError,
+} from './errors';
+
+const INITIAL_TYPES = ['default', 'required', 'type', 'transform'];
+const REQUIRED_TYPES = ['default', 'required'];
+
+export default class Schema {
+  constructor(meta = {}) {
+    this.assertions = [];
+    this.meta = meta;
+  }
+
+  // Public
+
+  required() {
+    return this.clone({ required: true }).assert('required', (val) => {
+      if (val === undefined) {
+        throw new LocalizedError('Value is required.');
+      }
+    });
+  }
+
+  default(value) {
+    return this.clone({ default: value }).assert('default', (val) => {
+      if (val === undefined) {
+        return value;
+      }
+    });
+  }
+
+  custom(...args) {
+    const type = args.length > 1 ? args[0] : 'custom';
+    const fn = args.length > 1 ? args[1] : args[0];
+    if (!type) {
+      throw new Error('Assertion type required.');
+    } else if (!fn) {
+      throw new Error('Assertion function required.');
+    }
+    return this.clone().assert(type, async (val, options) => {
+      return await fn(val, options);
+    });
+  }
+
+  allow(...set) {
+    return this.assertEnum(set, true);
+  }
+
+  reject(...set) {
+    return this.assertEnum(set, false);
+  }
+
+  message(message) {
+    return this.clone({ message });
+  }
+
+  tag(tags) {
+    return this.clone({
+      tags: {
+        ...this.meta.tags,
+        ...tags,
+      },
+    });
+  }
+
+  description(description) {
+    return this.tag({
+      description,
+    });
+  }
+
+  options(options) {
+    return this.clone({ ...options });
+  }
+
+  async validate(value, options = {}) {
+    let details = [];
+
+    options = {
+      root: value,
+      ...options,
+      ...this.meta,
+      original: value,
+    };
+
+    for (let assertion of this.assertions) {
+      if (!assertion.required && value === undefined) {
+        break;
+      }
+      try {
+        const result = await this.runAssertion(assertion, value, options);
+        if (result !== undefined) {
+          value = result;
+        }
+      } catch (error) {
+        if (error instanceof ArrayError) {
+          details = [...details, ...error.details];
+        } else {
+          details.push(error);
+        }
+        if (assertion.halt) {
+          break;
+        }
+      }
+    }
+
+    if (details.length) {
+      const { message = 'Input failed validation.' } = this.meta;
+      throw new ValidationError(message, details);
+    }
+
+    return value;
+  }
+
+  clone(meta) {
+    const clone = Object.create(this.constructor.prototype);
+    clone.assertions = [...this.assertions];
+    clone.meta = { ...this.meta, ...meta };
+    return clone;
+  }
+
+  // Private
+
+  assertEnum(set, allow) {
+    if (set.length === 1 && Array.isArray(set[0])) {
+      set = set[0];
+    }
+    const types = set.map((el) => {
+      if (!isSchema(el)) {
+        el = JSON.stringify(el);
+      }
+      return el;
+    });
+    const msg = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
+    return this.clone({ enum: set }).assert('enum', async (val, options) => {
+      if (val !== undefined) {
+        for (let el of set) {
+          if (isSchema(el)) {
+            try {
+              await el.validate(val, options);
+              return;
+            } catch (error) {
+              continue;
+            }
+          } else if ((el === val) === allow) {
+            return;
+          }
+        }
+        throw new LocalizedError(msg, {
+          types: types.join(', '),
+        });
+      }
+    });
+  }
+
+  assert(type, fn) {
+    this.pushAssertion({
+      halt: INITIAL_TYPES.includes(type),
+      required: REQUIRED_TYPES.includes(type),
+      type,
+      fn,
+    });
+    return this;
+  }
+
+  pushAssertion(assertion) {
+    this.assertions.push(assertion);
+    this.assertions.sort((a, b) => {
+      return this.getSortIndex(a.type) - this.getSortIndex(b.type);
+    });
+  }
+
+  transform(fn) {
+    this.assert('transform', (val, options) => {
+      if (val !== undefined) {
+        return fn(val, options);
+      }
+    });
+    return this;
+  }
+
+  getSortIndex(type) {
+    const index = INITIAL_TYPES.indexOf(type);
+    return index === -1 ? INITIAL_TYPES.length : index;
+  }
+
+  async runAssertion(assertion, value, options = {}) {
+    const { type, fn } = assertion;
+    try {
+      return await fn(value, options);
+    } catch (error) {
+      if (isSchemaError(error)) {
+        throw error;
+      }
+      throw new AssertionError(error.message, type, error);
+    }
+  }
+
+  toOpenApi(extra) {
+    const { required, format, tags, default: defaultValue } = this.meta;
+    return {
+      ...(required && {
+        required: true,
+      }),
+      ...(defaultValue && {
+        default: defaultValue,
+      }),
+      ...(format && {
+        format,
+      }),
+      ...this.enumToOpenApi(),
+      ...tags,
+      ...extra,
+    };
+  }
+
+  enumToOpenApi() {
+    const { enum: allowed } = this.meta;
+    if (allowed?.length) {
+      const type = typeof allowed[0];
+      const allowEnum = allowed.every((entry) => {
+        const entryType = typeof entry;
+        return entryType !== 'object' && entryType === type;
+      });
+      if (allowEnum) {
+        return {
+          type,
+          enum: allowed,
+        };
+      } else {
+        const oneOf = [];
+        for (let entry of allowed) {
+          if (isSchema(entry)) {
+            oneOf.push(entry.toOpenApi());
+          } else {
+            const type = typeof entry;
+            let forType = oneOf.find((el) => {
+              return el.type === type;
+            });
+            if (!forType) {
+              forType = {
+                type,
+                enum: [],
+              };
+              oneOf.push(forType);
+            }
+            forType.enum.push(entry);
+          }
+        }
+        return { oneOf };
+      }
+    }
+  }
+}
+
+export function isSchema(arg) {
+  return arg instanceof Schema;
+}

package/src/TypeSchema.js

@@ -0,0 +1,23 @@
+import Schema from './Schema';
+
+export default class TypeSchema extends Schema {
+  constructor(Class, meta) {
+    const type = Class.name.toLowerCase();
+    super({ type, ...meta });
+  }
+
+  format(name, fn) {
+    return this.clone({ format: name }).assert('format', fn);
+  }
+
+  toString() {
+    return this.meta.type;
+  }
+
+  toOpenApi(extra) {
+    return {
+      type: this.meta.type,
+      ...super.toOpenApi(extra),
+    };
+  }
+}