@dawntech/blip-tools 0.1.5 → 0.1.7

package/dist/exceptions/blip-error.d.ts

@@ -0,0 +1,4 @@
+export default class BlipError extends Error {
+    code: number;
+    constructor(message: string, code?: number);
+}

package/dist/exceptions/blip-error.js

@@ -0,0 +1,7 @@
+export default class BlipError extends Error {
+    code;
+    constructor(message, code = 0) {
+        super(message);
+        this.code = code;
+    }
+}

package/dist/helpers/format-template-params.d.ts

@@ -0,0 +1 @@
+export default function formatTemplateParams(params: string[]): Record<string, string>;

package/dist/helpers/format-template-params.js

@@ -0,0 +1,6 @@
+export default function formatTemplateParams(params) {
+    return params.reduce((prev, current, index) => {
+        prev[index + 1] = current;
+        return prev;
+    }, {});
+}

package/dist/helpers/handle-error.d.ts

@@ -0,0 +1 @@
+export default function handleError(error: unknown): void;

package/dist/helpers/handle-error.js

@@ -0,0 +1,14 @@
+import { AxiosError } from 'axios';
+import BlipError from '../exceptions/blip-error.js';
+export default 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;
+}

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

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

package/dist/helpers/validate-instance.js

@@ -0,0 +1,9 @@
+import BlipError from '../exceptions/blip-error.js';
+export default 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.');
+    }
+}

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

@@ -0,0 +1,2 @@
+import { AxiosResponse } from 'axios';
+export default function validateResponse(response: AxiosResponse): void;

package/dist/helpers/validate-response.js

@@ -0,0 +1,6 @@
+import BlipError from '../exceptions/blip-error.js';
+export default function validateResponse(response) {
+    if (response.data.status === 'failure') {
+        throw new BlipError(response.data.reason.description, response.data.reason.code);
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,58 @@
+import { AxiosInstance } from 'axios';
+import { Template } from './types/template.js';
+import { Contact } from './types/contact.js';
+import { BlipConstructor } from './types/blip-constructor.js';
+import BlipError from './exceptions/blip-error.js';
+export { BlipError };
 export default class Blip {
-    baseUrl: string;
-    constructor(baseUrl: string);
-    someMethod(): void;
-    fetchData(endpoint: string): Promise<unknown>;
+    api: AxiosInstance;
+    constructor(params: BlipConstructor);
+    /**
+     * Sends a template-based message to any user. For sending messages to clients who are active, use `sendTemplateMessage` instead.
+     */
+    sendIndividualActiveCampaign({ campaignName, masterState, flowId, stateId, channelType, phone, templateName, params, }: {
+        campaignName: string;
+        masterState: string;
+        flowId: string;
+        stateId: string;
+        channelType: string;
+        phone: string;
+        templateName: string;
+        params: string[];
+    }): Promise<void>;
+    getContextVariable({ identity, variableName }: {
+        identity: string;
+        variableName: string;
+    }): Promise<unknown>;
+    getAvailableContextVariables({ identity }: {
+        identity: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * 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 }: {
+        identity: string;
+        template: Template;
+    }): 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 }: {
+        identity: string;
+        content: string;
+    }): Promise<void>;
+    updateContact({ identity, contactData }: {
+        identity: string;
+        contactData: Record<string, unknown>;
+    }): Promise<void>;
+    getContact({ identity }: {
+        identity: string;
+    }): Promise<Contact>;
+    getWhatsAppTemplates(): Promise<Contact>;
+    setContextVariable({ value, variableName, identity, }: {
+        variableName: string;
+        value: unknown;
+        identity: string;
+    }): Promise<void>;
+    getWhatsAppIdentity(phone: string): Promise<string>;
 }

package/dist/index.js

@@ -1,17 +1,205 @@
+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';
+export { BlipError };
 export default class Blip {
-    baseUrl;
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl;
-    }
-    someMethod() {
-        // Example method
-    }
-    fetchData(endpoint) {
-        return fetch(endpoint)
-            .then((response) => response.json())
-            .catch((error) => {
-            console.error('Error fetching data:', error);
-            throw error;
+    api;
+    constructor(params) {
+        validateInstance(params);
+        this.api = axios.create({
+            baseURL: `https://${params.contract}.http.msging.net`,
+            headers: {
+                Authorization: `Key ${params.authToken}`,
+            },
+            timeout: 30000,
         });
     }
+    /**
+     * 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, }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: 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}`,
+                        messageParams: formatTemplateParams(params),
+                    },
+                    message: {
+                        messageTemplate: templateName,
+                        messageParams: params.map((_param, index) => String(index + 1)),
+                        channelType,
+                    },
+                },
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            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.
+     */
+    async sendTemplateMessage({ identity, template }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: randomUUID(),
+                to: identity,
+                type: 'application/json',
+                content: {
+                    type: 'template',
+                    template,
+                },
+            });
+            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 }) {
+        try {
+            const response = await this.api.post('/messages', {
+                id: randomUUID(),
+                to: identity,
+                type: 'text/plain',
+                content,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
+    async updateContact({ 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 getContact({ 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);
+        }
+    }
+    async getWhatsAppTemplates() {
+        try {
+            const response = await this.api.post('/commands', {
+                id: 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 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 getWhatsAppIdentity(phone) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: 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);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawntech/blip-tools",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Node package for Blip API",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -30,10 +30,14 @@
   "license": "MIT",
   "devDependencies": {
     "@eslint/js": "^9.22.0",
+    "@types/node": "^22.13.10",
     "@typescript-eslint/eslint-plugin": "^8.26.0",
     "eslint": "^9.22.0",
     "prettier": "^3.5.3",
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.26.0"
+  },
+  "dependencies": {
+    "axios": "^1.8.3"
   }
 }