@dawntech/blip-tools 0.1.11 → 0.3.0

package/dist/helpers/encode-blip-params.js

@@ -1,12 +1,10 @@
-function normalizeValue(value) {
-    return String(value).replaceAll(' ', '%20');
-}
+import encodeString from './encode-strings.js';
 export default 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(`${normalizeValue(key)}=${normalizeValue(value)}`);
+            parsedParams.push(`${encodeString(key)}=${encodeString(value)}`);
         }
     }
     return parsedParams.join('&');

package/dist/helpers/encode-strings.d.ts

@@ -0,0 +1 @@
+export default function encodeString(value: unknown): string;

package/dist/helpers/encode-strings.js

@@ -0,0 +1,3 @@
+export default function encodeString(value) {
+    return String(value).replaceAll(' ', '%20');
+}

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { AxiosInstance } from 'axios';
 import { Template } from './types/template.js';
 import { Contact } from './types/contact.js';
 import { BlipConstructor } from './types/blip-constructor.js';
@@ -7,9 +6,13 @@ import { AttendanceHourContainer } from './types/attendance-hour-container.js';
 import { Ticket } from './types/ticket.js';
 import { CampaignNotification } from './types/campaign-notification.js';
 import { CampaignNotificationStatus } from './types/campaign-notification-status.js';
