@integration-app/react 0.1.4 → 0.1.5

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

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

@@ -1,147 +0,0 @@
-import { buildData } from '../data-builder'
-import contactsSpec from './contacts'
-
-describe('udm/contacts', () => {
-  it('should normalize phones', () => {
-    expect(
-      contactsSpec.normalizeFields({
-        primaryPhone: '+1 (617) 123-45-67',
-        phones: [
-          {
-            value: '+1 (617) 123-45-67',
-            type: 'mobile',
-          },
-          {
-            value: '12345',
-            type: 'other',
-          },
-          {
-            value: '6134113122',
-            type: 'home',
-          },
-        ],
-      }),
-    ).toEqual({
-      primaryPhone: '+16171234567',
-      phones: [
-        {
-          value: '+16171234567',
-          type: 'mobile',
-        },
-        {
-          value: '12345',
-          type: 'other',
-        },
-        {
-          value: '+16134113122',
-          type: 'home',
-        },
-      ],
-    })
-  }),
-    it('should not normalize phones if there is nothing to be normalized', () => {
-      expect(
-        contactsSpec.normalizeFields({
-          phones: [],
-          primaryPhone: null,
-        }),
-      ).toEqual({
-        phones: [],
-        primaryPhone: null,
-      })
-    }),
-    it('should populate primary contact info', () => {
-      expect(
-        contactsSpec.populateFields({
-          primaryEmail: null,
-          primaryPhone: null,
-          emails: [
-            {
-              value: 'workEmail@gmail.com',
-              type: 'work',
-            },
-            {
-              value: 'otherEmail@gmail.com',
-              type: 'other',
-            },
-          ],
-          phones: [
-            {
-              value: '+16171234567',
-              type: 'mobile',
-            },
-            {
-              value: '12345',
-              type: 'other',
-            },
-            {
-              value: '+16134113122',
-              type: 'home',
-            },
-          ],
-        }),
-      ).toEqual({
-        primaryEmail: 'workEmail@gmail.com',
-        primaryPhone: '+16171234567',
-        emails: [
-          {
-            value: 'workEmail@gmail.com',
-            type: 'work',
-          },
-          {
-            value: 'otherEmail@gmail.com',
-            type: 'other',
-          },
-        ],
-        phones: [
-          {
-            value: '+16171234567',
-            type: 'mobile',
-          },
-          {
-            value: '12345',
-            type: 'other',
-          },
-          {
-            value: '+16134113122',
-            type: 'home',
-          },
-        ],
-      })
-    }),
-    it('should not populate primary contact info if there is nothing to be populated', () => {
-      expect(
-        contactsSpec.populateFields({
-          primaryEmail: null,
-          emails: [],
-        }),
-      ).toEqual({
-        primaryEmail: null,
-        emails: [],
-      })
-    }),
-    it('should populate fullName if firstName and lastName were set', async () => {
-      expect(
-        await buildData(
-          contactsSpec.populateFields({ firstName: 'John', lastName: 'Doe' }),
-        ),
-      ).toEqual({
-        firstName: 'John',
-        lastName: 'Doe',
-        fullName: 'John Doe',
-      })
-    }),
-    it('should not overwrite fullName if it has already been set', () => {
-      expect(
-        contactsSpec.populateFields({
-          firstName: 'John',
-          lastName: 'Doe',
-          fullName: 'Rachel Green',
-        }),
-      ).toEqual({
-        firstName: 'John',
-        lastName: 'Doe',
-        fullName: 'Rachel Green',
-      })
-    })
-})

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

