@integration-app/react 0.1.1 → 0.1.2

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

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

@@ -1,43 +0,0 @@
-import activitySpec from './activities'
-
-describe('udm/activities', () => {
-  it('should populate empty dates', () => {
-    expect(
-      activitySpec.populateFields({
-        dueTime: null,
-        startTime: '2020-01-01T00:00:00.000Z',
-        endTime: null,
-      }),
-    ).toEqual({
-      dueTime: '2020-01-01T00:00:00.000Z',
-      startTime: '2020-01-01T00:00:00.000Z',
-      endTime: '2020-01-01T00:00:00.000Z',
-    })
-  }),
-    it('should not populate empty dates if there is nothing to be populated', () => {
-      expect(
-        activitySpec.populateFields({
-          dueTime: null,
-          startTime: null,
-          endTime: null,
-        }),
-      ).toEqual({
-        dueTime: null,
-        startTime: null,
-        endTime: null,
-      })
-    }),
-    it('should not mess up w/ existing values', () => {
-      expect(
-        activitySpec.populateFields({
-          dueTime: '2022-01-01T00:00:00.000Z',
-          startTime: '2020-01-01T00:00:00.000Z',
-          endTime: '2021-01-01T00:00:00.000Z',
-        }),
-      ).toEqual({
-        dueTime: '2022-01-01T00:00:00.000Z',
-        startTime: '2020-01-01T00:00:00.000Z',
-        endTime: '2021-01-01T00:00:00.000Z',
-      })
-    })
-})

package/node_modules/@integration-app/sdk/src/udm/activities.ts

@@ -1,83 +0,0 @@
-import { Static, Type } from '@sinclair/typebox'
-import { UnifiedDataModel } from './base'
-
-export const FIELDS_SCHEMA = Type.Partial(
-  Type.Object({
-    title: Type.String(),
-    description: Type.String(),
-    type: Type.String(),
-    durationSeconds: Type.Number(),
-    location: Type.String(),
-    isRecurrent: Type.Boolean(),
-    participants: Type.Array(
-      Type.Object({
-        userId: Type.String(),
-        contactId: Type.String(),
-      }),
-    ),
-    status: Type.String(),
-    contactId: Type.String({
-      referenceUdm: 'contacts',
-    }),
-    companyId: Type.String({
-      referenceUdm: 'companies',
-    }),
-    dealId: Type.String({
-      referenceUdm: 'deals',
-    }),
-    leadId: Type.String({
-      referenceUdm: 'leads',
-    }),
-    ownerId: Type.String({
-      referenceUdm: 'users',
-    }),
-    startTime: Type.String({ format: 'date-time' }),
-    endTime: Type.String({ format: 'date-time' }),
-    dueTime: Type.String({ format: 'date-time' }),
-    createdTime: Type.String({ format: 'date-time' }),
-    createdBy: Type.String({
-      referenceUdm: 'users',
-    }),
-    updatedTime: Type.String({ format: 'date-time' }),
-    updatedBy: Type.String({
-      referenceUdm: 'users',
-    }),
-  }),
-)
-
-export type UnifiedActivityFields = Static<typeof FIELDS_SCHEMA>
-
-const udm: UnifiedDataModel = {
-  singularName: 'activity',
-  pluralName: 'activities',
-  fieldsSchema: FIELDS_SCHEMA,
-  create: {
-    excludedFields: ['createdTime', 'createdBy', 'updatedTime', 'updatedBy'],
-  },
-  update: {
-    excludedFields: ['createdTime', 'createdBy', 'updatedTime', 'updatedBy'],
-  },
-  populateFields,
-}
-
-export default udm
-
-function populateFields(fields: UnifiedActivityFields): UnifiedActivityFields {
-  const result = JSON.parse(JSON.stringify(fields))
-  /*
-   * If Due Date is empty, set it into End Date (if set) or Start Date
-   * If Start Date is empty, set it into Due Date or End Date
-   * If End Date is empty, set it into Due Date or Start Date
-   */
-  if (!result.dueTime) {
-    result.dueTime = result.endTime || result.startTime
-  }
-  if (!result.startTime) {
-    result.startTime = result.dueTime || result.endTime
-  }
-  if (!result.endTime) {
-    result.endTime = result.dueTime || result.startTime
-  }
-
-  return result
-}

package/node_modules/@integration-app/sdk/src/udm/base.ts

@@ -1,88 +0,0 @@
-import { Type } from '@sinclair/typebox'
-import phone from 'phone'
-import {
-  DataCollectionCreateSpec,
-  DataCollectionDeleteSpec,
-  DataCollectionFindSpec,
-  DataCollectionUpdateSpec,
-} from '../connector-api'
-
-export interface UnifiedDataModel {
-  singularName: string
-  pluralName: string
-  fieldsSchema: any
-  /**
-   * Normalize field values. For example, normalize phone numbers to E.164 format.
-   */
-  normalizeFields?: (fields: Record<string, any>) => Record<string, any>
-  /**
-   * Using dependencies between fields, populates missing fields.
-   * For example, if primaryEmail is missing, it will be populated from emails.
-   */
-  populateFields?: (fields: Record<string, any>) => Record<string, any>
-  find?: DataCollectionFindSpec
-  create?: DataCollectionCreateSpec
-  update?: DataCollectionUpdateSpec
-  delete?: DataCollectionDeleteSpec
-}
-
-export const AddressSchema = Type.Object({
-  type: Type.String(),
-  full: Type.String(),
-  street: Type.String(),
-  city: Type.String(),
-  state: Type.String(),
-  country: Type.String(),
-  zip: Type.String(),
-})
-
-export const PhoneEmailSchema = Type.Object({
-  value: Type.String(),
-  type: Type.String(),
-})
-
-export function normalizePhone(value: string): string {
-  if (typeof value !== 'string') {
-    return value
-  }
-  const validationResult = phone(value)
-  if (validationResult.isValid) {
-    return validationResult.phoneNumber
-  } else {
-    // By default, just remove all the non-phone-number symbols from the value
-    const hasPlus = value.trim().startsWith('+')
-    let result = value.replace(/[^\d]/g, '')
-    if (hasPlus) {
-      result = `+${result}`
-    }
-    return result
-  }
-}
-
-export function populateContactInfo(
-  fields: Record<string, any>,
-): Record<string, any> {
-  const result = JSON.parse(JSON.stringify(fields))
-  if (!result.fullName && result.firstName && result.lastName) {
-    result.fullName = {
-      $concat: {
-        values: [result.firstName, result.lastName],
-        delimiter: ' ',
-      },
-    }
-  }
-  if (!result.primaryEmail && result.emails && result.emails.length > 0) {
-    result.primaryEmail = result.emails[0].value
-  }
-  if (!result.primaryPhone && result.phones && result.phones.length > 0) {
-    result.primaryPhone = result.phones[0].value
-  }
-  if (
-    !result.primaryAddress &&
-    result.addresses &&
-    result.addresses.length > 0
-  ) {
-    result.primaryAddress = result.addresses[0]
-  }
-  return result
-}

