Intercom Connector: Models & Skeleton to manage connector object (#2564)

* Intercom Connector: Models & Skeleton to manage connector object

* Apply feedback

Author: PopDaph

connectors/package-lock.json

@@ -35,6 +35,7 @@
     "fs-extra": "^11.1.1",
     "googleapis": "^118.0.0",
     "hot-shots": "^10.0.0",
+    "intercom-client": "^4.0.0",
     "io-ts": "^2.2.20",
     "io-ts-reporters": "^2.0.1",
     "lodash.get": "^4.4.2",

connectors/package.json

@@ -22,6 +22,10 @@ import {
   SlackConfiguration,
   SlackMessages,
 } from "@connectors/lib/models";
+import {
+  IntercomArticle,
+  IntercomCollection,
+} from "@connectors/lib/models/intercom";
 import logger from "@connectors/logger/logger";
 
 async function main(): Promise<void> {
@@ -44,6 +48,8 @@ async function main(): Promise<void> {
   await NotionConnectorPageCacheEntry.sync({ alter: true });
   await NotionConnectorResourcesToCheckCacheEntry.sync({ alter: true });
   await GoogleDriveConfig.sync({ alter: true });
+  await IntercomCollection.sync({ alter: true });
+  await IntercomArticle.sync({ alter: true });
 
   // enable the `unaccent` extension
   await sequelize_conn.query("CREATE EXTENSION IF NOT EXISTS unaccent;");

connectors/src/admin/db.ts

@@ -20,6 +20,16 @@ import {
   updateGoogleDriveConnector,
 } from "@connectors/connectors/google_drive";
 import { launchGoogleDriveFullSyncWorkflow } from "@connectors/connectors/google_drive/temporal/client";
+import {
+  cleanupIntercomConnector,
+  createIntercomConnector,
+  fullResyncIntercomConnector,
+  resumeIntercomConnector,
+  retrieveIntercomConnectorPermissions,
+  retrieveIntercomResourcesTitles,
+  stopIntercomConnector,
+  updateIntercomConnector,
+} from "@connectors/connectors/intercom";
 import {
   BotEnabledGetter,
   BotToggler,
@@ -73,6 +83,7 @@ export const CREATE_CONNECTOR_BY_TYPE: Record<
   notion: createNotionConnector,
   github: createGithubConnector,
   google_drive: createGoogleDriveConnector,
+  intercom: createIntercomConnector,
 };
 
 export const UPDATE_CONNECTOR_BY_TYPE: Record<
@@ -83,6 +94,7 @@ export const UPDATE_CONNECTOR_BY_TYPE: Record<
   notion: updateNotionConnector,
   github: updateGithubConnector,
   google_drive: updateGoogleDriveConnector,
+  intercom: updateIntercomConnector,
 };
 
 export const STOP_CONNECTOR_BY_TYPE: Record<
@@ -99,6 +111,7 @@ export const STOP_CONNECTOR_BY_TYPE: Record<
     logger.info({ connectorId }, `Stopping Google Drive connector is a no-op.`);
     return new Ok(connectorId);
   },
+  intercom: stopIntercomConnector,
 };
 
 export const DELETE_CONNECTOR_BY_TYPE: Record<
@@ -109,6 +122,7 @@ export const DELETE_CONNECTOR_BY_TYPE: Record<
   notion: cleanupNotionConnector,
   github: cleanupGithubConnector,
   google_drive: cleanupGoogleDriveConnector,
+  intercom: cleanupIntercomConnector,
 };
 
 export const RESUME_CONNECTOR_BY_TYPE: Record<
@@ -124,6 +138,7 @@ export const RESUME_CONNECTOR_BY_TYPE: Record<
   google_drive: async (connectorId: string) => {
     throw new Error(`Not implemented ${connectorId}`);
   },
