@vogent/vogent-web-client 0.0.1

package/__generated__/index.ts

@@ -0,0 +1 @@
+export * from "./gql";

package/codegen.ts

@@ -0,0 +1,29 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { CodegenConfig } from '@graphql-codegen/cli';
+
+const config: CodegenConfig = {
+  generates: {
+    './__generated__/': {
+      preset: 'client',
+      schema: 'https://api.getelto.com/query',
+      documents: ['*.ts'],
+      plugins: [
+        {
+          add: {
+            content: '/* eslint-disable */',
+          },
+        },
+      ],
+      presetConfig: {
+        gqlTagName: 'gql',
+        fragmentMasking: false,
+      },
+      config: {
+        dedupeFragments: true,
+      },
+    },
+  },
+  ignoreNoDocuments: true,
+};
+
+export default config;

package/devices/VogentDevice.ts

@@ -0,0 +1,12 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+export interface VogentCall {
+    on: (ev: 'mute' | 'disconnect', fn: (...args: any[]) => void) => void;
+    mute: (status: boolean) => void;
+    disconnect: () => void;
+    sendDigits: (k: string) => void;
+  }
+
+  export interface VogentDevice {
+    connect: (p: any) => Promise<VogentCall>;
+  }

package/devices/VonageDevice.ts

@@ -0,0 +1,103 @@
+import { VogentCall } from './VogentDevice';
+import { VonageClient, LoggingLevel } from '@vonage/client-sdk';
+
+export class VonageCall {
+  _callId: string;
+  _client: VonageClient;
+  _liveListen: boolean;
+  _params: any;
+  _handlers: {
+    ev: 'mute' | 'disconnect';
+    fn: (...args: any[]) => void;
+  }[];
+
+  constructor(callId: string, client: VonageClient, params: any) {
+    this._callId = callId;
+    this._client = client;
+    this._params = params;
+    this._handlers = [];
+
+    this._client.on('callHangup', (callId, _, reason) => {
+      if (callId !== this._callId) {
+        return;
+      }
+
+      console.log('Call status changed', reason, callId);
+
+      if (
+        !this._liveListen &&
+        (reason === 'REMOTE_HANGUP' || reason === 'REMOTE_NO_ANSWER_TIMEOUT')
+      ) {
+        console.log('Reconnecting');
+        this._client
+          .serverCall(this._params)
+          .then((cid: string) => {
+            this._callId = cid;
+          })
+          .catch((err) => {
+            console.error('Error reconnecting', err);
+            this.sendEvent('disconnect');
+          });
+      } else {
+        this.sendEvent('disconnect');
+      }
+    });
+  }
+
+  mute(status: boolean) {
+    if (status) {
+      this._client.mute(this._callId).then(() => {
+        this.sendEvent('mute', true);
+      });
+    } else {
+      this._client.unmute(this._callId).then(() => {
+        this.sendEvent('mute', false);
+      });
+    }
+  }
+
+  sendDigits(k: string) {
+    this._client.sendDTMF(this._callId, k);
+  }
+
+  disconnect() {
+    this._client.hangup(this._callId);
+  }
+
+  sendEvent(evName: string, ...args: any[]) {
+    for (const { ev, fn } of this._handlers) {
+      if (ev === evName) {
+        fn(...args);
+      }
+    }
+  }
+
+  on(ev: 'mute' | 'disconnect', fn: (...args: any[]) => void) {
+    this._handlers.push({
+      ev,
+      fn,
+    });
+  }
+}
+
+export class VonageDevice {
+  _sessionId: string;
+  _client: VonageClient;
+
+  private constructor(sessionId: string, client: VonageClient, liveListen = false) {
+    this._sessionId = sessionId;
+    this._client = client;
+  }
+
+  static async getDevice(sessionToken: string, disableEffects = false): Promise<VonageDevice> {
+    const client = new VonageClient({ loggingLevel: LoggingLevel.Warn });
+    const sessId = await client.createSession(sessionToken);
+    return new VonageDevice(sessId, client, disableEffects);
+  }
+
+  async connect(p: any): Promise<VogentCall> {
+    const call = await this._client.serverCall(p.params);
+    const v = new VonageCall(call, this._client, p.params);
+    return v;
+  }
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@vogent/vogent-web-client",
+  "version": "0.0.1",
+  "license": "MIT",
+  "dependencies": {
+    "@apollo/client": "^3.12.4",
+    "@vonage/client-sdk": "^1.7.2",
+    "graphql": "^16.10.0"
+  },
+  "devDependencies": {
+    "@graphql-codegen/cli": "^5.0.3",
+    "@graphql-codegen/client-preset": "^4.5.1",
+    "@graphql-typed-document-node/core": "^3.2.0"
+  }
+}

package/queries.ts

@@ -0,0 +1,64 @@
+import { gql } from './__generated__';
+
+export const AI_CREATE_AD_HOC_DIAL_SESSION = gql(`
+mutation CreateAdHocDialSession($input: CreateAdHocDialSessionInput!) {
+  createAdHocDialSession(input: $input) {
+    id
+    telephonyProvider
+  }
+}`);
+
+export const AI_START_DIAL_SESSION = gql(`
+  mutation StartDialSession($sessionId: ID!) {
+    startDialSession(dialSessionId: $sessionId)
+  }
+`);
+
+export const AI_HANGUP_CALL = gql(`
+  mutation HangupCall($dialId: ID!, $dropVoicemail: Boolean, $transferNumber: String) {
+    hangupCall(dialId: $dialId, dropVoicemail: $dropVoicemail, transferNumber: $transferNumber)
+  }
+`);
+
+export const AI_GET_TOKEN = gql(`
+  mutation BrowserDialToken($input: BrowserDialTokenInput!) {
+    browserDialToken(input: $input) {
+      token
+      iceConfig
+    }
+  }
+`);
+
+export const AI_CONNECT_SESSION = gql(`
+  subscription ConnectSession($sessionId: ID!) {
+    connectSession(sessionId: $sessionId) {
+      messageType
+      content {
+        __typename
+        ... on DialsUpdatedMessage {
+          contactId
+          dials {
+            id
+            status
+            answerType
+            phoneField
+            callDispositionId
+            systemResultType
+            toNumber
+          }
+          contactComplete
+        }
+        ... on DialConnectMessage {
+          dialId
+        }
+        ... on SessionUpdatedMessage {
+          dialSession {
+            id
+            status
+          }
+          reason
+        }
+      }
+    }
+  }
+`);

package/utils.ts

@@ -0,0 +1,16 @@
+export function dialStatusIsComplete(status: string) {
+    switch (status) {
+      case 'completed':
+        return true;
+      case 'canceled':
+        return true;
+      case 'no-answer':
+        return true;
+      case 'failed':
+        return true;
+      case 'busy':
+        return true;
+      default:
+        return false;
+    }
+  }