@integration-app/react 0.1.1

package/node_modules/@integration-app/sdk/src/json-schema/json-schema.test.ts

@@ -0,0 +1,246 @@
+import {
+  getDefaultsFromSchema,
+  JSONSchemaType,
+  schemaDiff,
+  valueToSchema,
+} from '.'
+
+describe('JSONSchema', () => {
+  describe('schemaDiff', () => {
+    it('should return null if schemas are matching', () => {
+      expect(
+        schemaDiff(
+          { type: JSONSchemaType.String },
+          { type: JSONSchemaType.String },
+        ),
+      ).toBeNull()
+    })
+
+    it('should return first schema if the second is empty', () => {
+      expect(schemaDiff({ type: JSONSchemaType.String }, null)).toEqual({
+        type: JSONSchemaType.String,
+      })
+    })
+
+    it('should return null if the first is empty', () => {
+      expect(schemaDiff(null, { type: JSONSchemaType.String })).toBeNull()
+    })
+
+    it('should calculate diff for an object', () => {
+      expect(
+        schemaDiff(
+          {
+            type: JSONSchemaType.Object,
+            properties: {
+              property1: { type: JSONSchemaType.String },
+              property2: { type: JSONSchemaType.String },
+            },
+          },
+          {
+            type: JSONSchemaType.Object,
+            properties: {
+              property1: { type: JSONSchemaType.String },
+            },
+          },
+        ),
+      ).toEqual({
+        type: JSONSchemaType.Object,
+        properties: {
+          property2: { type: JSONSchemaType.String },
+        },
+      })
+    })
+
+    it('should calculate diff for an array of objects', () => {
+      expect(
+        schemaDiff(
+          {
+            type: JSONSchemaType.Array,
+            items: {
+              type: JSONSchemaType.Object,
+              properties: {
+                property1: { type: JSONSchemaType.String },
+                property2: { type: JSONSchemaType.String },
+              },
+            },
+          },
+          {
+            type: JSONSchemaType.Array,
+            items: {
+              type: JSONSchemaType.Object,
+              properties: {
+                property1: { type: JSONSchemaType.String },
+              },
+            },
+          },
+        ),
+      ).toEqual({
+        type: JSONSchemaType.Array,
+        items: {
+          type: JSONSchemaType.Object,
+          properties: {
+            property2: { type: JSONSchemaType.String },
+          },
+        },
+      })
+    })
+
+    it('should calculate diff for a complex schema', () => {
+      const diff = schemaDiff(
+        {
+          type: JSONSchemaType.Object,
+          properties: {
+            property1: { type: JSONSchemaType.Number },
+            property2: { type: JSONSchemaType.String },
+            arrayProperty: {
+              type: JSONSchemaType.Array,
+              items: {
+                type: JSONSchemaType.Object,
+                properties: {
+                  arrayProperty1: { type: JSONSchemaType.String },
+                  arrayProperty2: { type: JSONSchemaType.String },
+                },
+              },
+            },
+          },
+        },
+        {
+          type: JSONSchemaType.Object,
+          properties: {
+            property1: { type: JSONSchemaType.String },
+            arrayProperty: {
+              type: JSONSchemaType.Array,
+              items: {
+                type: JSONSchemaType.Object,
+                properties: {
+                  arrayProperty1: { type: JSONSchemaType.String },
+                },
+              },
+            },
+          },
+        },
+      )
+
+      expect(diff).toEqual({
+        type: JSONSchemaType.Object,
+        properties: {
+          property2: { type: JSONSchemaType.String },
+          arrayProperty: {
+            type: JSONSchemaType.Array,
+            items: {
+              type: JSONSchemaType.Object,
+              properties: {
+                arrayProperty2: { type: JSONSchemaType.String },
+              },
+            },
+          },
+        },
+      })
+    })
+  })
+
+  describe('getDefaultsFromSchema', () => {
+    it('should return null for empty schema', () => {
+      expect(getDefaultsFromSchema(null)).toBeUndefined()
+    })
+
+    it('should return null for schema without defaults', () => {
+      expect(
+        getDefaultsFromSchema({
+          type: 'object',
+          properties: {
+            key: { type: 'string' },
+          },
+        }),
+      ).toBeUndefined()
+    })
+
+    it('should return default for a scalar schema', () => {
+      expect(
+        getDefaultsFromSchema({
+          type: 'string',
+          default: 'value',
+        }),
+      ).toEqual('value')
+    })
+
+    it('should return default if it is false', () => {
+      expect(
+        getDefaultsFromSchema({
+          type: 'boolean',
+          default: false,
+        }),
+      ).toBe(false)
+    })
+
+    it('should return default for a complex object', () => {
+      expect(
+        getDefaultsFromSchema({
+          type: 'object',
+          properties: {
+            key: {
+              type: 'string',
+              default: 'keyValue',
+            },
+            objKey: {
+              type: 'object',
+              properties: {
+                subKey: {
+                  type: 'string',
+                  default: 'subKeyValue',
+                },
+              },
+            },
+          },
+        }),
+      ).toEqual({
+        key: 'keyValue',
+        objKey: {
+          subKey: 'subKeyValue',
+        },
+      })
+    })
+  })
+})
+
+describe('valueToSchema', () => {
+  it('should ignore object keys that are not in schema', () => {
+    expect(
+      valueToSchema(
+        {
+          key1: 'value1',
+          key2: 'value2',
+        },
+        {
+          type: 'object',
+          properties: {
+            key1: { type: 'string' },
+          },
+        },
+      ),
+    ).toEqual({
+      key1: 'value1',
+    })
+  })
+
+  it('should not ignore object keys if additionalProperties is set', () => {
+    expect(
+      valueToSchema(
+        {
+          key1: 'value1',
+          key2: 'value2',
+        },
+        {
+          type: 'object',
+          properites: {
+            key1: { type: 'string' },
+          },
+          additionalProperties: true,
+        },
+      ),
+    ).toEqual({
+      key1: 'value1',
+      key2: 'value2',
+    })
+  })
+})