+import BlipBucket from './modules/blip-bucket.js';
+import BlipMedia from './modules/blip-media.js';
 export { BlipError, type Ticket, type AttendanceHourContainer, type Contact, type Template };
 export default class Blip {
-    api: AxiosInstance;
+    private api;
+    bucket: BlipBucket;
+    media: BlipMedia;
     constructor(params: BlipConstructor);
     /**
      * Sends a template-based message to any user. For sending messages to clients who are active, use `sendTemplateMessage` instead.
@@ -37,21 +40,39 @@ export default class Blip {
     /**
      * Sends a template-based message to an active user. For sending messages to clients who have never interacted or are inactive, use `sendTemplate` instead.
      */
-    sendTemplateMessage({ identity, template }: {
+    sendTemplateMessage({ identity, template, metadata, }: {
         identity: string;
         template: Template;
+        metadata?: string;
     }): Promise<void>;
     /**
      * Sends a simple text message to an active user. For sending messages to clients who have never interacted or are inactive, use `sendTemplate` instead.
      */
-    sendSimpleMessage({ identity, content }: {
+    sendSimpleMessage({ identity, content, metadata }: {
         identity: string;
         content: string;
+        metadata?: string;
     }): Promise<void>;
-    sendMessageWithButtons({ identity, message, buttons, }: {
+    /**
+     * 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.
+     */
+    sendMediaMessage({ identity, text, metadata, uri, type, title, aspectRatio, size, previewUri, }: {
+        type?: string;
+        uri: string;
+        identity: string;
+        text: string;
+        metadata?: string;
+        title: string;
+        aspectRatio?: string;
+        size?: number;
+        previewUri?: string;
+        previewType?: string;
+    }): Promise<void>;
+    sendMessageWithButtons({ identity, message, buttons, metadata, }: {
         identity: string;
         message: string;
         buttons: string[];
+        metadata?: string;
     }): Promise<void>;
     updateContact({ identity, contactData }: {
         identity: string;
@@ -66,6 +87,12 @@ export default class Blip {
         value: unknown;
         identity: string;
     }): Promise<void>;
+    moveUser({ identity, botIdentity, botFlowId, botStateId, }: {
+        identity: string;
+        botIdentity: string;
+        botFlowId: string;
+        botStateId: string;
+    }): Promise<void>;
     getWhatsAppIdentity(phone: string): Promise<string>;
     createTrackEvent({ category, action, identity }: {
         category: string;

package/dist/index.js

@@ -6,9 +6,13 @@ 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 {
     api;
+    bucket;
+    media;
     constructor(params) {
         validateInstance(params);
         this.api = axios.create({
@@ -18,6 +22,8 @@ export default class Blip {
             },
             timeout: 30000,
         });
+        this.bucket = new BlipBucket(this.api);
+        this.media = new BlipMedia(this.api);
     }
     /**
      * Sends a template-based message to any user. For sending messages to clients who are active, use `sendTemplateMessage` instead.
@@ -108,7 +114,7 @@ export default class Blip {
     /**
      * 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 }) {
+    async sendTemplateMessage({ identity, template, metadata, }) {
         try {
             const response = await this.api.post('/messages', {
                 id: randomUUID(),
@@ -118,6 +124,7 @@ export default class Blip {
                     type: 'template',
                     template,
                 },
+                metadata,
             });
             validateResponse(response);
         }
@@ -128,13 +135,14 @@ export default class Blip {
     /**
      * 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 }) {
+    async sendSimpleMessage({ identity, content, metadata }) {
         try {
             const response = await this.api.post('/messages', {
                 id: randomUUID(),
                 to: identity,
                 type: 'text/plain',
                 content,
+                metadata,
             });
             validateResponse(response);
         }
@@ -142,7 +150,33 @@ export default class Blip {
             handleError(error);
         }
     }
-    async sendMessageWithButtons({ identity, message, buttons, }) {
+    /**
+     * 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: 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: randomUUID(),
@@ -153,6 +187,7 @@ export default class Blip {
                     text: message,
                     options: buttons.map((button, index) => ({ order: index + 1, text: button })),
                 },
+                metadata,
             });
             validateResponse(response);
         }
@@ -225,6 +260,12 @@ export default class Blip {
             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) {
         try {
             const response = await this.api.post('/commands', {
@@ -251,11 +292,9 @@ export default class Blip {
                 resource: {
                     category,
                     action,
+                    contact: identity ? { identity } : undefined,
                 },
             };
-            if (identity && body.resource) {
-                body.resource.contact = { identity };
-            }
             const response = await this.api.post('/commands', body);
             validateResponse(response);
         }

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

@@ -0,0 +1,21 @@
+import { AxiosInstance } from 'axios';
+export default class BlipBucket {
+    private api;
+    constructor(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.
+    */
+    storeContentInBucket(id: string, content: unknown, opts?: {
+        expiresInMs?: number;
+    }): Promise<void>;
+    /**
+        Retrieves a document from the Blip bucket.
+    */
+    getContentFromBucket<T>(id: string): Promise<T>;
+    getAllContentIdsFromBucket(): Promise<string[]>;
+    /**
+        Deletes a JSON document from the Blip bucket.
+    */
+    deleteContentFromBucket(id: string): Promise<void>;
+}

package/dist/modules/blip-bucket.js

@@ -0,0 +1,88 @@
+import encodeString from '../helpers/encode-strings.js';
+import { randomUUID } from 'crypto';
+import encodeBlipParams from '../helpers/encode-blip-params.js';
+import validateResponse from '../helpers/validate-response.js';
+import handleError from '../helpers/handle-error.js';
+export default class BlipBucket {
+    api;
+    constructor(api) {
+        this.api = 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);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+export default class BlipMedia {
+    private api;
+    constructor(api: AxiosInstance);
+    /**
+     * 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
+     */
+    uploadMedia(content: Blob): Promise<string>;
+}

package/dist/modules/blip-media.js

@@ -0,0 +1,33 @@
+import axios from 'axios';
+import { randomUUID } from 'crypto';
+import validateResponse from '../helpers/validate-response.js';
+import handleError from '../helpers/handle-error.js';
+export default class BlipMedia {
+    api;
+    constructor(api) {
+        this.api = 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);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawntech/blip-tools",
-  "version": "0.1.11",
+  "version": "0.3.0",
   "description": "Node package for Blip API",
   "main": "dist/index.js",
   "module": "dist/index.js",