@integration-app/react 0.1.1 → 0.1.2

package/node_modules/@integration-app/sdk/src/integrations/api.ts

@@ -1,13 +0,0 @@
-export interface IntegrationSelector {
-  integrationKey?: string
-
-  integrationId?: string
-}
-
-export interface CreateIntegrationRequest {
-  name: string
-}
-
-export interface UpdateIntegrationRequest {
-  name?: string
-}

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

@@ -1,50 +0,0 @@
-import { PaginationQuery, PaginationResponse } from '../entity-repository'
-import { Connection } from '../connections'
-
-export enum ConnectionMode {
-  POPUP = 'popup',
-  IFRAME = 'iframe',
-}
-
-export interface IntegrationAuth {
-  clientId: string
-
-  clientSecret: string
-
-  authorizeUri: string
-
-  tokenUri: string
-}
-
-export interface Integration {
-  /**
-   * Unique immutable id.
-   */
-  id: string
-
-  /**
-   * Integration key unique across its app.
-   */
-  key: string
-
-  /**
-   * User-readable name.
-   */
-  name: string
-
-  baseUri: string
-
-  auth: IntegrationAuth
-
-  logoUri: string
-
-  connectionMode?: ConnectionMode
-
-  connection?: Connection
-
-  archivedAt?: Date
-}
-
-export class FindIntegrationsQuery extends PaginationQuery {}
-
-export class FindIntegrationsResponse extends PaginationResponse<Integration> {}

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
-  }
-}