json-2-joi 2.0.2 → 2.1.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 2.1.0
+
+- Fix the issue that `enum` is only applied to `string` type or when missing type info.
+- Add `strictEnum` and `enableEnum` option.
+- Allow override options when calling `convert` api.
+
 ### 2.0.2
 
 - Remove `min` setting from JOI schema if `minLength` is not defined in JSON schema.

package/README.md

@@ -6,7 +6,7 @@ Converts a JSON schema to a Joi schema for object validation.
 
 ## Change based on the forked version (enjoi):
 
-- Provided `refineDescription(schema)`, `allowNull` options
+- Provided `refineDescription(schema)`, `allowNull`, `strictEnum`, `enableEnum` options
 - Change cycle reference resovling without self-generating id and rely on $id if defined in JSON schema
 - Support `const` keyword in JSON schema
 - Support `example` setting for Joi based on JSON schema's `examples`, `default` or `enum`
@@ -53,7 +53,9 @@ Please file issues for other unsupported features.
 - `refineType(type, format)` - an (optional) function to call to apply to type based on the type and format of the JSON schema.
 - `refineSchema(joiSchema, jsonSchema)` - an (optional) function to call to apply to adjust Joi schema base on the original JSON schema. Primary use case is handling `nullable` flag in OpenAPI 3.0
 - `extensions` - an array of extensions to pass [joi.extend](https://github.com/hapijs/joi/blob/master/API.md#extendextension).
-- `allowNull` - Allows null value when the field is NOT required with a default value of `false`.
+- `allowNull` - Default as `false`.  When `true` and the field has no `enum` setting, `null` value will be allowed.
+- `strictEnum` - Default as `true`.  When `false`, and `allowNull` is `true`, `null` (and empty string additionally for string type) will be added to `enum` list.
+- `enableEnum` - Default as `true`.  When `false`, `enum` restriction will not be added to Joi Schema.
 
 Example:
 
@@ -204,6 +206,64 @@ const lengthSchema = json2Joi.convert({
 });
 ```
 
+#### Override options during conversion
+
+When reusing the Resolver and calling `convert` API, it's possible that different schema might have different requirement.
+
+It's possible to override these options for each conversion:
+
+* refineType
+* refineSchema
+* refineDescription
+* allowNull
+* strictEnum
+* enableEnum
+
+However, the overriden options do not have impact on the `subSchemas` as they are preprocessed during Resolver construction.
+
+```javascript
+const subSchemas = {
+    measurement: {
+        type: 'object',
+        properties: {
+            quantity: {
+                type: 'number',
+                enum: [0, 1]
+            }
+        }
+    }
+};
+const enjoi = Enjoi.resolver({
+    subSchemas,
+    enableEnum: false
+});
+
+const jsonSchema = {
+    type: 'object',
+    properties: {
+        weight: {
+            type: 'object',
+            properties: {
+                quantity: {
+                    type: 'number',
+                    enum: [0, 1]
+                }
+            }
+        },
+        length: {
+            $ref: 'measurement'
+        }
+    }
+};
+
+const schema1 = enjoi.convert(jsonSchema, { enableEnum: true });
+const schema2 = enjoi.convert(jsonSchema);
+
+t.ok(schema1.validate({ weight: { quantity: 2 } }).error, 'follow overridden options');
+t.ok(!schema1.validate({ length: { quantity: 2 } }).error, 'no impact on subschemas');
+t.ok(!schema2.validate({ weight: { quantity: 2 } }).error, 'still use original options');
+```
+
 ### Custom Types
 
 Custom types can be provided through the `extensions` option.

package/lib/resolver.js

@@ -20,9 +20,33 @@ const optionsSchema = Joi.object({
     refineSchema: Joi.func().allow(null),
     refineDescription: Joi.func().allow(null),
     allowNull: Joi.boolean().default(false),
+    strictEnum: Joi.boolean().default(true),
+    enableEnum: Joi.boolean().default(true),
     joiOptions: Joi.object().unknown(true).default({})
 });
 
+const overridableOptions = {
+    refineType: Joi.func().allow(null),
+    refineSchema: Joi.func().allow(null),
+    refineDescription: Joi.func().allow(null),
+    allowNull: Joi.boolean(),
+    strictEnum: Joi.boolean(),
+    enableEnum: Joi.boolean()
+};
+const overridableOptionKeys = Object.keys(overridableOptions);
+const overrideOptionsSchema = Joi.object(overridableOptions);
+
+function mergeOverridableOptions(target, ...sources) {
+    sources.forEach((src) => {
+        overridableOptionKeys.forEach((key) => {
+            if (typeof src[key] !== 'undefined') {
+                target[key] = src[key];
+            }
+        })
+    });
+    return target;
+}
+
 function isNumber(value) {
     return typeof value === 'number';
 }
@@ -37,11 +61,31 @@ function isNotEmptyObject(value) {
 
 function allowNullIfNeeded(schema, allowNull = false) {
     if (allowNull) {
+        const definition = schema.describe();
+        if (definition.flags && definition.flags.only && definition.allow) {
+            // Already has enum restriction
+            return schema;
+        }
         return schema.allow(null);
     }
     return schema;
 }
 
+function addEnumRestriction(joiSchema, enumList, { allowNull = false, strictEnum = true, enableEnum = true }) {
+    if (!enableEnum || !Array.isArray(enumList) || enumList.length === 0) {
+        return joiSchema;
+    }
+
+    const valids = [].concat(enumList);
+    if (allowNull && !strictEnum) {
+        valids.push(null);
+        if (joiSchema.type === 'string') {
+            valids.push('');
+        }
+    }
+    return joiSchema.valid(...valids);
+}
+
 function normalizedId(id) {
     return id.replace(/[^a-zA-Z0-9]/g, '_');
 }
@@ -104,13 +148,10 @@ class SchemaResolver {
 
         Hoek.assert(!validatedResult.error, validatedResult.error);
 
-        const { subSchemas = {}, refineType, refineSchema, extensions = [], allowNull = false, refineDescription, joiOptions } = validatedResult.value;
+        const { subSchemas = {}, extensions = [], joiOptions } = validatedResult.value;
 
+        this.resolveOptions = mergeOverridableOptions({}, validatedResult.value);
         this.subSchemas = subSchemas;
-        this.refineType = refineType;
-        this.refineDescription = refineDescription;
-        this.refineSchema = refineSchema;
-        this.allowNull = allowNull;
         this.joiOptions = joiOptions;
         this.joiSharedSchemas = new Map();
 
@@ -122,7 +163,7 @@ class SchemaResolver {
                 // shorthand schema type does not need to set $id
                 sharedSchema.$id = sharedSchemaId;
             }
-            this.joiSharedSchemas.set(sharedSchemaId, this.resolve(sharedSchema));
+            this.joiSharedSchemas.set(sharedSchemaId, this.resolve(sharedSchema, this.resolveOptions));
         }
 
         const itr = this.joiSharedSchemas.keys();
@@ -132,26 +173,29 @@ class SchemaResolver {
         }
     }
 
-    resolveShareSchemas(schema, baseUri = '', sharedProperties = '$defs') {
+    resolveShareSchemas(schema, resolveOptions, sharedProperties = '$defs', baseUri = '') {
         const localShared = schema[sharedProperties]
         if (localShared) {
             for (let sharedSchemaId in localShared) {
                 this.joiSharedSchemas.set(
                     `${baseUri}#/${sharedProperties}/${sharedSchemaId}`,
-                    this.resolve(localShared[sharedSchemaId], baseUri)
+                    this.resolve(localShared[sharedSchemaId], resolveOptions, baseUri)
                 );
             }
         }
     }
 
