support for empty schemas (#283)

Author: sinclairzx81

index.d.ts

@@ -58,6 +58,9 @@ declare namespace build {
      */
     $ref: string;
   }
+  
+  export interface AnySchema extends BaseSchema {
+  }
 
   export interface StringSchema extends BaseSchema {
     type: "string";
@@ -157,6 +160,7 @@ declare namespace build {
  * @param schema The schema used to stringify values
  * @param options The options to use (optional)
  */
+declare function build(schema: build.AnySchema, options?: build.Options): (doc: any) => any;
 declare function build(schema: build.StringSchema, options?: build.Options): (doc: string) => string;
 declare function build(schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): (doc: number) => string;
 declare function build(schema: build.NullSchema, options?: build.Options): (doc: null) => "null";

index.js

@@ -70,6 +70,7 @@ function build (schema, options) {
 
   code += `
     ${$pad2Zeros.toString()}
+    ${$asAny.toString()}
     ${$asString.toString()}
     ${$asStringNullable.toString()}
     ${$asStringSmall.toString()}
@@ -130,6 +131,9 @@ function build (schema, options) {
       main = '$main'
       code = buildArray(location, code, main)
       break
+    case undefined:
+      main = '$asAny'
+      break
     default:
       throw new Error(`${schema.type} unsupported`)
   }
@@ -237,6 +241,10 @@ function $pad2Zeros (num) {
   return s[s.length - 2] + s[s.length - 1]
 }
 
+function $asAny (i) {
+  return JSON.stringify(i)
+}
+
 function $asNull () {
   return 'null'
 }
@@ -890,7 +898,7 @@ function addIfThenElse (location, name) {
 }
 
 function toJSON (variableName) {
-  return `typeof ${variableName}.toJSON === 'function'
+  return `(${variableName} && typeof ${variableName}.toJSON === 'function')
     ? ${variableName}.toJSON()
     : ${variableName}
   `
@@ -1194,6 +1202,10 @@ function nested (laterCode, name, key, location, subKey, isArray) {
           else
             throw new Error(\`Item $\{JSON.stringify(obj${accessor})} does not match schema definition.\`)
         `
+      } else if (schema.type === undefined) {
+        code += `
+          json += JSON.stringify(obj${accessor})
+        `
       } else {
         throw new Error(`${schema.type} unsupported`)
       }

test/any.test.js

@@ -63,3 +63,92 @@ test('array with random items', (t) => {
   const value = stringify([1, 'string', null])
   t.is(value, '[1,"string",null]')
 })
+
+test('empty schema', (t) => {
+  t.plan(7)
+
+  const schema = { }
+
+  const stringify = build(schema)
+
+  t.is(stringify(null), 'null')
+  t.is(stringify(1), '1')
+  t.is(stringify(true), 'true')
+  t.is(stringify('hello'), '"hello"')
+  t.is(stringify({}), '{}')
+  t.is(stringify({ x: 10 }), '{"x":10}')
+  t.is(stringify([true, 1, 'hello']), '[true,1,"hello"]')
+})
+
+test('empty schema on nested object', (t) => {
+  t.plan(7)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      x: {}
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.is(stringify({ x: null }), '{"x":null}')
+  t.is(stringify({ x: 1 }), '{"x":1}')
+  t.is(stringify({ x: true }), '{"x":true}')
+  t.is(stringify({ x: 'hello' }), '{"x":"hello"}')
+  t.is(stringify({ x: {} }), '{"x":{}}')
+  t.is(stringify({ x: { x: 10 } }), '{"x":{"x":10}}')
+  t.is(stringify({ x: [true, 1, 'hello'] }), '{"x":[true,1,"hello"]}')
+})
+
+test('empty schema on array', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'array',
+    items: {}
+  }
+
+  const stringify = build(schema)
+
+  t.is(stringify([1, true, 'hello', [], { x: 1 }]), '[1,true,"hello",[],{"x":1}]')
+})
+
+test('empty schema on anyOf', (t) => {
+  t.plan(4)
+
+  // any on Foo codepath.
+  const schema = {
+    anyOf: [
+      {
+        type: 'object',
+        properties: {
+          kind: {
+            type: 'string',
+            enum: ['Foo']
+          },
+          value: {}
+        }
+      },
+      {
+        type: 'object',
+        properties: {
+          kind: {
+            type: 'string',
+            enum: ['Bar']
+          },
+          value: {
+            type: 'number'
+          }
+        }
+      }
+    ]
+  }
+
+  const stringify = build(schema)
+
+  t.is(stringify({ kind: 'Bar', value: 1 }), '{"kind":"Bar","value":1}')
+  t.is(stringify({ kind: 'Foo', value: 1 }), '{"kind":"Foo","value":1}')
+  t.is(stringify({ kind: 'Foo', value: true }), '{"kind":"Foo","value":true}')
+  t.is(stringify({ kind: 'Foo', value: 'hello' }), '{"kind":"Foo","value":"hello"}')
+})