Add required in nested prop. It works somehow but it's too fragile (issue #19)

Author: aboutlo

README.md

@@ -34,20 +34,20 @@ const schema = FluentSchema()
     FluentSchema()
       .asString()
       .format(FORMATS.EMAIL)
+      .required()
   )
-  .required()
   .prop(
     'password',
     FluentSchema()
       .asString()
       .minLength(8)
   )
-  .required()
   .prop(
     'role',
     FluentSchema()
       .enum(['ADMIN', 'USER'])
       .default('USER')
+      .required()
   )
   .definition(
     'address',

docs/API.md

@@ -48,7 +48,7 @@ There are no restrictions placed on the values within the array.</p>
 <p><a href="reference">https://json-schema.org/latest/json-schema-validation.html#rfc.section.10.2</a></p>
 </dd>
 <dt><a href="#required">required()</a> ⇒ <code><a href="#FluentSchema">FluentSchema</a></code></dt>
-<dd><p>Required&#39; has to be chained to a property:
+<dd><p>Required has to be chained to a property:
 Examples:</p>
 <ul>
 <li>FluentSchema().prop(&#39;prop&#39;).required()</li>
@@ -375,7 +375,7 @@ There are no restrictions placed on the value of this keyword.
 
 ## required() ⇒ [<code>FluentSchema</code>](#FluentSchema)
 
-Required' has to be chained to a property:
+Required has to be chained to a property:
 Examples:
 
 - FluentSchema().prop('prop').required()

src/FluentSchema.integration.test.js

@@ -187,19 +187,23 @@ describe('FluentSchema', () => {
       )
       .prop('username')
       .required()
-      .prop('password')
-      .required()
+      .prop(
+        'password',
+        FluentSchema()
+          .asString()
+          .required()
+      )
       .prop('address')
       .ref('#address')
       .required()
       .prop(
         'role',
         FluentSchema()
           .id('http://foo.com/role')
+          .required()
           .prop('name')
           .prop('permissions')
       )
-      .required()
       .prop('age')
       .asNumber()
       .valueOf()

src/FluentSchema.js

@@ -6,7 +6,9 @@ const {
   isFluentSchema,
   last,
   patchIdsWithParentId,
+  appendRequired,
   FORMATS,
+  REQUIRED,
 } = require('./utils')
 
 const initialState = {
@@ -166,9 +168,24 @@ const FluentSchema = (
     let attributes = props.valueOf()
     const $id =
       attributes.$id || (options.generateIds ? `#${target}/${name}` : undefined)
-    attributes = isFluentSchema(props)
-      ? patchIdsWithParentId({ schema: attributes, parentId: $id, ...options })
-      : attributes
+    if (isFluentSchema(props)) {
+      attributes = patchIdsWithParentId({
+        schema: attributes,
+        parentId: $id,
+        ...options,
+      })
+
+      const [schemaPatched, attributesPatched] = appendRequired({
+        schema,
+        attributes: {
+          ...attributes,
+          name,
+        },
+      })
+
+      schema = schemaPatched
+      attributes = attributesPatched
+    }
 
     const {
       type = hasCombiningKeywords(attributes) ? undefined : 'string',
@@ -270,7 +287,7 @@ const FluentSchema = (
                 // object
                 maxProperties !== undefined ? { maxProperties } : undefined,
                 minProperties !== undefined ? { minProperties } : undefined,
-                required !== undefined ? { required } : undefined,
+                required && required.length > 0 ? { required } : undefined,
                 properties !== undefined ? { properties } : undefined,
                 patternProperties !== undefined
                   ? { patternProperties }
@@ -326,7 +343,7 @@ const FluentSchema = (
   },
 
   /**
-   * Required' has to be chained to a property:
+   * Required has to be chained to a property:
    * Examples:
    * - FluentSchema().prop('prop').required()
    * - FluentSchema().prop('prop', FluentSchema().asNumber()).required()
@@ -337,12 +354,11 @@ const FluentSchema = (
 
   required: () => {
     const currentProp = last(schema.properties)
-    if (!currentProp)
-      throw new Error(
-        "'required' has to be chained to a prop: \nExamples: \n- FluentSchema().prop('prop').required() \n- FluentSchema().prop('prop', FluentSchema().asNumber()).required()"
-      )
+    const required = currentProp
+      ? [...schema.required, currentProp.name]
+      : [REQUIRED]
     return FluentSchema({
-      schema: { ...schema, required: [...schema.required, currentProp.name] },
+      schema: { ...schema, required },
       options,
     })
   },

src/FluentSchema.test.js

@@ -380,14 +380,74 @@ describe('FluentSchema', () => {
         ).toEqual([prop])
       })
 
-      it('invalid', () => {
-        expect(() => {
-          FluentSchema()
-            .asString()
-            .required()
-        }).toThrow(
-          "'required' has to be chained to a prop: \nExamples: \n- FluentSchema().prop('prop').required() \n- FluentSchema().prop('prop', FluentSchema().asNumber()).required()"
-        )
+      it('nested', () => {
+        const prop = 'foo'
+        const schema = FluentSchema()
+          .prop(
+            prop,
+            FluentSchema()
+              .asNumber()
+              .required()
+          )
+          .valueOf()
+        expect(schema.required).toEqual([prop])
+        expect(schema.properties[prop]).toEqual({ type: 'number' })
+      })
+
+      it('deep nested', () => {
+        const prop = 'foo'
+        const schema = FluentSchema()
+          .prop(
+            prop,
+            FluentSchema()
+              .required()
+              .prop('bar')
+              .required()
+          )
+          .valueOf()
+        expect(schema).toEqual({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          properties: {
+            foo: {
+              properties: { bar: { type: 'string' } },
+              required: ['bar'],
+              type: 'object',
+            },
+          },
+          required: ['foo'],
+          type: 'object',
+        })
+      })
+
+      it('multiple deep nested', () => {
+        const schema = FluentSchema()
+          .prop(
+            'foo',
+            FluentSchema()
+              .required()
+              .prop('bar')
+              .required()
+          )
+          .prop(
+            'prop',
+            FluentSchema()
+              .asString()
+              .required()
+          )
+          .valueOf()
+        expect(schema).toEqual({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          properties: {
+            foo: {
+              properties: { bar: { type: 'string' } },
+              required: ['bar'],
+              type: 'object',
+            },
+            prop: { type: 'string' },
+          },
+          required: ['foo', 'prop'],
+          type: 'object',
+        })
       })
     })
 

src/example.js

@@ -11,15 +11,15 @@ const userSchema = FluentSchema()
     FluentSchema()
       .asString()
       .format(FORMATS.EMAIL)
+      .required()
   )
-  .required()
   .prop(
     'password',
     FluentSchema()
       .asString()
       .minLength(8)
+      .required()
   )
-  .required()
   .prop(
     'role',
     FluentSchema()

src/utils.js

@@ -39,6 +39,8 @@ const flat = array =>
     }
   }, {})
 
+const REQUIRED = Symbol('required')
+
 const RELATIVE_JSON_POINTER = 'relative-json-pointer'
 const JSON_POINTER = 'json-pointer'
 const UUID = 'uuid'
@@ -96,13 +98,47 @@ const patchIdsWithParentId = ({ schema, generateIds, parentId }) => {
   }
 }
 
+const appendRequired = ({
+  attributes: { name, required, ...attributes },
+  schema,
+}) => {
+  const { schemaRequired, attributeRequired } = (required || []).reduce(
+    (memo, item) => {
+      return item === REQUIRED
+        ? {
+            ...memo,
+            // append prop name to the schema.required
+            schemaRequired: [...memo.schemaRequired, name],
+          }
+        : {
+            ...memo,
+            // propagate required attributes
+            attributeRequired: [...memo.attributeRequired, item],
+          }
+    },
+    { schemaRequired: [], attributeRequired: [] }
+  )
+
+  const schemaPatched = {
+    ...schema,
+    required: [...schema.required, ...schemaRequired],
+  }
+  const attributesPatched = {
+    ...attributes,
+    required: attributeRequired,
+  }
+  return [schemaPatched, attributesPatched]
+}
+
 module.exports = {
   isFluentSchema,
   hasCombiningKeywords,
   last,
   flat,
   omit,
+  REQUIRED,
   deepOmit,
   patchIdsWithParentId,
+  appendRequired,
   FORMATS,
 }