@dawntech/blip-tools 0.3.1 → 0.5.0

package/dist/{index.js → index.mjs}

@@ -1,29 +1,312 @@
-import axios from 'axios';
 import { randomUUID } from 'crypto';
-import validateResponse from './helpers/validate-response.js';
-import handleError from './helpers/handle-error.js';
-import formatTemplateParams from './helpers/format-template-params.js';
-import validateInstance from './helpers/validate-instance.js';
-import BlipError from './exceptions/blip-error.js';
-import encodeBlipParams from './helpers/encode-blip-params.js';
-import BlipBucket from './modules/blip-bucket.js';
-import BlipMedia from './modules/blip-media.js';
-export { BlipError };
-export default class Blip {
+import axios, { AxiosError } from 'axios';
+
+function encodeString(value) {
+    return String(value).replaceAll(' ', '%20');
+}
+
+function encodeBlipParams(params) {
+    //This function does not uses any of the standard methods of URI parsing because Blip does not follow any of them
+    const parsedParams = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value && key) {
+            parsedParams.push(`${encodeString(key)}=${encodeString(value)}`);
+        }
+    }
+    return parsedParams.join('&');
+}
+
+class BlipError extends Error {
+    code;
+    constructor(message, code = 0) {
+        super(message);
+        this.code = code;
+    }
+}
+
+function validateResponse(response) {
+    if (response.data.status === 'failure') {
+        throw new BlipError(response.data.reason.description, response.data.reason.code);
+    }
+}
+
+function handleError(error) {
+    if (error instanceof BlipError) {
+        throw error;
+    }
+    if (error instanceof AxiosError) {
+        if (error.response?.data.code) {
+            throw new BlipError(error.response?.data.description, error.response?.data.code);
+        }
+        throw new BlipError(error.message, 0);
+    }
+    throw error;
+}
+
+class BlipBucket {
     api;
-    bucket;
-    media;
-    constructor(params) {
-        validateInstance(params);
-        this.api = axios.create({
-            baseURL: `https://${params.contract}.http.msging.net`,
-            headers: {
-                Authorization: `Key ${params.authToken.replace('Key ', '')}`,
-            },
-            timeout: 30000,
-        });
-        this.bucket = new BlipBucket(this.api);
-        this.media = new BlipMedia(this.api);
+    constructor(context) {
+        this.api = context.api;
+    }
+    /**
+        Stores JSON content in a bucket provided by Blip. The content can be updaded or retrieved using the same id used in the update.
+        You can optionally provide a expiration time (in milliseconds) to delete the document after a certain amount of time.
+    */
+    async storeContentInBucket(id, content, opts) {
+        try {
+            let uri = `/buckets/${encodeString(id)}`;
+            const params = {};
+            if (opts?.expiresInMs) {
+                params.expiration = opts?.expiresInMs;
+                uri += `?${encodeBlipParams(params)}`;
+            }
+            const body = {
+                id: randomUUID(),
+                method: 'set',
+                type: 'application/json',
+                uri,
+                resource: content,
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    /**
+        Retrieves a document from the Blip bucket.
+    */
+    async getContentFromBucket(id) {
+        try {
+            const body = {
+                id: randomUUID(),
+                method: 'get',
+                uri: `/buckets/${encodeString(id)}`,
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    async getAllContentIdsFromBucket() {
+        try {
+            const body = {
+                id: randomUUID(),
+                method: 'get',
+                uri: `/buckets`,
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+            return response.data.resource.items;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    /**
+        Deletes a JSON document from the Blip bucket.
+    */
+    async deleteContentFromBucket(id) {
+        try {
+            const body = {
+                id: randomUUID(),
+                method: 'delete',
+                uri: `/buckets/${encodeString(id)}`,
+                to: 'postmaster@msging.net',
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+class BlipMedia {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    /**
+     * Uploads an media file to Blip storage to be used later when sending messages
+     * @param content A Blob containing a image, PDF or video
+     * @returns A public URL
+     */
+    async uploadMedia(content) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@media.msging.net',
+                method: 'get',
+                uri: '/upload-media-uri',
+            });
+            validateResponse(response);
+            const uploadResponse = await axios.post(response.data.resource, content, {
+                headers: { 'Content-Type': 'application/octet-stream' },
+            });
+            return uploadResponse.data.mediaUri;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    /**
+     * Generates a new public URI to access blip chat media. Blip medias have expiration dates so you need to generate new ones to access the data.
+     * @param expiredMediaUri Blip media expired URI
+     * @returns A new public URI
+     */
+    async refreshMediaUri(expiredMediaUri) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@media.msging.net',
+                method: 'set',
+                type: 'text/plain',
+                uri: '/refresh-media-uri',
+                resource: expiredMediaUri,
+            });
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+class BlipAttendance {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async getAttendanceHourContainer({ attendanceContainerId }) {
+        try {
+            const body = {
+                id: randomUUID(),
+                to: 'postmaster@desk.msging.net',
+                method: 'get',
+                uri: `/attendance-hour-container/${attendanceContainerId}`,
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+class BlipContact {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async update({ identity, contactData }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@msging.net',
+                method: 'merge',
+                uri: '/contacts',
+                type: 'application/vnd.lime.contact+json',
+                resource: {
+                    identity,
+                    ...contactData,
+                },
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+    async get({ identity }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@crm.msging.net',
+                method: 'get',
+                uri: `/contacts/${identity}`,
+            });
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+class BlipContext {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async getContextVariable({ identity, variableName }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@msging.net',
+                method: 'get',
+                uri: `/contexts/${identity}/${variableName}`,
+            });
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    async getAvailableContextVariables({ identity }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                to: 'postmaster@msging.net',
+                method: 'get',
+                uri: `/contexts/${identity}`,
+            });
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    async setContextVariable({ value, variableName, identity, }) {
+        try {
+            const resourceType = typeof value === 'object' ? 'application/vnd.lime.contact+json' : 'text/plain';
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                method: 'set',
+                uri: `/contexts/${identity}/${variableName}`,
+                type: resourceType,
+                resource: value,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+}
+
+function formatTemplateParams(params) {
+    return params.reduce((prev, current, index) => {
+        prev[index + 1] = current;
+        return prev;
+    }, {});
+}
+
+class BlipDispatch {
+    api;
+    constructor(context) {
+        this.api = context.api;
     }
     /**
      * Sends a template-based message to any user. For sending messages to clients who are active, use `sendTemplateMessage` instead.
@@ -81,36 +364,6 @@ export default class Blip {
             throw handleError(error);
         }
     }
-    async getContextVariable({ identity, variableName }) {
-        try {
-            const response = await this.api.post('/commands', {
-                id: randomUUID(),
-                to: 'postmaster@msging.net',
-                method: 'get',
-                uri: `/contexts/${identity}/${variableName}`,
-            });
-            validateResponse(response);
-            return response.data.resource;
-        }
-        catch (error) {
-            throw handleError(error);
-        }
-    }
-    async getAvailableContextVariables({ identity }) {
-        try {
-            const response = await this.api.post('/commands', {
-                id: randomUUID(),
-                to: 'postmaster@msging.net',
-                method: 'get',
-                uri: `/contexts/${identity}`,
-            });
-            validateResponse(response);
-            return response.data.resource;
-        }
-        catch (error) {
-            throw handleError(error);
-        }
-    }
     /**
      * Sends a template-based message to an active user. For sending messages to clients who have never interacted or are inactive, use `sendTemplate` instead.
      */
@@ -195,41 +448,83 @@ export default class Blip {
             handleError(error);
         }
     }
-    async updateContact({ identity, contactData }) {
+}
+
+class BlipEvent {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async createTrackEvent({ category, action, identity }) {
         try {
-            const response = await this.api.post('/commands', {
+            const body = {
                 id: randomUUID(),
-                to: 'postmaster@msging.net',
-                method: 'merge',
-                uri: '/contacts',
-                type: 'application/vnd.lime.contact+json',
+                to: 'postmaster@analytics.msging.net',
+                method: 'set',
+                type: 'application/vnd.iris.eventTrack+json',
+                uri: '/event-track',
                 resource: {
-                    identity,
-                    ...contactData,
+                    category,
+                    action,
+                    contact: identity ? { identity } : undefined,
                 },
-            });
+            };
+            const response = await this.api.post('/commands', body);
             validateResponse(response);
         }
         catch (error) {
-            handleError(error);
+            throw handleError(error);
         }
     }
-    async getContact({ identity }) {
+}
+
+class BlipInteraction {
+    blipContext;
+    constructor(context) {
+        this.blipContext = context.blipContext;
+    }
+    async moveUser({ identity, botIdentity, botFlowId, botStateId, }) {
+        await Promise.all([
+            this.blipContext.setContextVariable({ identity, variableName: 'master-state', value: botIdentity }),
+            this.blipContext.setContextVariable({ identity, variableName: `stateid@${botFlowId}`, value: botStateId }),
+        ]);
+    }
+}
+
+class BlipTicket {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async search({ filter, skip, take }) {
         try {
-            const response = await this.api.post('/commands', {
+            const params = {
+                $filter: filter,
+                $skip: skip,
+                $take: take,
+            };
+            const body = {
                 id: randomUUID(),
-                to: 'postmaster@crm.msging.net',
+                to: 'postmaster@desk.msging.net',
                 method: 'get',
-                uri: `/contacts/${identity}`,
-            });
+                uri: `/tickets?${encodeBlipParams(params)}`,
+            };
+            const response = await this.api.post('/commands', body);
             validateResponse(response);
-            return response.data.resource;
+            return response.data.resource.items;
         }
         catch (error) {
             throw handleError(error);
         }
     }
-    async getWhatsAppTemplates() {
+}
+
+class BlipWhatsapp {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async getTemplates() {
         try {
             const response = await this.api.post('/commands', {
                 id: randomUUID(),
@@ -244,29 +539,7 @@ export default class Blip {
             throw handleError(error);
         }
     }
-    async setContextVariable({ value, variableName, identity, }) {
-        try {
-            const resourceType = typeof value === 'object' ? 'application/vnd.lime.contact+json' : 'text/plain';
-            const response = await this.api.post('/commands', {
-                id: randomUUID(),
-                method: 'set',
-                uri: `/contexts/${identity}/${variableName}`,
-                type: resourceType,
-                resource: value,
-            });
-            validateResponse(response);
-        }
-        catch (error) {
-            handleError(error);
-        }
-    }
-    async moveUser({ identity, botIdentity, botFlowId, botStateId, }) {
-        await Promise.all([
-            this.setContextVariable({ identity, variableName: 'master-state', value: botIdentity }),
-            this.setContextVariable({ identity, variableName: `stateid@${botFlowId}`, value: botStateId }),
-        ]);
-    }
-    async getWhatsAppIdentity(phone) {
+    async getIdentity(phone) {
         try {
             const response = await this.api.post('/commands', {
                 id: randomUUID(),
@@ -281,36 +554,59 @@ export default class Blip {
             throw handleError(error);
         }
     }
-    async createTrackEvent({ category, action, identity }) {
+}
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BlipAttendance: BlipAttendance,
+    BlipBucket: BlipBucket,
+    BlipContact: BlipContact,
+    BlipContext: BlipContext,
+    BlipDispatch: BlipDispatch,
+    BlipEvent: BlipEvent,
+    BlipInteraction: BlipInteraction,
+    BlipMedia: BlipMedia,
+    BlipTicket: BlipTicket,
+    BlipWhatsapp: BlipWhatsapp
+});
+
+function validateInstance(params) {
+    if (!params.contract) {
+        throw new BlipError('A contract must be specified.');
+    }
+    if (!params.authToken) {
+        throw new BlipError('An authToken must be provided.');
+    }
+}
+
+class BlipMonitoring {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async getTickets() {
         try {
-            const body = {
+            const response = await this.api.post('/commands', {
                 id: randomUUID(),
-                to: 'postmaster@analytics.msging.net',
-                method: 'set',
-                type: 'application/vnd.iris.eventTrack+json',
-                uri: '/event-track',
-                resource: {
-                    category,
-                    action,
-                    contact: identity ? { identity } : undefined,
-                },
-            };
-            const response = await this.api.post('/commands', body);
+                to: 'postmaster@desk.msging.net',
+                method: 'get',
+                uri: '/monitoring/tickets',
+            });
             validateResponse(response);
+            return response.data.resource;
         }
         catch (error) {
             throw handleError(error);
         }
     }
-    async getAttendanceHourContainer({ attendanceContainerId }) {
+    async getTicketMetrics() {
         try {
-            const body = {
+            const response = await this.api.post('/commands', {
                 id: randomUUID(),
                 to: 'postmaster@desk.msging.net',
                 method: 'get',
-                uri: `/attendance-hour-container/${attendanceContainerId}`,
-            };
-            const response = await this.api.post('/commands', body);
+                uri: '/monitoring/ticket-metrics',
+            });
             validateResponse(response);
             return response.data.resource;
         }
@@ -318,25 +614,57 @@ export default class Blip {
             throw handleError(error);
         }
     }
-    async searchTickets({ filter, skip, take }) {
+    async getAttendantStatusMetrics() {
         try {
-            const params = {
-                $filter: filter,
-                $skip: skip,
-                $take: take,
-            };
-            const body = {
+            const response = await this.api.post('/commands', {
                 id: randomUUID(),
                 to: 'postmaster@desk.msging.net',
                 method: 'get',
-                uri: `/tickets?${encodeBlipParams(params)}`,
-            };
-            const response = await this.api.post('/commands', body);
+                uri: '/monitoring/attendant-status-metrics',
+            });
             validateResponse(response);
-            return response.data.resource.items;
+            return response.data.resource;
         }
         catch (error) {
             throw handleError(error);
         }
     }
 }
+
+class Blip {
+    api;
+    bucket;
+    media;
+    attendance;
+    contact;
+    context;
+    dispatch;
+    event;
+    interaction;
+    ticket;
+    whatsapp;
+    monitoring;
+    constructor(params) {
+        validateInstance(params);
+        this.api = axios.create({
+            baseURL: `https://${params.contract}.http.msging.net`,
+            headers: {
+                Authorization: `Key ${params.authToken.replace('Key ', '')}`,
+            },
+            timeout: 30000,
+        });
+        this.bucket = new BlipBucket({ api: this.api });
+        this.media = new BlipMedia({ api: this.api });
+        this.attendance = new BlipAttendance({ api: this.api });
+        this.context = new BlipContext({ api: this.api });
+        this.contact = new BlipContact({ api: this.api });
+        this.dispatch = new BlipDispatch({ api: this.api });
+        this.event = new BlipEvent({ api: this.api });
+        this.interaction = new BlipInteraction({ blipContext: this.context });
+        this.ticket = new BlipTicket({ api: this.api });
+        this.whatsapp = new BlipWhatsapp({ api: this.api });
+        this.monitoring = new BlipMonitoring({ api: this.api });
+    }
+}
+
+export { Blip, index as Modules };

package/dist/modules/blip-attendance.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { AttendanceHourContainer } from '../types/attendance-hour-container';
+export default class BlipAttendance {
+    private api;
+    constructor(context: {
+        api: AxiosInstance;
+    });
+    getAttendanceHourContainer({ attendanceContainerId }: {
+        attendanceContainerId: string;
+    }): Promise<AttendanceHourContainer>;
+}

package/dist/modules/blip-bucket.d.ts

@@ -1,7 +1,9 @@
 import { AxiosInstance } from 'axios';
 export default class BlipBucket {
     private api;
-    constructor(api: AxiosInstance);
+    constructor(context: {
+        api: AxiosInstance;
+    });
     /**
         Stores JSON content in a bucket provided by Blip. The content can be updaded or retrieved using the same id used in the update.
         You can optionally provide a expiration time (in milliseconds) to delete the document after a certain amount of time.

package/dist/modules/blip-contact.d.ts

@@ -0,0 +1,15 @@
+import { AxiosInstance } from 'axios';
+import { Contact } from '../types/contact';
+export default class BlipContact {
+    private api;
+    constructor(context: {
+        api: AxiosInstance;
+    });
+    update({ identity, contactData }: {
+        identity: string;
+        contactData: Record<string, unknown>;
+    }): Promise<void>;
+    get({ identity }: {
+        identity: string;
+    }): Promise<Contact>;
+}