package/node_modules/@integration-app/sdk/src/udm/campaigns.ts

@@ -1,72 +0,0 @@
-import { Static, Type } from '@sinclair/typebox'
-import { UnifiedDataModel } from './base'
-
-const FIELDS_SCHEMA = Type.Partial(
-  Type.Object({
-    name: Type.String(),
-    cost: Type.Number(),
-    description: Type.String(),
-    source: Type.String(),
-    stage: Type.String(),
-    type: Type.String(),
-    ownerId: Type.String({
-      referenceUdm: 'users',
-    }),
-    sentCount: Type.Number(),
-    replyCount: Type.Number(),
-    openCount: Type.Number(),
-    clickCount: Type.Number(),
-    startTime: Type.String({
-      format: 'date-time',
-    }),
-    endTime: Type.String({
-      format: 'date-time',
-    }),
-    createdTime: Type.String({
-      format: 'date-time',
-    }),
-    createdBy: Type.String({
-      referenceUdm: 'users',
-    }),
-    updatedTime: Type.String({
-      format: 'date-time',
-    }),
-    updatedBy: Type.String({
-      referenceUdm: 'users',
-    }),
-    lastActivityTime: Type.String({
-      format: 'date-time',
-    }),
-  }),
-)
-
-export type UnifiedCampaignFields = Static<typeof FIELDS_SCHEMA>
-
-const MODIFIABLE_FIELDS = [
-  'name',
-  'description',
-  'ownerId',
-  'startTime',
-  'endTime',
-  'cost',
-  'source',
-  'stage',
-  'type',
-]
-
-const udm: UnifiedDataModel = {
-  singularName: 'campaign',
-  pluralName: 'campaigns',
-  fieldsSchema: FIELDS_SCHEMA,
-  find: {
-    queryFields: ['name', 'ownerId', 'source', 'stage', 'type'],
-  },
-  create: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  update: {
-    fields: MODIFIABLE_FIELDS,
-  },
-}
-
-export default udm

package/node_modules/@integration-app/sdk/src/udm/companies.ts

@@ -1,80 +0,0 @@
-import { Static, Type } from '@sinclair/typebox'
-import {
-  AddressSchema,
-  normalizePhone,
-  PhoneEmailSchema,
-  UnifiedDataModel,
-} from './base'
-
-const FIELDS_SCHEMA = Type.Partial(
-  Type.Object({
-    name: Type.String(),
-    websiteUrl: Type.String(),
-    phones: Type.Array(PhoneEmailSchema),
-    primaryPhone: Type.String(),
-    description: Type.String(),
-    currency: Type.String(),
-    industry: Type.String(),
-    ownerId: Type.String({
-      referenceUdm: 'users',
-    }),
-    primaryAddress: AddressSchema,
-    addresses: Type.Array(AddressSchema),
-    numberOfEmployees: Type.Number(),
-    createdTime: Type.String({ format: 'date-time' }),
-    createdBy: Type.String({
-      referenceUdm: 'users',
-    }),
-    updatedTime: Type.String({ format: 'date-time' }),
-    updatedBy: Type.String({
-      referenceUdm: 'users',
-    }),
-    lastActivityTime: Type.String({ format: 'date-time' }),
-  }),
-)
-
-export type UnifiedCompanyFields = Static<typeof FIELDS_SCHEMA>
-
-const MODIFIABLE_FIELDS = [
-  'addresses',
-  'currency',
-  'description',
-  'industry',
-  'name',
-  'numberOfEmployees',
-  'ownerId',
-  'primaryAddress',
-  'primaryPhone',
-  'websiteUrl',
-]
-
-const udm: UnifiedDataModel = {
-  singularName: 'company',
-  pluralName: 'companies',
-  fieldsSchema: FIELDS_SCHEMA,
-  find: {
-    queryFields: ['name', 'primaryAddress', 'primaryPhone'],
-  },
-  create: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  update: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  normalizeFields,
-}
-
-export default udm
-
-function normalizeFields(fields: UnifiedCompanyFields): UnifiedCompanyFields {
-  const result = JSON.parse(JSON.stringify(fields))
-  if (result.primaryPhone) {
-    result.primaryPhone = normalizePhone(result.primaryPhone)
-  }
-  if (result.phones) {
-    result.phones.forEach((phone) => {
-      phone.value = normalizePhone(phone.value)
-    })
-  }
-  return result
-}