+  intercom: resumeIntercomConnector,
 };
 
 const toggleBotNotImplemented = async (
@@ -139,6 +154,7 @@ export const TOGGLE_BOT_BY_TYPE: Record<ConnectorProvider, BotToggler> = {
   notion: toggleBotNotImplemented,
   github: toggleBotNotImplemented,
   google_drive: toggleBotNotImplemented,
+  intercom: toggleBotNotImplemented,
 };
 
 const getBotEnabledNotImplemented = async (
@@ -159,6 +175,7 @@ export const GET_BOT_ENABLED_BY_TYPE: Record<
   notion: getBotEnabledNotImplemented,
   github: getBotEnabledNotImplemented,
   google_drive: getBotEnabledNotImplemented,
+  intercom: getBotEnabledNotImplemented,
 };
 
 export const SYNC_CONNECTOR_BY_TYPE: Record<ConnectorProvider, SyncConnector> =
@@ -167,6 +184,7 @@ export const SYNC_CONNECTOR_BY_TYPE: Record<ConnectorProvider, SyncConnector> =
     notion: fullResyncNotionConnector,
     github: fullResyncGithubConnector,
     google_drive: launchGoogleDriveFullSyncWorkflow,
+    intercom: fullResyncIntercomConnector,
   };
 
 export const RETRIEVE_CONNECTOR_PERMISSIONS_BY_TYPE: Record<
@@ -177,6 +195,7 @@ export const RETRIEVE_CONNECTOR_PERMISSIONS_BY_TYPE: Record<
   github: retrieveGithubConnectorPermissions,
   notion: retrieveNotionConnectorPermissions,
   google_drive: retrieveGoogleDriveConnectorPermissions,
+  intercom: retrieveIntercomConnectorPermissions,
 };
 
 export const SET_CONNECTOR_PERMISSIONS_BY_TYPE: Record<
@@ -195,6 +214,13 @@ export const SET_CONNECTOR_PERMISSIONS_BY_TYPE: Record<
     );
   },
   google_drive: setGoogleDriveConnectorPermissions,
+  intercom: async () => {
+    return new Err(
+      new Error(
+        `Setting Intercom connector permissions is not implemented yet.`
+      )
+    );
+  },
 };
 
 export const BATCH_RETRIEVE_RESOURCE_TITLE_BY_TYPE: Record<
@@ -205,6 +231,7 @@ export const BATCH_RETRIEVE_RESOURCE_TITLE_BY_TYPE: Record<
   notion: retrieveNotionResourcesTitles,
   github: retrieveGithubReposTitles,
   google_drive: retrieveGoogleDriveObjectsTitles,
+  intercom: retrieveIntercomResourcesTitles,
 };
 
 export const RETRIEVE_RESOURCE_PARENTS_BY_TYPE: Record<
@@ -215,6 +242,7 @@ export const RETRIEVE_RESOURCE_PARENTS_BY_TYPE: Record<
   google_drive: retrieveGoogleDriveObjectsParents,
   slack: async () => new Ok([]), // Slack is flat
   github: async () => new Ok([]), // Github is flat,
+  intercom: async () => new Ok([]), // Intercom is not truly flat as we can put articles & collections inside collections but will handle this later
 };
 
 export const SET_CONNECTOR_CONFIG_BY_TYPE: Record<
@@ -231,6 +259,9 @@ export const SET_CONNECTOR_CONFIG_BY_TYPE: Record<
     throw new Error("Not implemented");
   },
   google_drive: setGoogleDriveConfig,
+  intercom: async () => {
+    throw new Error("Not implemented");
+  },
 };
 
 export const GET_CONNECTOR_CONFIG_BY_TYPE: Record<
@@ -247,4 +278,7 @@ export const GET_CONNECTOR_CONFIG_BY_TYPE: Record<
     throw new Error("Not implemented");
   },
   google_drive: getGoogleDriveConfig,
+  intercom: async () => {
+    throw new Error("Not implemented");
+  },
 };

connectors/src/connectors/index.ts

