@integration-app/react 0.1.3 → 0.1.5

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

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

@@ -1,258 +0,0 @@
-/*
-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

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

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