@integration-app/react 0.1.1

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

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

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

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

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

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

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

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

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