package/node_modules/@integration-app/sdk/src/json-schema/schema-builder.test.ts

@@ -0,0 +1,396 @@
+import {
+  createSchema,
+  mergeSchemas,
+  extendSchema,
+  createCompoundSchema,
+} from './schema-builder'
+
+describe('SchemaBuilder', () => {
+  describe('generation', () => {
+    describe('simple types', () => {
+      it('should build schema for integer', () => {
+        const schema = createSchema(1)
+        expect(schema.type).toEqual('integer')
+      })
+
+      it('should build schema for number', () => {
+        const schema = createSchema(1.1)
+        expect(schema.type).toEqual('number')
+      })
+
+      it('should build schema for string', () => {
+        const schema = createSchema('some string')
+        expect(schema.type).toEqual('string')
+      })
+
+      it('should build schema for null', () => {
+        const schema = createSchema(null)
+        expect(schema.type).toBeUndefined()
+      })
+
+      it('should build schema for boolean', () => {
+        const schema = createSchema(false)
+        expect(schema.type).toEqual('boolean')
+      })
+
+      it('should build schema for array', () => {
+        const schema = createSchema([])
+        expect(schema.type).toEqual('array')
+        expect(schema.items).toBeUndefined()
+      })
+
+      it('should build schema for object', () => {
+        const schema = createSchema({})
+        expect(schema.type).toEqual('object')
+        expect(schema.properties).toBeUndefined()
+      })
+
+      it('should build schema for undefined', () => {
+        const schema = createSchema(undefined)
+        expect(schema.type).toBeUndefined()
+      })
+    })
+
+    describe('arrays', () => {
+      it('it should generate schema for arrays of the same type', () => {
+        const schema = createSchema([1, 2, 3])
+        expect(schema.type).toEqual('array')
+        expect(schema.items.type).toEqual('integer')
+      })
+
+      it('it should generate schema for arrays of the same type with floats', () => {
+        const schema = createSchema([1, 2.1, 3])
+        expect(schema.type).toEqual('array')
+        expect(schema.items.type).toEqual('number')
+      })
+    })
+
+    describe('objects', () => {
+      it('it should generate schema for object with props of the same type', () => {
+        const schema = createSchema({ one: 1, two: 2 })
+        expect(schema).toEqual({
+          type: 'object',
+          properties: {
+            one: { type: 'integer' },
+            two: { type: 'integer' },
+          },
+        })
+      })
+
+      it('it should generate schema for object with props of different types', () => {
+        const schema = createSchema({ one: 1, two: 'second' })
+        expect(schema).toEqual({
+          type: 'object',
+          properties: {
+            one: { type: 'integer' },
+            two: { type: 'string' },
+          },
+        })
+      })
+    })
+
+    describe('nested array', () => {
+      it('should generate schema for nested arrays', () => {
+        const schema = createSchema([1, [2.1], [[3]]])
+        expect(schema.type).toEqual('array')
+        expect(schema.items).toHaveProperty('anyOf')
+        const integerSchema = schema.items.anyOf.find(
+          (s) => s.type == 'integer',
+        )
+        expect(integerSchema).toBeTruthy()
+        const arraySchema = schema.items.anyOf.find((s) => s.type == 'array')
+        expect(arraySchema).not.toBeUndefined()
+        expect(arraySchema.items).toHaveProperty('anyOf')
+        const nestedNumberSchema = arraySchema.items.anyOf.find(
+          (s) => s.type == 'number',
+        )
+        expect(nestedNumberSchema).not.toBeUndefined()
+        const nestedArraySchema = arraySchema.items.anyOf.find(
+          (s) => s.type == 'array',
+        )
+        expect(nestedArraySchema).not.toBeUndefined()
+        expect(nestedArraySchema.items.type).toEqual('integer')
+      })
+
+      it('complex end-to-end case: should generate schema for nested arrays and simplify anyOf', () => {
+        const schema = createSchema([
+          1,
+          'some string',
+          null,
+          [2, 'some other string', {}],
+          [[3.1]],
+        ])
+        expect(schema).toMatchSnapshot()
+      })
+    })
+
+    describe('nested objects/arrays', () => {
+      it('should combine object schemas and respect required property', () => {
+        const schema = createSchema({
+          one: 1,
+          two: 'second',
+          three: {
+            four: 5,
+            five: [5],
+            six: null,
+            seven: [{}, { eight: 1.1 }, { nine: 'nine' }],
+          },
+        })
+        expect(schema).toMatchSnapshot()
+      })
+    })
+
+    describe('all cases combined', () => {
+      it('should generate valid schemas for complex objects', () => {
+        const schema = createSchema([
+          {
+            lvl1PropNum: 1,
+            lvl1PropStr: 'second',
+            lvl1PropObj1: { lvl2PropArr: [1, 2] },
+            lvl1PropObj2: {
+              lvl2PropNum1: 5,
+              lvl2PropArr1: [5],
+              six: null,
+              lvl2PropArr2: [
+                {},
+                { lvl3PropNum1: 1.2 },
+                { lvl3PropStr1: 'nine' },
+                [1, false],
+                1,
+                'some string',
+              ],
+            },
+          },
+          { lvl1PropStr: 'one' },
+          { lvl1PropNum: 1.2, lvl1PropStr: 'one' },
+          {
+            lvl1PropStr: 'one',
+            lvl1PropObj1: { lvl2PropArr: [2.3, null, 'some string', false] },
+          },
+        ])
+
+        expect(schema).toMatchSnapshot()
+      })
+    })
+
+    describe('prototype methods', () => {
+      function createObjectWithProtoMethods(): Record<string, any> {
+        return {
+          constructor: 'constructor value',
+          hasOwnProperty: 'hasOwnProperty value',
+          isPrototypeOf: 'isPrototypeOf value',
+          propertyIsEnumerable: 'propertyIsEnumerable value',
+          toLocaleString: 'toLocaleString value',
+          toString: 'toString value',
+          valueOf: 'valueOf value',
+          __defineGetter__: '__defineGetter__ value',
+          __defineSetter__: '__defineSetter__ value',
+          __lookupGetter__: '__lookupGetter__ value',
+          __lookupSetter__: '__lookupSetter__ value',
+          __proto__: '__proto__ value',
+        }
+      }
+
+      it('should work for props with the same names as Object.prototype methods', async () => {
+        // it's improtant to keep them in array, as this is more complex case
+        const value: any = [
+          createObjectWithProtoMethods(),
+          createObjectWithProtoMethods(),
+        ]
+        const schema = createSchema(value)
+        expect(schema.items).toEqual({
+          type: 'object',
+          properties: {
+            constructor: { type: 'string' },
+            hasOwnProperty: {
+              type: 'string',
+            },
+            isPrototypeOf: {
+              type: 'string',
+            },
+            propertyIsEnumerable: {
+              type: 'string',
+            },
+            toLocaleString: {
+              type: 'string',
+            },
+            toString: { type: 'string' },
+            valueOf: { type: 'string' },
+            __defineGetter__: {
+              type: 'string',
+            },
+            __defineSetter__: {
+              type: 'string',
+            },
+            __lookupGetter__: {
+              type: 'string',
+            },
+            __lookupSetter__: {
+              type: 'string',
+            },
+          },
+        })
+      })
+    })
+
+    describe('circular refs', () => {
+      it('should throw an error w/ explanation', async () => {
+        const a: any = {}
+        const b: any = {}
+        a.b = b
+        b.a = a
+
+        expect(() => {
+          createSchema(a)
+        }).toThrowErrorMatchingSnapshot()
+      })
+    })
+
+    describe('non-json values', () => {
+      it('should ignore functions', async () => {
+        const value: any = {
+          func() {
+            /* do nothing*/
+          },
+          someProp: 'string',
+        }
+        const schema = createSchema(value)
+        expect(schema.type).toEqual('object')
+        expect(Object.keys(schema.properties)).toHaveLength(1)
+        expect(schema.properties).toHaveProperty('someProp')
+      })
+    })
+
+    describe('null values', () => {
+      it('should generate fields with empty schemas when the value is null', async () => {
+        const value = {
+          key1: 'string',
+          key2: null,
+        }
+
+        const schema = createSchema(value)
+        expect(schema.type).toEqual('object')
+        expect(Object.keys(schema.properties)).toHaveLength(2)
+        expect(schema.properties.key1.type).toEqual('string')
+        expect(schema.properties.key2.type).toBeUndefined()
+      })
+    })
+  })
+
+  describe('createCompoundSchema', () => {
+    it('should create compound schema from multiple inputs', () => {
+      const schema = createCompoundSchema([
+        { age: 35 },
+        { age: 19, name: 'John' },
+        { age: 23, admin: true },
+      ])
+      expect(schema).toEqual({
+        type: 'object',
+        properties: {
+          admin: { type: 'boolean' },
+          age: { type: 'integer' },
+          name: { type: 'string' },
+        },
+      })
+    })
+  })
+
+  describe('merging', () => {
+    it('should merge simple schemas', () => {
+      const merged = mergeSchemas([{ type: 'number' }, { type: 'string' }])
+      expect(merged).toEqual({ type: ['number', 'string'] })
+    })
+
+    it('should merge array schemas', () => {
+      const merged = mergeSchemas([
+        {
+          type: 'array',
+          items: {
+            anyOf: [
+              {
+                type: ['number', 'string'],
+              },
+              {
+                type: 'array',
+              },
+            ],
+          },
+        },
+        { type: 'string' },
+      ])
+      expect(merged).toEqual({
+        anyOf: [
+          { type: 'string' },
+          {
+            type: 'array',
+            items: {
+              type: ['number', 'string', 'array'],
+            },
+          },
+        ],
+      })
+    })
+
+    it('should merge object schemas', async () => {
+      const merged = mergeSchemas([
+        { type: 'object' },
+        {
+          type: 'object',
+          properties: { prop1: { type: 'string' } },
+        },
+      ])
+      expect(merged).toEqual({
+        type: 'object',
+        properties: { prop1: { type: 'string' } },
+      })
+    })
+
+    it('should merge more than 2 schemas', async () => {
+      const merged = mergeSchemas([
+        { type: 'number' },
+        { type: 'string' },
+        { type: 'boolean' },
+      ])
+      expect(merged).toEqual({ type: ['boolean', 'number', 'string'] })
+    })
+  })
+
+  describe('extending', () => {
+    it('should extend simple schemas', () => {
+      const merged = extendSchema({ type: 'number' }, 'some string')
+      expect(merged).toEqual({
+        type: ['number', 'string'],
+      })
+    })
+
+    it('should extend array schemas', () => {
+      const merged = extendSchema(
+        {
+          type: 'array',
+          items: {
+            anyOf: [
+              {
+                type: ['number', 'string'],
+              },
+              {
+                type: 'array',
+              },
+            ],
+          },
+        },
+        'some string',
+      )
+      expect(merged).toEqual({
+        anyOf: [
+          createSchema('some string'),
+          {
+            type: 'array',
+            items: {
+              type: ['number', 'string', 'array'],
+            },
+          },
+        ],
+      })
+    })
+  })
+})