@dawntech/blip-tools 0.3.1 → 0.4.0

package/dist/exceptions/index.d.ts

@@ -0,0 +1,5 @@
+import BlipError from './blip-error';
+declare const _default: {
+    BlipError: typeof BlipError;
+};
+export default _default;

package/dist/helpers/validate-instance.d.ts

@@ -1,2 +1,2 @@
-import { BlipConstructor } from '../types/blip-constructor.js';
+import { BlipConstructor } from '../types/blip-constructor';
 export default function validateInstance(params: BlipConstructor): void;

package/dist/index.cjs

@@ -0,0 +1,619 @@
+'use strict';
+
+var crypto = require('crypto');
+var axios = require('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 axios.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;
+    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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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: crypto.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.
+     */
+    async sendIndividualActiveCampaign({ campaignName, masterState, flowId, stateId, channelType, phone, templateName, params = [], }) {
+        const body = {
+            id: crypto.randomUUID(),
+            to: 'postmaster@activecampaign.msging.net',
+            method: 'set',
+            uri: '/campaign/full',
+            type: 'application/vnd.iris.activecampaign.full-campaign+json',
+            resource: {
+                campaign: {
+                    name: campaignName,
+                    campaignType: 'Individual',
+                    masterState,
+                    flowId,
+                    stateId,
+                    channelType,
+                },
+                audience: {
+                    recipient: `+${phone}`,
+                },
+                message: {
+                    messageTemplate: templateName,
+                    channelType,
+                },
+            },
+        };
+        if (params.length > 0) {
+            body.resource.audience.messageParams = formatTemplateParams(params);
+            body.resource.message.messageParams = params.map((_param, index) => String(index + 1));
+        }
+        try {
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+            return response.data.resource;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    async getCampaignNotificationStatus({ campaignNotificationId }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: crypto.randomUUID(),
+                to: 'postmaster@msging.net',
+                method: 'get',
+                uri: `/notifications?id=${campaignNotificationId}`,
+            });
+            validateResponse(response);
+            return response.data.resource.items;
+        }
+        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.
+     */
+    async sendTemplateMessage({ identity, template, metadata, }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: crypto.randomUUID(),
+                to: identity,
+                type: 'application/json',
+                content: {
+                    type: 'template',
+                    template,
+                },
+                metadata,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+    /**
+     * Sends a simple text message to an active user. For sending messages to clients who have never interacted or are inactive, use `sendTemplate` instead.
+     */
+    async sendSimpleMessage({ identity, content, metadata }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: crypto.randomUUID(),
+                to: identity,
+                type: 'text/plain',
+                content,
+                metadata,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+    /**
+     * Sends a text message to an active user with a midia. For sending messages to clients who have never interacted or are inactive, use `sendTemplate` instead.
+     */
+    async sendMediaMessage({ identity, text, metadata, uri, type, title, aspectRatio = '1:1', size, previewUri, }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: crypto.randomUUID(),
+                to: identity,
+                type: 'application/vnd.lime.media-link+json',
+                content: {
+                    text,
+                    uri,
+                    type,
+                    title,
+                    aspectRatio,
+                    size,
+                    previewUri,
+                },
+                metadata,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+    async sendMessageWithButtons({ identity, message, buttons, metadata, }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: crypto.randomUUID(),
+                to: identity,
+                type: 'application/vnd.lime.select+json',
+                content: {
+                    scope: buttons.length <= 3 ? 'immediate' : null,
+                    text: message,
+                    options: buttons.map((button, index) => ({ order: index + 1, text: button })),
+                },
+                metadata,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+}
+
+class BlipEvent {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async createTrackEvent({ category, action, identity }) {
+        try {
+            const body = {
+                id: crypto.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);
+            validateResponse(response);
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+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 params = {
+                $filter: filter,
+                $skip: skip,
+                $take: take,
+            };
+            const body = {
+                id: crypto.randomUUID(),
+                to: 'postmaster@desk.msging.net',
+                method: 'get',
+                uri: `/tickets?${encodeBlipParams(params)}`,
+            };
+            const response = await this.api.post('/commands', body);
+            validateResponse(response);
+            return response.data.resource.items;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+class BlipWhatsapp {
+    api;
+    constructor(context) {
+        this.api = context.api;
+    }
+    async getTemplates() {
+        try {
+            const response = await this.api.post('/commands', {
+                id: crypto.randomUUID(),
+                to: 'postmaster@wa.gw.msging.net',
+                method: 'get',
+                uri: '/message-templates',
+            });
+            validateResponse(response);
+            return response.data.resource.data;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+    async getIdentity(phone) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: crypto.randomUUID(),
+                to: 'postmaster@wa.gw.msging.net',
+                method: 'get',
+                uri: `lime://wa.gw.msging.net/accounts/+${phone}`,
+            });
+            validateResponse(response);
+            return response.data.resource.identity;
+        }
+        catch (error) {
+            throw handleError(error);
+        }
+    }
+}
+
+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 Blip {
+    api;
+    bucket;
+    media;
+    attendance;
+    contact;
+    context;
+    dispatch;
+    event;
+    interaction;
+    ticket;
+    whatsapp;
+    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 });
+    }
+}
+
+exports.Blip = Blip;
+exports.Modules = index;