json-schema-class

Base Class that includes JSON Schema validations via ajv package.

Installing

npm install json-schema-class --save
Copy

Importing

import {SchemaClass} from 'json-schema-class';
Copy

SchemaClass Public Methods

You should be able to validate the class itself against the current schema draft. You can also store the model data in a class prop and validate it in the constructor/methods/other props. @test {SchemaClass}

It is able create a basic validator class

    // ES6
const Validator = new SchemaClass({
  type: 'string',
});

// Using a valid input
const text = Validator.validate('Input Text');
expect(text).to.equal('Input Text');

// Using an invalid input
expect(() => {
  Validator.validate(1);
}).to.throw(Error);
Copy

It is able to use extends

    class SimpleClass extends SchemaClass {
  constructor(text) {
    super({
      type: 'string',
      enum: ['Text'],
    });

    this.validate(text);
  }
}
expect(SimpleClass).to.exist;

const SimpleModel = new SimpleClass('Text');

expect(SimpleModel).to.exist;
Copy

It is able to create new instances with defaults

    class WithDefaults extends SchemaClass {
  constructor(id) {
    super({
      type: 'object',
      properties: {
        id: {
          type: 'string',
        },
        check: {
          type: 'string',
          default: 'This is a default value',
        },
      },
      required: ['id'],
    });

    this.id = id;

    this.validate(this);
  }
}

// On the import side you can instantiate it like so
const defaultTest = new WithDefaults('1');

// Expect find the class model's id
expect(defaultTest.id).to.exist;

// Any defaults should exist after creating a new instance
expect(defaultTest.check).to.exist;
Copy

It is able to validate the model data

    class BadData extends SchemaClass {
  constructor(id) {
    super({
      type: 'object',
      properties: {
        id: {
          type: 'string',
        },
      },
      required: ['id'],
    });

    /**
     * Do anything you need to do with the data model
     * You can create a custom Model placeholder or
     * validate the class directly like so
     *
     * let model = this;
     *  - or -
     * let model = {}
     */
    const model = this;
    model.id = 1;

    this.validate(model);
  }
}

expect(BadData).to.exist;

expect(() => {
  new BadData(1);
}).to.throw(Error);
Copy

SchemaClass Private Methods

Private methods for the SchemaClass are used to set and get the current schema for the class. Future plans are to expand this to include the caching features of ajv

It is able to get and set the schema

    const myObj = new SchemaClass();

expect(myObj.getSchema).to.exist;

expect(() => {
  myObj.getSchema();
}).to.throw(Error);

expect(myObj.setSchema).to.exist;

expect(() => {
  myObj.setSchema();
}).to.throw(Error);

expect(() => {
  myObj.setSchema({
    type: 'string',
  });
}).to.not.throw(Error);

expect(myObj.schema).to.deep.equal({
  type: 'string',
});

expect(() => {
  myObj.getSchema();
}).to.not.throw(Error);

expect(myObj.getSchema()).to.deep.equal({
  type: 'string',
});
Copy

It is able to get and set a validator

    const myObj = new SchemaClass({
  type: 'string',
});

expect(myObj.getValidator).to.exist;

let test = null;

/**
 * The Validator will fail if setValidator is not triggered
 */
expect(() => {
  test = myObj.getValidator();
}).to.throw(Error);

expect(() => {
  myObj.setValidator();
}).to.not.throw(Error);

expect(() => {
  test = myObj.getValidator();
}).to.not.throw(Error);

expect(test).to.exist;

expect(myObj.schema).to.deep.equal({
  type: 'string',
});

expect(() => {
  myObj.validate('Input Text');
}).to.not.throw(Error);

expect(() => {
  myObj.validate(1);
}).to.throw(Error);

expect(() => {
  myObj.setValidator({
    type: 'number',
  });
}).to.not.throw(Error);

expect(() => {
  myObj.validate('Input Text');
}).to.throw(Error);

expect(() => {
  myObj.validate(1);
}).to.not.throw(Error);

expect(myObj.schema).to.deep.equal({
  type: 'number',
});
Copy