@integration-app/react 0.1.2 → 0.1.3

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'],
+            },
+          },
+        ],
+      })
+    })
+  })
+})

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

@@ -0,0 +1,258 @@
+/*
+Originally created by Aspecto folks: https://github.com/aspecto-io/genson-js.
+
+We added a few modifications:
+ * Ignore null schemas when combining schemas.
+ * Always ignore `required`.
+*/
+function createSchemaFor(value: any): any {
+  switch (typeof value) {
+    case 'number':
+      if (Number.isInteger(value)) {
+        return { type: 'integer' }
+      }
+      return { type: 'number' }
+    case 'boolean':
+      return { type: 'boolean' }
+    case 'string':
+      return { type: 'string' }
+    case 'object':
+      if (value === null) {
+        return {}
+      }
+      if (Array.isArray(value)) {
+        return createSchemaForArray(value)
+      }
+      return createSchemaForObject(value)
+    default:
+      return null
+  }
+}
+
+function createSchemaForArray(arr: Array<any>): any {
+  if (arr.length === 0) {
+    return { type: 'array' }
+  }
+  const elementSchemas = arr.map((value) => createSchemaFor(value))
+  const items = combineSchemas(elementSchemas)
+  return { type: 'array', items }
+}
+
+function createSchemaForObject(obj: Record<string, any>): any {
+  const keys = Object.keys(obj)
+  if (keys.length === 0) {
+    return {
+      type: 'object',
+    }
+  }
+  const properties = Object.entries(obj).reduce((props, [key, val]) => {
+    props[key] = createSchemaFor(val)
+    return props
+  }, {})
+
+  const schema: any = { type: 'object', properties }
+  return schema
+}
+
+function combineSchemas(schemas: any[]): any {
+  const schemasByType: Record<string, any[]> = {
+    undefined: [],
+    ['null']: [],
+    ['boolean']: [],
+    ['integer']: [],
+    ['number']: [],
+    ['string']: [],
+    ['array']: [],
+    ['object']: [],
+  }
+
+  const unwrappedSchemas = unwrapSchemas(schemas)
+  for (const unwrappedSchema of unwrappedSchemas) {
+    const type = unwrappedSchema.type
+    schemasByType[type].push(unwrappedSchema)
+  }
+
+  if (schemasByType['number'].length > 0) {
+    // if at least one value is number, other integers can be numbers too
+    schemasByType['number'].push(
+      ...schemasByType['integer'].map((r) => ({
+        ...r,
+        type: 'number',
+      })),
+    )
+    delete schemasByType['integer']
+  }
+
+  const resultSchemasByType: Record<string, any> = {
+    ['null']: combineSameTypeScalarSchemas(schemasByType['null']),
+    ['boolean']: combineSameTypeScalarSchemas(schemasByType['boolean']),
+    ['number']: combineSameTypeScalarSchemas(schemasByType['number']),
+    ['integer']: combineSameTypeScalarSchemas(schemasByType['integer']),
+    ['string']: combineSameTypeScalarSchemas(schemasByType['string']),
+    ['array']: combineArraySchemas(schemasByType['array']),
+    ['object']: combineObjectSchemas(schemasByType['object']),
+  }
+
+  const schemasFound = Object.values(resultSchemasByType).filter(Boolean)
+  const multiType = schemasFound.length > 1
+  if (multiType) {
+    const wrapped = wrapAnyOfSchema({ anyOf: schemasFound })
+    return wrapped
+  }
+  return schemasFound[0] as any
+}
+
+function combineSameTypeScalarSchemas(schemas: any[]): any {
+  if (!schemas || schemas.length === 0) {
+    return undefined
+  }
+
+  const schema = <any>{
+    type: schemas[0].type,
+  }
+
+  addTitleFromSourceSchemas(schema, schemas)
+
+  return schema
+}
+
+function combineArraySchemas(schemas: any[]): any {
+  if (!schemas || schemas.length === 0) {
+    return undefined
+  }
+  const itemSchemas: any[] = []
+  for (const schema of schemas) {
+    if (!schema.items) continue
+    const unwrappedSchemas = unwrapSchema(schema.items)
+    itemSchemas.push(...unwrappedSchemas)
+  }
+
+  const schema = <any>{
+    type: 'array',
+  }
+  addTitleFromSourceSchemas(schema, schemas)
+
+  if (itemSchemas.length > 0) {
+    schema.items = combineSchemas(itemSchemas)
+  }
+  return schema
+}
+
+function combineObjectSchemas(schemas: any[]): any {
+  if (!schemas || schemas.length === 0) {
+    return undefined
+  }
+  const allPropSchemas = schemas.map((s) => s.properties).filter(Boolean)
+  const schemasByProp: Record<string, any[]> = Object.create(null)
+  // const schemasByProp: Record<string, any[]> = {};
+  for (const propSchemas of allPropSchemas) {
+    for (const [prop, schema] of Object.entries(propSchemas)) {
+      if (!schemasByProp[prop]) {
+        schemasByProp[prop] = []
+      }
+      const unwrappedSchemas = unwrapSchema(schema)
+      schemasByProp[prop].push(...unwrappedSchemas)
+    }
+  }
+
+  const properties: Record<string, any> = Object.entries(schemasByProp).reduce(
+    (props, [prop, schemas]) => {
+      if (schemas.length === 1) {
+        props[prop] = schemas[0]
+      } else {
+        props[prop] = combineSchemas(schemas)
+      }
+      return props
+    },
+    {},
+  )
+
+  const combinedSchema: any = {
+    type: 'object',
+  }
+  addTitleFromSourceSchemas(combinedSchema, schemas)
+
+  if (Object.keys(properties).length > 0) {
+    combinedSchema.properties = properties
+  }
+
+  return combinedSchema
+}
+
+export function unwrapSchema(schema: any): any[] {
+  if (!schema) return []
+  if (schema.anyOf) {
+    return unwrapSchemas(schema.anyOf)
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.map((x) => ({ type: x }))
+  }
+  return [schema]
+}
+
+export function unwrapSchemas(schemas: any[]): any[] {
+  if (!schemas || schemas.length === 0) return []
+  const unwrappedSchemas = schemas.flatMap((schema) => unwrapSchema(schema))
+  return unwrappedSchemas
+}
+
+export function wrapAnyOfSchema(schema: any): any {
+  const simpleSchemas = []
+  const complexSchemas = []
+  for (const subSchema of schema.anyOf) {
+    if (Array.isArray(subSchema.type)) {
+      simpleSchemas.push(...subSchema.type)
+    } else if (isSimpleSchema(subSchema)) {
+      simpleSchemas.push((subSchema as any).type)
+    } else {
+      complexSchemas.push(subSchema)
+    }
+  }
+  if (complexSchemas.length === 0) {
+    return { type: simpleSchemas }
+  }
+  const anyOf = []
+  if (simpleSchemas.length > 0) {
+    anyOf.push({
+      type: simpleSchemas.length > 1 ? simpleSchemas : simpleSchemas[0],
+    })
+  }
+  anyOf.push(...complexSchemas)
+  return { anyOf }
+}
+
+function isSimpleSchema(schema: any): boolean {
+  const keys = Object.keys(schema)
+  return keys.length === 1 && keys[0] === 'type'
+}
+
+// FACADE
+
+export function createSchema(value: any): any {
+  if (typeof value === 'undefined') value = null
+  const clone = JSON.parse(JSON.stringify(value))
+  return createSchemaFor(clone)
+}
+
+export function mergeSchemas(schemas: any[]): any {
+  const mergedSchema = combineSchemas(schemas)
+  return mergedSchema
+}
+
+export function extendSchema(schema: any, value: any): any {
+  const valueSchema = createSchema(value)
+  const mergedSchema = combineSchemas([schema, valueSchema])
+  return mergedSchema
+}
+
+export function createCompoundSchema(values: any[]): any {
+  const schemas = values.map((value) => createSchema(value))
+  return mergeSchemas(schemas)
+}
+
+function addTitleFromSourceSchemas(schema: any, schemas: any[]) {
+  const title = schemas.filter((s) => !!s.title)[0]?.title
+  if (title) {
+    schema.title = title
+  }
+}

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

