Schema Based Validations

[anywhichway]

Schema based validations are being considered. This feature would support the optional use of schema to support object validation, default values, and index specification.

This topic is open for questions, comments, and design thoughts. Give it a thumbs-up if it is important to you.

[mingard]

I have been working on something for this. It consists of:

• Schema config JSON
• Schema builder

Schema config JSON

User schema

{
  "fields": {
    "name": {
      "type": "String"
    },
    "age": {
      "type": "Number"
    },
    "group": {
      "type": "Group"
    }
  }
}

Group schema

{
  "fields": {
    "title": {
      "type": "String"
    },
    "createdAt": {
      "type": "Date"
    }
  }
}

Schema Builder

'use strict'

const fs = require('fs')
const path = require('path')
const _ = require('underscore')
const _s = require('underscore.string')

var classes = {
  String: class extends Field {},
  Object: class extends Field {},
  Array: class extends Field {},
  Number: class extends Field {},
  Date: class extends Field {}
}

const Schemas = function () {
  // Get all schema files
  let schemas = fs.readdirSync(path.join(__dirname, 'schemas'))
  // Iterate schema appending classes
  this.iterateSchemas(schemas)
}

Schemas.prototype.iterateSchemas = function (schemas) {

  Object.assign(classes, ..._.map(schemas, (schema) => {
    let json = this.getSchema(schema)
    return {
      [json.classname]: class {
        constructor (data) {
          if (!_.isUndefined(data)) {
            _.each(json.fields, (field, key) => {
              if (data[key] && classes[field.type]) {
                this[key] = new classes[field.type](data[key]) 
              }
            })
          }
        }
      }
    }
  }))
}

Schemas.prototype.getSchemas = function (schema) {
  let content = fs.readFileSync(path.join(__dirname, 'schemas', schema),'utf8')
  let body = JSON.parse(content)
  return {
    classname: _s.capitalize(path.parse(schema).name),
    fields: body.fields
  }
}

module.exports = function () {
  return new Schemas()
}

Allowing nested validation too, simply with:

let schemas = new Schemas()

new schemas.Users({
  "name": "Joe",
  "age" : 31,
  "group": {
    "title": "My Group",
    "createdAt": 1484833503
  }
})