@dawntech/blip-tools 0.1.4 → 0.1.6

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) {
+        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-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,48 @@
+import { AxiosInstance } from 'axios';
+import { Template } from './types/template.js';
+import { Contact } from './types/contact.js';
 export default class Blip {
-    baseUrl: string;
-    constructor(baseUrl: string);
-    someMethod(): void;
-    fetchData(endpoint: string): Promise<unknown>;
+    api: AxiosInstance;
+    constructor({ contract, authToken }: {
+        contract: string;
+        authToken: string;
+    });
+    sendTemplate({ campaignName, campaignType, masterState, flowId, stateId, channelType, phone, templateName, params, }: {
+        campaignName: string;
+        campaignType: 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>>;
+    sendTemplateMessage({ identity, template }: {
+        identity: string;
+        template: Template;
+    }): Promise<void>;
+    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>;
+    setVariable({ value, variableName, identity }: {
+        variableName: string;
+        value: unknown;
+        identity: string;
+    }): Promise<void>;
 }

package/dist/index.js

@@ -1,17 +1,161 @@
+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';
 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({ contract, authToken }) {
+        this.api = axios.create({
+            baseURL: `https://${contract}.http.msging.net`,
+            headers: {
+                Authorization: `Key ${authToken}`,
+            },
+            timeout: 30000,
         });
     }
+    async sendTemplate({ campaignName, campaignType, 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,
+                        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);
+        }
+    }
+    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);
+        }
+    }
+    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 setVariable({ value, variableName, identity }) {
+        try {
+            const response = await this.api.post('/commands', {
+                id: randomUUID(),
+                method: 'set',
+                uri: `/contexts/${identity}/${variableName}`,
+                type: 'application/vnd.lime.contact+json',
+                resource: value,
+            });
+            validateResponse(response);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dawntech/blip-tools",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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"
   }
 }