@@ -0,0 +1,11 @@
+import { isJWT } from './jwt'
+
+describe('JWT', () => {
+  it('should treat valid token as valid', () => {
+    expect(
+      isJWT(
+        'eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjYwZGQxYTU3MGRmZTk3MDAwOTAyZjY1NiIsImVtYWlsIjoiZGFuaWlsQGludGVncmF0aW9uLmFwcCIsIm5hbWUiOiJEYW5paWwgQnJhdGNoZW5rbyIsImRlZmF1bHRBY2NvdW50SWQiOiI2MGRkMWIyZTMwOWE1ODAwMDkwNzc2NGIiLCJkZWZhdWx0QXBwSWQiOiI2MTQyMGYyNmEyNTI4MzE0YmM3NTYwZTgiLCJ1c2VyIjp7ImlkIjoiNjBkZDFhNTcwZGZlOTcwMDA5MDJmNjU2IiwiZW1haWwiOiJkYW5paWxAaW50ZWdyYXRpb24uYXBwIiwibmFtZSI6IkRhbmlpbCBCcmF0Y2hlbmtvIiwiZGVmYXVsdEFjY291bnRJZCI6IjYwZGQxYjJlMzA5YTU4MDAwOTA3NzY0YiIsImRlZmF1bHRBcHBJZCI6IjYxNDIwZjI2YTI1MjgzMTRiYzc1NjBlOCIsImlzQWRtaW4iOnRydWV9LCJpc3MiOiJlOTI2YTI1OS0xNTM2LTQxYTUtOWVmMy03MDhkNzdiNjI2ODkiLCJleHAiOjE2Mzk3MzUxMTF9.s3sUNns-5mVi7e2y4nc7Mmm0-Bq4MqEbFxhYOxzDig4',
+      ),
+    ).toBe(true)
+  })
+})

package/node_modules/@integration-app/sdk/src/jwt.ts

@@ -0,0 +1,40 @@
+export function isJWT(token: string): boolean {
+  if (typeof token !== 'string') return false
+
+  const splittedToken = token.split('.')
+  if (splittedToken.length !== 3) return false
+
+  try {
+    JSON.parse(decodeBase64(splittedToken[0]))
+  } catch (e) {
+    return false
+  }
+
+  return true
+}
+
+function decodeBase64(s) {
+  const e = {},
+    L = s.length,
+    w = String.fromCharCode
+  let i,
+    b = 0,
+    c,
+    x,
+    l = 0,
+    a,
+    r = ''
+  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  for (i = 0; i < 64; i++) {
+    e[A.charAt(i)] = i
+  }
+  for (x = 0; x < L; x++) {
+    c = e[s.charAt(x)]
+    b = (b << 6) + c
+    l += 6
+    while (l >= 8) {
+      ;((a = (b >>> (l -= 8)) & 0xff) || x < L - 2) && (r += w(a))
+    }
+  }
+  return r
+}