@@ -1,106 +0,0 @@
-import { Static, Type } from '@sinclair/typebox'
-import {
-  AddressSchema,
-  normalizePhone,
-  PhoneEmailSchema,
-  populateContactInfo,
-  UnifiedDataModel,
-} from './base'
-
-const FIELDS_SCHEMA = Type.Partial(
-  Type.Object({
-    fullName: Type.String(),
-    firstName: Type.String(),
-    lastName: Type.String(),
-    primaryEmail: Type.String(),
-    emails: Type.Array(PhoneEmailSchema),
-    primaryPhone: Type.String(),
-    phones: Type.Array(PhoneEmailSchema),
-    primaryAddress: AddressSchema,
-    addresses: Type.Array(AddressSchema),
-    stage: Type.String(),
-    companyName: Type.String(),
-    companyId: Type.String({
-      referenceUdm: 'companies',
-    }),
-    ownerId: Type.String({
-      referenceUdm: 'users',
-    }),
-    jobTitle: Type.String(),
-    source: Type.String(),
-    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' }),
-  }),
-)
-
-const MODIFIABLE_FIELDS = [
-  'fullName',
-  'firstName',
-  'lastName',
-  'primaryEmail',
-  'primaryPhone',
-  'primaryAddress',
-  'companyId',
-  'companyName',
-  'jobTitle',
-  'source',
-  'stage',
-  'ownerId',
-  'emails',
-  'phones',
-  'addresses',
-]
-
-export type UnifiedContactFields = Static<typeof FIELDS_SCHEMA>
-
-const udm: UnifiedDataModel = {
-  singularName: 'contact',
-  pluralName: 'contacts',
-  fieldsSchema: FIELDS_SCHEMA,
-  find: {
-    queryFields: [
-      'fullName',
-      'firstName',
-      'lastName',
-      'primaryEmail',
-      'primaryPhone',
-      'primaryAddress',
-      'companyId',
-      'companyName',
-      'jobTitle',
-      'ownerId',
-    ],
-  },
-  create: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  update: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  normalizeFields,
-  populateFields: populateContactInfo,
-}
-
-export default udm
-
-function normalizeFields(fields: UnifiedContactFields): UnifiedContactFields {
-  const result = JSON.parse(JSON.stringify(fields))
-  if (result.primaryPhone) {
-    result.primaryPhone = normalizePhone(result.primaryPhone)
-  }
-  if (result.phones) {
-    result.phones.forEach((phone) => {
-      if (phone && typeof phone === 'object') {
-        phone.value = normalizePhone(phone.value)
-      }
-    })
-  }
-  return result
-}

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

@@ -1,90 +0,0 @@
-import { Static, Type } from '@sinclair/typebox'
-import { UnifiedDataModel } from './base'
-
-const FIELDS_SCHEMA = Type.Partial(
-  Type.Object({
-    name: Type.String(),
-    amount: Type.Number(),
-    currency: Type.String(),
-    companyId: Type.String({
-      referenceUdm: 'companies',
-    }),
-    contactId: Type.String({
-      referenceUdm: 'contacts',
-    }),
-    campaignId: Type.String({
-      referenceUdm: 'campaigns',
-    }),
-    source: Type.String(),
-    description: Type.String(),
-    stage: Type.String(),
-    status: Type.String({
-      enum: ['open', 'won', 'lost'],
-    }),
-    type: Type.String(),
-    ownerId: Type.String({
-      referenceUdm: 'users',
-    }),
-    closeTime: 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',
-    }),
-    probability: Type.Number(),
-  }),
-)
-
-export type UnifiedDealFields = Static<typeof FIELDS_SCHEMA>
-
-const MODIFIABLE_FIELDS = [
-  'amount',
-  'currency',
-  'companyId',
-  'contactId',
-  'campaignId',
-  'source',
-  'description',
-  'stage',
-  'status',
-  'type',
-  'ownerId',
-  'closeTime',
-]
-
-const udm: UnifiedDataModel = {
-  singularName: 'deal',
-  pluralName: 'deals',
-  fieldsSchema: FIELDS_SCHEMA,
-  find: {
-    queryFields: [
-      'companyId',
-      'contactId',
-      'campaignId',
-      'source',
-      'stage',
-      'type',
-      'ownerId',
-    ],
-  },
-  create: {
-    fields: MODIFIABLE_FIELDS,
-  },
-  update: {
-    fields: MODIFIABLE_FIELDS,
-  },
-}
-
-export default udm