@integration-app/react 0.1.4 → 0.1.6

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

@@ -1,167 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`SchemaBuilder generation all cases combined should generate valid schemas for complex objects 1`] = `
-Object {
-  "items": Object {
-    "properties": Object {
-      "lvl1PropNum": Object {
-        "type": "number",
-      },
-      "lvl1PropObj1": Object {
-        "properties": Object {
-          "lvl2PropArr": Object {
-            "items": Object {
-              "type": Array [
-                "boolean",
-                "number",
-                "string",
-              ],
-            },
-            "type": "array",
-          },
-        },
-        "type": "object",
-      },
-      "lvl1PropObj2": Object {
-        "properties": Object {
-          "lvl2PropArr1": Object {
-            "items": Object {
-              "type": "integer",
-            },
-            "type": "array",
-          },
-          "lvl2PropArr2": Object {
-            "items": Object {
-              "anyOf": Array [
-                Object {
-                  "type": Array [
-                    "integer",
-                    "string",
-                  ],
-                },
-                Object {
-                  "items": Object {
-                    "type": Array [
-                      "boolean",
-                      "integer",
-                    ],
-                  },
-                  "type": "array",
-                },
-                Object {
-                  "properties": Object {
-                    "lvl3PropNum1": Object {
-                      "type": "number",
-                    },
-                    "lvl3PropStr1": Object {
-                      "type": "string",
-                    },
-                  },
-                  "type": "object",
-                },
-              ],
-            },
-            "type": "array",
-          },
-          "lvl2PropNum1": Object {
-            "type": "integer",
-          },
-          "six": Object {},
-        },
-        "type": "object",
-      },
-      "lvl1PropStr": Object {
-        "type": "string",
-      },
-    },
-    "type": "object",
-  },
-  "type": "array",
-}
-`;
-
-exports[`SchemaBuilder generation circular refs should throw an error w/ explanation 1`] = `
-"Converting circular structure to JSON
-    --> starting at object with constructor 'Object'
-    |     property 'b' -> object with constructor 'Object'
-    --- property 'a' closes the circle"
-`;
-
-exports[`SchemaBuilder generation nested array complex end-to-end case: should generate schema for nested arrays and simplify anyOf 1`] = `
-Object {
-  "items": Object {
-    "anyOf": Array [
-      Object {
-        "type": Array [
-          "integer",
-          "string",
-        ],
-      },
-      Object {
-        "items": Object {
-          "anyOf": Array [
-            Object {
-              "type": Array [
-                "integer",
-                "string",
-                "object",
-              ],
-            },
-            Object {
-              "items": Object {
-                "type": "number",
-              },
-              "type": "array",
-            },
-          ],
-        },
-        "type": "array",
-      },
-    ],
-  },
-  "type": "array",
-}
-`;
-
-exports[`SchemaBuilder generation nested objects/arrays should combine object schemas and respect required property 1`] = `
-Object {
-  "properties": Object {
-    "one": Object {
-      "type": "integer",
-    },
-    "three": Object {
-      "properties": Object {
-        "five": Object {
-          "items": Object {
-            "type": "integer",
-          },
-          "type": "array",
-        },
-        "four": Object {
-          "type": "integer",
-        },
-        "seven": Object {
-          "items": Object {
-            "properties": Object {
-              "eight": Object {
-                "type": "number",
-              },
-              "nine": Object {
-                "type": "string",
-              },
-            },
-            "type": "object",
-          },
-          "type": "array",
-        },
-        "six": Object {},
-      },
-      "type": "object",
-    },
-    "two": Object {
-      "type": "string",
-    },
-  },
-  "type": "object",
-}
-`;

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

