@integration-app/react 0.1.1 → 0.1.2

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

@@ -1,246 +0,0 @@
-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

@@ -1,396 +0,0 @@
-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'],
-            },
-          },
-        ],
-      })
-    })
-  })
-})