-    convert(schema) {
+    convert(schema, options = {}) {
         const validateSchema = schemaSchema.validate(schema);
+        const { value: overrideOptions, error: overrideOptionsError } = overrideOptionsSchema.validate(options);
 
         Hoek.assert(!validateSchema.error, validateSchema.error);
+        Hoek.assert(!overrideOptionsError, overrideOptionsError);
 
         const schemaId = schema.$id || '';
         this.subSchemas[schemaId] = schema;
-        const joiSchema = this.resolve(schema);
+
+        const joiSchema = this.resolve(schema, mergeOverridableOptions({}, this.resolveOptions, overrideOptions));
 
         // Cleanup all shared schema registered other than the initial shared ones
         delete this.subSchemas[schemaId];
@@ -165,7 +209,7 @@ class SchemaResolver {
         return joiSchema;
     }
 
-    resolve(schema, baseUri = (schema.$id || '')) {
+    resolve(schema, resolveOptions = {}, baseUri = (schema.$id || '')) {
         if (this.joi.isSchema(schema)) {
             return schema;
         }
@@ -180,46 +224,48 @@ class SchemaResolver {
             }
         }
 
-        this.resolveShareSchemas(schema, baseUri, '$defs');
-        this.resolveShareSchemas(schema, baseUri, 'definitions');
+        this.resolveShareSchemas(schema, resolveOptions, '$defs', baseUri);
+        this.resolveShareSchemas(schema, resolveOptions, 'definitions', baseUri);
 
         if (typeof schema === 'string') {
             // If schema is itself a string, interpret it as a type
-            resolvedSchema = this.resolveType({ type: schema });
+            resolvedSchema = this.resolveType({ type: schema }, resolveOptions, baseUri);
         } else if (schema.$ref) {
             if (schema.$ref.trim() === '#') {
                 return baseUri ? this.joi.link(`#${normalizedId(baseUri)}`) : this.joi.link('/');
             }
 
-            resolvedSchema = this.resolve(this.resolveReference(schema.$ref, baseUri), baseUri);
+            resolvedSchema = this.resolve(this.resolveReference(schema.$ref, baseUri), resolveOptions, baseUri);
         } else {
             const partialSchemas = [];
             if (schema.type) {
-                partialSchemas.push(this.resolveType(schema, baseUri));
+                partialSchemas.push(this.resolveType(schema, resolveOptions, baseUri));
             } else if (schema.properties) {
                 // if no type is specified, just properties
-                partialSchemas.push(this.object(schema, baseUri))
+                partialSchemas.push(this.object(schema, resolveOptions, baseUri))
             } else if (schema.format) {
                 // if no type is specified, just format
                 partialSchemas.push(this.string(schema))
             } else if (schema.enum) {
                 // If no type is specified, just enum
-                partialSchemas.push(this.joi.any().valid(...schema.enum).example(schema.enum[0]));
+                partialSchemas.push(
+                    addEnumRestriction(this.joi.any().example(schema.enum[0]), schema.enum, resolveOptions)
+                );
             } else if (schema.const) {
                 // Constant value
                 partialSchemas.push(this.getValueJoiType(schema.const).valid(schema.const));
             }
             if (schema.anyOf) {
-                partialSchemas.push(this.resolveAnyOf(schema, baseUri));
+                partialSchemas.push(this.resolveAnyOf(schema, resolveOptions, baseUri));
             }
             if (schema.allOf) {
-                partialSchemas.push(this.resolveAllOf(schema, baseUri));
+                partialSchemas.push(this.resolveAllOf(schema, resolveOptions, baseUri));
             }
             if (schema.oneOf) {
-                partialSchemas.push(this.resolveOneOf(schema, baseUri));
+                partialSchemas.push(this.resolveOneOf(schema, resolveOptions, baseUri));
             }
             if (schema.not) {
-                partialSchemas.push(this.resolveNot(schema, baseUri));
+                partialSchemas.push(this.resolveNot(schema, resolveOptions, baseUri));
             }
             if (partialSchemas.length === 0) {
                 //Fall through to whatever.
@@ -231,8 +277,8 @@ class SchemaResolver {
             resolvedSchema = partialSchemas.length === 1 ? partialSchemas[0] : this.joi.alternatives(partialSchemas).match('all');
         }
 
-        if (this.refineSchema) {
-            resolvedSchema = this.refineSchema(resolvedSchema, schema);
+        if (resolveOptions.refineSchema) {
+            resolvedSchema = resolveOptions.refineSchema(resolvedSchema, schema);
         }
 
         if (schema.default !== undefined) {
@@ -299,7 +345,7 @@ class SchemaResolver {
         return refSchema;
     }
 
-    resolveType(schema, baseUri) {
+    resolveType(schema, resolveOptions, baseUri) {
         let joischema;
 
         const typeDefinitionMap = {
@@ -307,16 +353,16 @@ class SchemaResolver {
             default: 'default'
         };
 
-        const joitype = (type, format) => {
+        const joitype = (type, options, format) => {
             let joischema;
 
-            if (this.refineType) {
-                type = this.refineType(type, format);
+            if (options.refineType) {
+                type = options.refineType(type, format);
             }
 
             switch (type) {
                 case 'array':
-                    joischema = this.array(schema, baseUri);
+                    joischema = this.array(schema, options, baseUri);
                     break;
                 case 'boolean':
                     joischema = this.joi.boolean();
@@ -326,7 +372,7 @@ class SchemaResolver {
                     joischema = this.number(schema);
                     break;
                 case 'object':
-                    joischema = this.object(schema, baseUri);
+                    joischema = this.object(schema, options, baseUri);
                     break;
                 case 'string':
                     joischema = this.string(schema);
@@ -347,12 +393,12 @@ class SchemaResolver {
             const schemas = [];
 
             for (let i = 0; i < schema.type.length; i++) {
-                schemas.push(joitype(schema.type[i], schema.format));
+                schemas.push(joitype(schema.type[i], resolveOptions, schema.format));
             }
 
             joischema = this.joi.alternatives(schemas);
         } else {
-            joischema = joitype(schema.type, schema.format);
+            joischema = joitype(schema.type, resolveOptions, schema.format);
         }
 
         Object.keys(typeDefinitionMap).forEach(function (key) {
@@ -362,8 +408,8 @@ class SchemaResolver {
         });
 
         let desc = schema.description;
-        if (this.refineDescription) {
-            desc = this.refineDescription(schema);
+        if (resolveOptions.refineDescription) {
+            desc = resolveOptions.refineDescription(schema);
         }
         if (desc) {
             joischema = joischema.description(desc);
@@ -383,70 +429,69 @@ class SchemaResolver {
             joischema = joischema.type === 'array' && !Array.isArray(example) ? joischema.example([example]) : joischema.example(example);
         }
 
-        return joischema;
+        return addEnumRestriction(joischema, schema.enum, resolveOptions);
     }
 
-    resolveOneOf(schema, baseUri) {
+    resolveOneOf(schema, resolveOptions, baseUri) {
         Hoek.assert(Array.isArray(schema.oneOf), 'Expected oneOf to be an array.');
 
-        return this.joi.alternatives(schema.oneOf.map(schema => this.resolve(schema, baseUri))).match('one');
+        return this.joi.alternatives(schema.oneOf.map(schema => this.resolve(schema, resolveOptions, baseUri))).match('one');
     }
 
-    resolveAnyOf(schema, baseUri) {
+    resolveAnyOf(schema, resolveOptions, baseUri) {
         Hoek.assert(Array.isArray(schema.anyOf), 'Expected anyOf to be an array.');
 
-        return this.joi.alternatives(schema.anyOf.map(schema => this.resolve(schema, baseUri))).match('any');
+        return this.joi.alternatives(schema.anyOf.map(schema => this.resolve(schema, resolveOptions, baseUri))).match('any');
     }
 
-    resolveAllOf(schema, baseUri) {
+    resolveAllOf(schema, resolveOptions, baseUri) {
         Hoek.assert(Array.isArray(schema.allOf), 'Expected allOf to be an array.');
 
-        return this.joi.alternatives(schema.allOf.map(schema => this.resolve(schema, baseUri))).match('all');
+        return this.joi.alternatives(schema.allOf.map(schema => this.resolve(schema, resolveOptions, baseUri))).match('all');
     }
 
-    resolveNot(schema, baseUri) {
+    resolveNot(schema, resolveOptions, baseUri) {
         Hoek.assert(isObject(schema.not), 'Expected Not to be an object.');
 
         return this.joi.alternatives().conditional(
           '.',
           {
-              not: this.resolve(schema.not, baseUri),
+              not: this.resolve(schema.not, resolveOptions, baseUri),
               then: this.joi.any(),
               otherwise: this.joi.any().forbidden()
           }
         );
     }
 
-    object(schema, baseUri) {
+    resolveProperties(jsonSchema, resolveOptions, baseUri) {
+        const schemas = {};
 
-        const resolveproperties = () => {
-            const schemas = {};
-
-            if (!isObject(schema.properties)) {
-                return;
-            }
+        if (!isObject(jsonSchema.properties)) {
+            return;
+        }
 
-            Object.keys(schema.properties).forEach((key) => {
-                const property = schema.properties[key];
+        Object.keys(jsonSchema.properties).forEach((key) => {
+            const property = jsonSchema.properties[key];
 
-                let joischema = this.resolve(property, baseUri);
+            let joischema = this.resolve(property, resolveOptions, baseUri);
 
-                if (Array.isArray(schema.required) && !!~schema.required.indexOf(key)) {
-                    joischema = joischema.required();
-                } else {
-                    joischema = allowNullIfNeeded(joischema, this.allowNull);
-                }
+            if (Array.isArray(jsonSchema.required) && !!~jsonSchema.required.indexOf(key)) {
+                joischema = joischema.required();
+            } else {
+                joischema = allowNullIfNeeded(joischema, resolveOptions.allowNull);
+            }
 
-                schemas[key] = joischema;
-            });
+            schemas[key] = joischema;
+        });
 
-            return schemas;
-        }
+        return schemas;
+    }
 
-        let joischema = this.joi.object(resolveproperties(schema));
+    object(schema, resolveOptions, baseUri) {
+        let joischema = this.joi.object(this.resolveProperties(schema, resolveOptions, baseUri));
 
         if (isObject(schema.additionalProperties)) {
-            joischema = joischema.pattern(/^/, this.resolve(schema.additionalProperties, baseUri));
+            joischema = joischema.pattern(/^/, this.resolve(schema.additionalProperties, resolveOptions, baseUri));
         } else if (typeof this.joiOptions.allowUnknown === 'undefined') {
             joischema = joischema.unknown(schema.additionalProperties !== false);
         }
@@ -457,25 +502,25 @@ class SchemaResolver {
         return joischema;
     }
 
-    resolveAsArray(value, baseUri) {
+    resolveAsArray(value, resolveOptions, baseUri) {
         if (Array.isArray(value)) {
             // found an array, thus its _per type_
-            return value.map((v) => allowNullIfNeeded(this.resolve(v, baseUri), this.allowNull));
+            return value.map((v) => allowNullIfNeeded(this.resolve(v, resolveOptions, baseUri), resolveOptions.allowNull));
         }
         // it's a single entity, so just resolve it normally
-        return [allowNullIfNeeded(this.resolve(value, baseUri), this.allowNull)];
+        return [allowNullIfNeeded(this.resolve(value, resolveOptions, baseUri), resolveOptions.allowNull)];
     }
 
-    array(schema, baseUri) {
+    array(schema, resolveOptions, baseUri) {
         let joischema = this.joi.array();
         let items;
 
         if (schema.items) {
-            items = this.resolveAsArray(schema.items, baseUri);
+            items = this.resolveAsArray(schema.items, resolveOptions, baseUri);
 
             joischema = joischema.items(...items);
         } else if (schema.ordered) {
-            items = this.resolveAsArray(schema.ordered, baseUri);
+            items = this.resolveAsArray(schema.ordered, resolveOptions, baseUri);
             joischema = joischema.ordered(...items);
         }
 
@@ -490,7 +535,7 @@ class SchemaResolver {
             joischema = joischema.unique();
         }
         if (schema.contains) {
-            joischema = joischema.has(this.resolve(schema.contains, baseUri));
+            joischema = joischema.has(this.resolve(schema.contains, resolveOptions, baseUri));
         }
 
         return joischema;
@@ -519,10 +564,6 @@ class SchemaResolver {
         const timeRegex = '([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(.[0-9]+)?(Z|(\\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))';
         const dateTimeRegex = dateRegex + 'T' + timeRegex;
 
-        if (schema.enum) {
-            return this.joi.string().valid(...schema.enum);
-        }
-
         switch (schema.format) {
             case 'date':
                 return joischema.regex(new RegExp('^' + dateRegex + '$', 'i'), 'JsonSchema date format');
@@ -561,7 +602,7 @@ class SchemaResolver {
     regularString(schema, joischema) {
         schema.pattern && (joischema = joischema.regex(new RegExp(schema.pattern)));
 
-        if ((typeof schema.minLength === 'undefined' || schema.minLength === 0) && !schema.pattern && !schema.format) {
+        if ((typeof schema.minLength === 'undefined' || schema.minLength === 0) && !schema.pattern && !schema.format && !schema.enum) {
             joischema = joischema.allow('');
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-2-joi",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "license": "Apache 2.0",
   "description": "Converts json-schema to Joi schema. (Enhanced enjoi)",
   "main": "./index.js",