@@ -1,251 +0,0 @@
-export enum JSONSchemaType {
-  Null = 'null',
-  Boolean = 'boolean',
-  Integer = 'integer',
-  Number = 'number',
-  String = 'string',
-  Object = 'object',
-  Array = 'array',
-}
-
-export type JSONSchemaTypeStr =
-  | 'null'
-  | 'boolean'
-  | 'integer'
-  | 'number'
-  | 'string'
-  | 'object'
-  | 'array'
-
-export type JSONSchema = {
-  type?: JSONSchemaTypeStr | JSONSchemaTypeStr[]
-  items?: JSONSchema
-  maxItems?: number // Maximum observed number of items in an array
-  properties?: Record<string, JSONSchema>
-  required?: string[]
-  anyOf?: Array<JSONSchema>
-  examples?: any[] // Examples of values (only for scalars)
-  title?: string
-  enum?: any[]
-  format?: string
-  $ref?: string
-}
-
-export type SchemaComparisonOptions = {
-  ignoreRequired: boolean
-}
-
-/**
- * Returns fields that are present in the `first` schema, but absent in the `second` schema.
- * Does not distinguish between types, i.e. schemaDiff({type: 'string'}, {type: 'number'}) === null.
- *
- * @param first
- * @param second
- */
-export function schemaDiff(first: JSONSchema, second: JSONSchema): JSONSchema {
-  if (!first) {
-    return null
-  } else if (first.type == JSONSchemaType.Object && first.properties) {
-    if (second?.type == JSONSchemaType.Object && second.properties) {
-      const diff: JSONSchema = {
-        type: JSONSchemaType.Object,
-        properties: {},
-      }
-      Object.keys(first.properties).forEach((key) => {
-        const keyDiff = schemaDiff(
-          first.properties[key],
-          second.properties[key],
-        )
-        if (keyDiff) {
-          diff.properties[key] = keyDiff
-        }
-      })
-      return Object.keys(diff.properties).length > 0 ? diff : null
-    } else {
-      // `first` is object ,but `second` is not object,
-      // so the whole `first` is missing.
-      return first
-    }
-  } else if (first.type == JSONSchemaType.Array && first.items) {
-    if (second?.type == JSONSchemaType.Array && second.items) {
-      const itemsDiff = schemaDiff(first.items, second.items)
-      if (itemsDiff) {
-        return {
-          type: JSONSchemaType.Array,
-          items: itemsDiff,
-        }
-      } else {
-        return null
-      }
-    } else {
-      return first
-    }
-  } else {
-    // Neither object nor array.
-    if (second) {
-      // As long as second is not empty, there is no difference.
-      return null
-    } else {
-      // Otherwise the whole `first` is a difference
-      return first
-    }
-  }
-}
-
-export function isScalar(schema) {
-  return (
-    schema.type != 'array' && schema.type != 'object' && schema.type != 'null'
-  )
-}
-
-export function schemaTypeFromValue(value: any) {
-  switch (typeof value) {
-    case 'object':
-      if (Array.isArray(value)) {
-        return 'array'
-      } else if (value === null) {
-        return 'null'
-      } else {
-        return 'object'
-      }
-    case 'boolean':
-      return 'boolean'
-    case 'bigint':
-    case 'number':
-      return 'number'
-    default:
-      return 'string'
-  }
-}
-
-/**
- * Removes part of the schema that are not user-visible (has userVisible set to false).
- */
-export function getUserVisibleSchema(schema: any) {
-  if (!schema || typeof schema !== 'object') {
-    return null
-  }
-
-  if (schema.userVisible === false) {
-    return null
-  }
-
-  if (schema.properties && typeof schema.properties === 'object') {
-    const userVisibleProperties = {}
-    Object.entries(schema.properties).forEach(([key, propertySchema]) => {
-      const userVisiblePropertySchema = getUserVisibleSchema(propertySchema)
-      if (userVisiblePropertySchema) {
-        userVisibleProperties[key] = userVisiblePropertySchema
-      }
-    })
-    return {
-      ...schema,
-      properties: userVisibleProperties,
-    }
-  }
-
-  if (schema.items) {
-    return {
-      ...schema,
-      items: getUserVisibleSchema(schema.items) ?? {},
-    }
-  }
-
-  return schema
-}
-
-/**
- * Extract `default` values from the whole schema.
- */
-export function getDefaultsFromSchema(schema) {
-  if (schema?.type === 'object' && schema.properties) {
-    const propDefaults = {}
-    for (const [key, value] of Object.entries(schema.properties)) {
-      const defaults = getDefaultsFromSchema(value)
-      if (defaults !== null && defaults !== undefined) {
-        propDefaults[key] = defaults
-      }
-    }
-    if (Object.keys(propDefaults).length > 0) {
-      return propDefaults
-    } else {
-      return undefined
-    }
-  } else {
-    return schema?.default
-  }
-}
-
-/**
- * Normalizes value to a provided schema by
- * converting scalars (strings, numbers, booleans) to each other whenever possible
- * and ignoring fields that are not in schema.
- */
-export function valueToSchema(value: any, schema: any, field = '') {
-  function throwError(message) {
-    throw new Error(`${message}${field ? ` for field ${field}` : ''}`)
-  }
-
-  if (value === null || value === undefined) {
-    return undefined
-  }
-
-  switch (schema?.type) {
-    case 'string':
-      return value?.toString()
-    case 'integer':
-    case 'number':
-      const result = Number(value)
-      if (result === NaN) {
-        throwError(`Cannot convert "${value}" to number`)
-      }
-      if (schema.type === 'integer' && !Number.isInteger(result)) {
-        throwError(`Expected integer but got ${value}`)
-      }
-      return result
-    case 'boolean':
-      if (typeof value === 'boolean') {
-        return value
-      } else if (typeof value === 'string') {
-        if (value === 'true') {
-          return true
-        } else if (value === 'false') {
-          return false
-        } else {
-          throwError(`Expected true or false but got "${value}"`)
-        }
-      } else if (value) {
-        throwError(`Expected true or false but got "${value}"`)
-      }
-      return undefined
-    case 'list':
-      if (Array.isArray(value)) {
-        return value.map((item) => valueToSchema(item, schema.items, field))
-      } else {
-        return undefined
-      }
-    case 'object':
-      if (typeof value === 'object' && value) {
-        const result = {}
-        for (const [key, fieldValue] of Object.entries(value)) {
-          const fieldSchema = schema?.properties?.[key]
-
-          if (!fieldSchema && schema && !schema.additionalProperties) {
-            // Property is not in schema - ignore it
-            continue
-          }
-
-          result[key] = valueToSchema(
-            fieldValue,
-            fieldSchema,
-            field ? `${field}.${key}` : key,
-          )
-        }
-        return result
-      } else {
-        return undefined
-      }
-    default:
-      return value
-  }
-}

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