@@ -0,0 +1,113 @@
+import { validateAccessToken } from "@connectors/connectors/intercom/lib/intercom_api";
+import { ConnectorPermissionRetriever } from "@connectors/connectors/interface";
+import { Connector, ModelId } from "@connectors/lib/models";
+import { getAccessTokenFromNango } from "@connectors/lib/nango_helpers";
+import { Err, Ok, Result } from "@connectors/lib/result";
+import logger from "@connectors/logger/logger";
+import { DataSourceConfig } from "@connectors/types/data_source_config";
+import { ConnectorsAPIErrorResponse } from "@connectors/types/errors";
+import { NangoConnectionId } from "@connectors/types/nango_connection_id";
+import {
+  ConnectorPermission,
+  ConnectorResource,
+} from "@connectors/types/resources";
+
+const { NANGO_INTERCOM_CONNECTOR_ID } = process.env;
+
+export async function createIntercomConnector(
+  dataSourceConfig: DataSourceConfig,
+  connectionId: NangoConnectionId
+): Promise<Result<string, Error>> {
+  const nangoConnectionId = connectionId;
+
+  if (!NANGO_INTERCOM_CONNECTOR_ID) {
+    throw new Error("NANGO_INTERCOM_CONNECTOR_ID not set");
+  }
+
+  const accessToken = await getAccessTokenFromNango({
+    connectionId: nangoConnectionId,
+    integrationId: NANGO_INTERCOM_CONNECTOR_ID,
+    useCache: false,
+  });
+
+  if (!validateAccessToken(accessToken)) {
+    return new Err(new Error("Intercom access token is invalid"));
+  }
+
+  try {
+    const connector = await Connector.create({
+      type: "intercom",
+      connectionId: nangoConnectionId,
+      workspaceAPIKey: dataSourceConfig.workspaceAPIKey,
+      workspaceId: dataSourceConfig.workspaceId,
+      dataSourceName: dataSourceConfig.dataSourceName,
+      defaultNewResourcePermission: "read_write",
+    });
+    // @todo Daph lauch workflow await launchIntercomSyncWorkflow(connector.id);
+    return new Ok(connector.id.toString());
+  } catch (e) {
+    logger.error({ error: e }, "Error creating Intercom connector.");
+    return new Err(e as Error);
+  }
+}
+
+export async function updateIntercomConnector(
+  connectorId: ModelId,
+  {
+    connectionId,
+    newDefaultNewResourcePermission,
+  }: {
+    connectionId?: NangoConnectionId | null;
+    newDefaultNewResourcePermission?: ConnectorPermission | null;
+  }
+): Promise<Result<string, ConnectorsAPIErrorResponse>> {
+  console.log({ connectorId, connectionId, newDefaultNewResourcePermission });
+  throw new Error("Not implemented");
+}
+
+export async function cleanupIntercomConnector(
+  connectorId: string
+): Promise<Result<void, Error>> {
+  console.log({ connectorId });
+  throw new Error("Not implemented");
+}
+
+export async function stopIntercomConnector(
+  connectorId: string
+): Promise<Result<string, Error>> {
+  console.log({ connectorId });
+  throw new Error("Not implemented");
+}
+
+export async function resumeIntercomConnector(
+  connectorId: string
+): Promise<Result<string, Error>> {
+  console.log({ connectorId });
+  throw new Error("Not implemented");
+}
+
+export async function fullResyncIntercomConnector(
+  connectorId: string,
+  fromTs: number | null
+): Promise<Result<string, Error>> {
+  console.log({ connectorId, fromTs });
+  throw new Error("Not implemented");
+}
+
+export async function retrieveIntercomConnectorPermissions({
+  connectorId,
+  parentInternalId,
+}: Parameters<ConnectorPermissionRetriever>[0]): Promise<
+  Result<ConnectorResource[], Error>
+> {
+  console.log({ connectorId, parentInternalId });
+  throw new Error("Not implemented");
+}
+
+export async function retrieveIntercomResourcesTitles(
+  connectorId: ModelId,
+  internalIds: string[]
+): Promise<Result<Record<string, string | null>, Error>> {
+  console.log({ connectorId, internalIds });
+  throw new Error("Not implemented");
+}

connectors/src/connectors/intercom/index.ts

@@ -0,0 +1,13 @@
+import { Client } from "intercom-client";
+
+export async function validateAccessToken(intercomAccessToken: string) {
+  const intercomClient = new Client({
+    tokenAuth: { token: intercomAccessToken },
+  });
+  try {
+    await intercomClient.admins.list(); // trying a simple request
+  } catch (e) {
+    return false;
+  }
+  return true;
+}