Extend a schema #46 (#47)

* Extend schema #46

Author: aboutlo

README.md

@@ -274,7 +274,31 @@ Output:
 
     {valid: true}
 
+## Extend schema
+
+Normally inheritance with JSON Schema is achieved with `allOf`. However when `.additionalProperties(false)` is used the validator won't
+understand which properties come from the base schema. `S.extend` creates a schema merging the base into the new one so
+that the validator knows all the properties because it's evaluating only a single schema.
+For example in a CRUD API `POST /users` could use the `userBaseSchema` rather than `GET /users` or `PATCH /users` use the `userSchema`
+which contains the `id`, `createdAt` and `updatedAt` generated server side.
+
+```js
+const S = require('fluent-schema')
+const userBaseSchema = S.object()
+  .additionalProperties(false)
+  .prop('username', S.string())
+  .prop('password', S.string())
+
+const userSchema = S.extend(userBaseSchema)
+  .prop('id', S.string().format('uuid'))
+  .prop('createdAt', S.string().format('time'))
+  .prop('updatedAt', S.string().format('time'))
+
+console.log(userSchema)
+```
+
 ### Detect Fluent Schema objects
+
 Every Fluent Schema objects contains a boolean `isFluentSchema`. In this way you can write your own utilities that understands the Fluent Schema API and improve the user experience of your tool.
 
 ```js

src/BaseSchema.js

@@ -253,9 +253,7 @@ const BaseSchema = (
    * @private set a property to a type. Use string number etc.
    * @returns {BaseSchema}
    */
-  as: type => {
-    return setAttribute({ schema, ...options }, ['type', type])
-  },
+  as: type => setAttribute({ schema, ...options }, ['type', type]),
 
   /**
    * This validation outcome of this keyword's subschema has no direct effect on the overall validation result.
@@ -363,6 +361,14 @@ const BaseSchema = (
     })
   },
 
+  /**
+   * @private It returns the internal schema data structure
+   * @returns {object}
+   */
+  _getState: () => {
+    return schema
+  },
+
   /**
    * It returns all the schema values
    *

src/FluentSchema.d.ts

@@ -145,6 +145,7 @@ export interface S extends BaseSchema<S> {
   array: () => ArraySchema
   object: () => ObjectSchema
   null: () => NullSchema
+  extend: (schema: ObjectSchema) => ObjectSchema
   //FIXME LS we should return only a MixedSchema
   mixed: <T>(types: TYPE[]) => MixedSchema<T> & any
 }

src/FluentSchema.integration.test.js

@@ -194,7 +194,7 @@ describe('S', () => {
   describe('cloning objects retains boolean', () => {
     const ajv = new Ajv()
     const config = {
-      schema: S.object().prop('foo', S.string().enum(['foo']))
+      schema: S.object().prop('foo', S.string().enum(['foo'])),
     }
     const _config = require('lodash.merge')({}, config)
     expect(config.schema[Symbol.for('fluent-schema-object')]).toBeDefined()
@@ -209,14 +209,14 @@ describe('S', () => {
         properties: {
           foo: {
             type: 'string',
-            enum: ['foo']
-          }
-        }
+            enum: ['foo'],
+          },
+        },
       })
     })
 
     it('valid', () => {
-      const valid = validate({foo: 'foo'})
+      const valid = validate({ foo: 'foo' })
       expect(validate.errors).toEqual(null)
       expect(valid).toBeTruthy()
     })

src/FluentSchema.js

@@ -111,10 +111,10 @@ const S = (
    * @returns {ObjectSchema}
    */
 
-  object: () =>
+  object: baseSchema =>
     ObjectSchema({
       ...options,
-      schema,
+      schema: baseSchema || schema,
       factory: ObjectSchema,
     }).as('object'),
 
@@ -170,6 +170,16 @@ module.exports = {
   string: () => S().string(),
   mixed: types => S().mixed(types),
   object: () => S().object(),
+  extend: schema => {
+    if (!schema) {
+      throw new Error("Schema can't be null or undefined")
+    }
+    if (!schema.isFluentSchema) {
+      throw new Error("Schema isn't FluentSchema type")
+    }
+    const state = schema._getState()
+    return S().object(state)
+  },
   array: () => S().array(),
   boolean: () => S().boolean(),
   integer: () => S().integer(),

src/ObjectSchema.test.js

@@ -550,4 +550,88 @@ describe('ObjectSchema', () => {
       })
     })
   })
+
+  describe('extend', () => {
+    it('extends a simple schema', () => {
+      const base = S.object()
+        .additionalProperties(false)
+        .prop('foo', S.string().minLength(5))
+
+      const extended = S.extend(base).prop('bar', S.number())
+
+      expect(extended.valueOf()).toEqual({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        additionalProperties: false,
+        properties: {
+          foo: {
+            type: 'string',
+            minLength: 5,
+          },
+          bar: {
+            type: 'number',
+          },
+        },
+        type: 'object',
+      })
+    })
+    it('extends a nested schema', () => {
+      const base = S.object()
+        .additionalProperties(false)
+        .prop(
+          'foo',
+          S.object().prop(
+            'id',
+            S.string()
+              .format('uuid')
+              .required()
+          )
+        )
+        .prop('str', S.string().required())
+        .prop('bol', S.boolean().required())
+        .prop('num', S.integer().required())
+
+      const extended = S.extend(base).prop('bar', S.number())
+
+      expect(extended.valueOf()).toEqual({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        additionalProperties: false,
+        properties: {
+          foo: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'string',
+                format: 'uuid',
+              },
+            },
+            required: ['id'],
+          },
+          bar: {
+            type: 'number',
+          },
+          str: {
+            type: 'string',
+          },
+          bol: {
+            type: 'boolean',
+          },
+          num: {
+            type: 'integer',
+          },
+        },
+        required: ['str', 'bol', 'num'],
+        type: 'object',
+      })
+    })
+    it('throws an error if a schema is not provided', () => {
+      expect(() => {
+        S.extend()
+      }).toThrow("Schema can't be null or undefined")
+    })
+    it('throws an error if a schema is not provided', () => {
+      expect(() => {
+        S.extend('boom!')
+      }).toThrow("Schema isn't FluentSchema type")
+    })
+  })
 })

src/example.js

@@ -107,3 +107,16 @@ console.log(validate.errors)
     params: { missingProperty: 'zipcoce' },
     message: 'should have required property \'zipcode\'' } ]
 */
+
+const userBaseSchema = S.object()
+  .additionalProperties(false)
+  .prop('username', S.string())
+  .prop('password', S.string())
+
+const userSchema = S.extend(userBaseSchema)
+  .prop('id', S.string().format('uuid'))
+  .prop('createdAt', S.string().format('time'))
+  .prop('updatedAt', S.string().format('time'))
+  .valueOf()
+
+console.log(userSchema.valueOf())

src/types/index.ts

@@ -51,8 +51,20 @@ const schema = S.object()
   .ifThen(S.object().prop('age', S.string()), S.required(['age']))
   .readOnly()
   .writeOnly(true)
-
   .valueOf()
 
 console.log(JSON.stringify(schema))
 console.log(S.object().isFluentSchema)
+
+const userBaseSchema = S.object()
+  .additionalProperties(false)
+  .prop('username', S.string())
+  .prop('password', S.string())
+
+const userSchema = S.extend(userBaseSchema)
+  .prop('id', S.string().format('uuid'))
+  .prop('createdAt', S.string().format('time'))
+  .prop('updatedAt', S.string().format('time'))
+  .valueOf()
+
+console.log('\n user:', JSON.stringify(userSchema))

src/utils.js

@@ -143,8 +143,8 @@ const setAttribute = ({ schema, ...options }, attribute) => {
   if (currentProp) {
     const { name, ...props } = currentProp
     return options.factory({ schema, ...options }).prop(name, {
-      ...props,
       [key]: value,
+      ...props,
     })
   }
   return options.factory({ schema: { ...schema, [key]: value }, ...options })