@integration-app/react 0.1.2 → 0.1.4

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

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

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

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