@whitewall/blip-sdk 0.0.136 → 0.0.138

package/src/namespaces/activecampaign.ts

@@ -0,0 +1,285 @@
+import type { BlipClient } from '../client.ts'
+import { type Identity, Node } from '../types/node.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+type AudienceSummary = {
+    id: string
+    name: string
+    campaignStatus: string
+    failed: number
+    processed: number
+    read: number
+    received: number
+    total: number
+    scheduled?: string
+    created: string
+}
+
+export class ActiveCampaignNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'activecampaign', defaultOptions)
+    }
+
+    public createAndDispatchBatchCampaign(
+        campaign: {
+            name: string
+            flowId: string
+            stateId: string
+            campaignSender: string
+            subbotIdentity?: Identity
+            agentEmail?: string
+            scheduled?: string
+            tags?: Array<string>
+        },
+        audiences: Array<{
+            recipient: string
+            buttonVariable?: string
+            mediaVariable?: string
+            bodyVariables: Array<string>
+            additionalContactExtras?: Record<string, string | null>
+        }>,
+        message: {
+            template: string
+            language: string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<{
+        id: string
+        status: string
+        created: string
+    }> {
+        const messageVariables = [
+            audiences[0].mediaVariable ? 'urllink' : undefined,
+            audiences[0].buttonVariable ? 'button' : undefined,
+            ...audiences[0].bodyVariables.map((_, i) => `variable${i + 1}`),
+        ].filter((v) => v)
+        return this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/campaign/full`,
+                type: 'application/vnd.iris.activecampaign.full-campaign+json',
+                resource: {
+                    campaign: {
+                        name: campaign.name,
+                        campaignType: 'BATCH',
+                        flowId: campaign.flowId,
+                        stateId: campaign.stateId,
+                        campaignSender: campaign.campaignSender,
+                        masterstate: campaign.subbotIdentity,
+                        attendanceRedirect: campaign.agentEmail ? new Node(campaign.agentEmail, 'blip.ai') : undefined,
+                        scheduled: campaign.scheduled,
+                        tags: campaign.tags,
+                    },
+                    audiences: audiences.map((audience) => {
+                        return {
+                            recipient: audience.recipient,
+                            messageParams: {
+                                urllink: audience.mediaVariable,
+                                button: audience.buttonVariable,
+                                ...Object.fromEntries(audience.bodyVariables.map((v, i) => [`variable${i + 1}`, v])),
+                                ...audience.additionalContactExtras,
+                            },
+                        }
+                    }),
+                    message: {
+                        messageTemplate: message.template,
+                        messageTemplateLanguage: message.language,
+                        // Needed because of a bug where the API interprets empty array as a single empty variable
+                        // E.g. "messageParams": [""]
+                        messageParams: messageVariables.length > 0 ? messageVariables : undefined,
+                    },
+                },
+            },
+            opts,
+        )
+    }
+
+    public async cancelCampaign(campaign: string, opts?: ConsumeOptions) {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/campaigns/${campaign}`,
+            },
+            opts,
+        )
+    }
+
+    public async getCampaigns(opts?: ConsumeOptions) {
+        // This is needed because this route throws an error if passed an $skip or $take query parameter
+        const resource = await this.sendCommand<'get', { items: Array<{ id: string; name: string }> }>(
+            {
+                method: 'get',
+                uri: uri`/campaigns`,
+            },
+            opts,
+        )
+        return resource.items
+    }
+
+    public getCampaign(
+        campaign: string,
+        opts?: ConsumeOptions,
+    ): Promise<{
+        id: string
+        name: string
+        campaignType: 'BATCH' | 'INDIVIDUAL'
+        masterState: Identity
+        flowId: string
+        stateId: string
+        campaignSender: Identity
+        status: string
+        created: string
+    }> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/campaigns/${campaign}`,
+            },
+            opts,
+        )
+    }
+
+    public async getCampaignMessage(campaign: string, opts?: ConsumeOptions) {
+        const [message] = await this.sendCommand<
+            'get',
+            Array<{
+                channelType: 'WHATSAPP'
+                messageTemplate: string
+                messageTemplateLanguage: string
+                messageParams: Array<string>
+            }>
+        >(
+            {
+                method: 'get',
+                uri: uri`/messages/${campaign}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+
+        return message
+    }
+
+    public getAudienceSummaries(
+        filter?: {
+            scheduled?: boolean
+            campaignName?: string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<AudienceSummary>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/audience-summary?${filter}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getAudienceSummary(campaign: string, opts?: ConsumeOptions) {
+        const [summary] = await this.sendCommand<'get', Array<AudienceSummary>>(
+            {
+                method: 'get',
+                uri: uri`/audience-summary/${campaign}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+
+        return summary
+    }
+
+    public getAudience(
+        campaign: string,
+        opts?: ConsumeOptions,
+    ): Promise<
+        Array<{
+            OwnerIdentity: Identity
+            CampaignId: string
+            recipient: string
+            recipientType: 'PhoneNumber'
+            channelType: 'WHATSAPP'
+            messageParams: Record<string, string>
+            status: string
+            validatedAccount: Identity
+            // These strings are actually timestamps
+            // Can be used to infer the message's state
+            processed?: string
+            received?: string
+            read?: string
+            failed?: string
+            reasonCode?: number
+            reasonDescription?: string
+        }>
+    > {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/audiences/${campaign}`,
+            },
+            {
+                collection: true,
+                take: 1000,
+                ...opts,
+            },
+        )
+    }
+
+    public getCampaignsSummaries(
+        filters: {
+            createdDate: string | Date
+            source?: 'Portal' | 'Desk' | 'API'
+            campaignSender?: string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<
+        Array<{
+            id: string
+            name: string
+            messageTemplate: string
+            masterState: Identity
+            flowId: string
+            stateId: string
+            attendanceRedirect: Identity
+            campaignSender: Identity
+            sendDate: string
+            statusAudience: Array<{
+                recipientIdentity: Identity
+                status: 'NOT_PROCESSED' | 'PROCESSED' | 'RECEIVED' | 'READ' | 'FAILED'
+                processed?: string
+                received?: string
+                read?: string
+                failed?: string
+                reasonCode?: number
+                reasonDescription?: string
+                numberStatus: string
+            }>
+        }>
+    > {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/campaigns/summaries?${{
+                    created:
+                        typeof filters.createdDate === 'string'
+                            ? filters.createdDate
+                            : filters.createdDate.toISOString(),
+                    SourceApplication: filters.source,
+                    CampaignSender: filters.campaignSender,
+                }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+}

package/src/namespaces/analytics.ts

@@ -0,0 +1,230 @@
+import type { BlipClient } from '../client.ts'
+import type { EventTrack, NonNullableEventTracking } from '../types/analytics.ts'
+import type { Identity } from '../types/node.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class AnalyticsNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'analytics', defaultOptions)
+    }
+
+    public async track(
+        contact: Identity | undefined,
+        category: string,
+        action: string,
+        extras: Record<string, string | undefined> = {},
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'observe',
+                uri: uri`/event-track`,
+                type: 'application/vnd.iris.eventTrack+json',
+                resource: {
+                    category,
+                    action,
+                    contact: contact
+                        ? {
+                              identity: contact,
+                          }
+                        : undefined,
+                    extras: {
+                        ...(contact ? { contactIdentity: contact } : {}),
+                        ...extras,
+                    },
+                } satisfies EventTrack,
+            },
+            opts,
+        )
+    }
+
+    public async getCategories(
+        filter?: string,
+        opts?: ConsumeOptions,
+    ): Promise<Array<Pick<NonNullableEventTracking, 'category'>>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/event-track?${{ categoryFilter: filter }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    /** @returns Quantity of actions in the category between the start and end date */
+    public async getCategoryCount(
+        category: string,
+        startDate: Date,
+        endDate: Date,
+        opts?: ConsumeOptions,
+    ): Promise<number> {
+        const { count } = await this.sendCommand<'get', { count: number }>(
+            {
+                method: 'get',
+                uri: uri`/event-track-count/${category}?${{ startDate, endDate }}`,
+            },
+            opts,
+        )
+        return count
+    }
+
+    /** @returns Counts of each action in the category grouped by day between the start and end date */
+    public async getCategoryActions(
+        category: string,
+        startDate: Date,
+        endDate: Date,
+        opts?: ConsumeOptions,
+    ): Promise<Array<Pick<NonNullableEventTracking, 'storageDate' | 'category' | 'action' | 'count'>>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/event-track/${category}?${{ startDate, endDate }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTrackings(category: string, action: string, startDate: Date, endDate: Date, opts?: ConsumeOptions) {
+        const trackings = await this.sendCommand<
+            'get',
+            Array<
+                Pick<EventTrack, 'ownerIdentity' | 'storageDate' | 'category' | 'action' | 'extras' | 'contact'> & {
+                    contact: {
+                        // This is a workaround, sometimes Blip returns it on pascal case
+                        Identity: Identity
+                    }
+                }
+            >
+        >(
+            {
+                method: 'get',
+                uri: uri`/event-track/${category}/${action}?${{ startDate, endDate }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+
+        return trackings.map((tracking) => ({
+            ...tracking,
+            contact: {
+                identity: tracking.contact?.Identity ?? tracking.contact?.identity ?? tracking.extras.contactIdentity,
+            },
+        }))
+    }
+
+    public async hasWebhook(url: string, opts?: ConsumeOptions) {
+        const webhooks = await this.getWebhooks(opts)
+        return webhooks.some((webhook) => webhook.url === url)
+    }
+
+    public async getWebhooks(opts?: ConsumeOptions) {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        const webhookUrls = configurations['Webhook.Url']?.split(';') ?? []
+        const advancedWebhookSettings = JSON.parse(configurations['Webhook.AdvancedSettings'] ?? '[]')
+
+        type Settings = {
+            settings: {
+                dispatchTypes: Array<'contacts' | 'messages' | 'eventtrackings'>
+                customHeaders: Record<string, string>
+            }
+        }
+
+        return webhookUrls
+            .filter((url) => url)
+            .map((url) => {
+                const settings = advancedWebhookSettings.find(
+                    (webhookSettings: Record<string, Settings>) => webhookSettings[url]?.settings,
+                )?.[url]?.settings
+
+                return {
+                    url,
+                    settings: (settings ?? {
+                        dispatchTypes: ['contacts', 'messages', 'eventtrackings'],
+                        customHeaders: {},
+                    }) as Settings['settings'],
+                }
+            })
+    }
+
+    /**
+     * It will add the url as an active webhook if it doesn't exist yet
+     * If the url already exists, it will update the settings
+     * @param url The url to set
+     * @param settings.listeners Default: ['contacts', 'messages', 'eventtrackings']
+     */
+    public async setWebhook(
+        url: string,
+        settings?: {
+            listeners?: Array<'contacts' | 'messages' | 'eventtrackings'>
+            headers?: Record<string, string>
+        },
+        opts?: ConsumeOptions,
+    ) {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        let webhookUrls = configurations['Webhook.Url']?.split(';') ?? []
+        if (!webhookUrls.includes(url)) {
+            webhookUrls = [...webhookUrls, url]
+        }
+
+        const webhookSettings = {
+            dispatchTypes: settings?.listeners ?? ['contacts', 'messages', 'eventtrackings'],
+            customHeaders: settings?.headers ?? {},
+        }
+
+        const advancedWebhookSettings = JSON.parse(configurations['Webhook.AdvancedSettings'] ?? '[]').filter(
+            (urls: Record<string, never>) => !urls[url],
+        )
+
+        await this.blipClient.account.setConfigurations(
+            {
+                'Webhook.Url': webhookUrls.join(';'),
+                'Webhook.IsValid': 'True',
+                'Webhook.AdvancedSettings': JSON.stringify([
+                    ...advancedWebhookSettings,
+                    {
+                        [url]: {
+                            settings: webhookSettings,
+                        },
+                    },
+                ]),
+            },
+            { ...opts, ownerIdentity: this.identity },
+        )
+    }
+
+    public async deleteWebhook(url: string, opts?: ConsumeOptions) {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        const currentWebhookUrls = configurations['Webhook.Url']?.split(';') ?? []
+        const advancedWebhookSettings = JSON.parse(configurations['Webhook.AdvancedSettings'] ?? '[]')
+        await this.blipClient.account.setConfigurations(
+            {
+                'Webhook.Url': currentWebhookUrls.filter((u) => u !== url).join(';'),
+                'Webhook.AdvancedSettings': JSON.stringify(
+                    advancedWebhookSettings.filter((urls: Record<string, never>) => !urls[url]),
+                ),
+            },
+            { ...opts, ownerIdentity: this.identity },
+        )
+    }
+}

package/src/namespaces/billing.ts

@@ -0,0 +1,17 @@
+import type { BlipClient } from '../client.ts'
+import type { Plan } from '../types/billing.ts'
+import { uri } from '../utils/uri.ts'
+import { Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class BillingNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'billing', { ...defaultOptions, domain: 'blip.ai' })
+    }
+
+    public async getPlan(tenantId: string): Promise<Plan> {
+        return await this.sendCommand({
+            method: 'get',
+            uri: uri`/tenants/${tenantId}/subscription/plan`,
+        })
+    }
+}

package/src/namespaces/builder.ts

@@ -0,0 +1,52 @@
+import type { BlipClient } from '../client.ts'
+import { BlipError } from '../sender/bliperror.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class BuilderNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'builder', defaultOptions)
+    }
+
+    public async getFlowId(botIdentifier?: string, opts?: ConsumeOptions): Promise<string | undefined> {
+        try {
+            return await this.sendCommand(
+                {
+                    method: 'get',
+                    uri: uri`/flow-id?${{ shortName: botIdentifier }}`,
+                },
+                opts,
+            )
+        } catch (err) {
+            if (err instanceof BlipError && err.code === 67) {
+                return undefined
+            }
+
+            throw err
+        }
+    }
+
+    public async getFlowStates(
+        botIdentifier?: string,
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ id: string; name: string }>> {
+        try {
+            return await this.sendCommand(
+                {
+                    method: 'get',
+                    uri: uri`/flow/states?${{ shortName: botIdentifier }}`,
+                },
+                {
+                    collection: true,
+                    ...opts,
+                },
+            )
+        } catch (err) {
+            if (err instanceof BlipError && err.code === 67) {
+                return []
+            }
+
+            throw err
+        }
+    }
+}

package/src/namespaces/configurations.ts

@@ -0,0 +1,19 @@
+import type { BlipClient } from '../client.ts'
+import { uri } from '../utils/uri.ts'
+import { Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class ConfigurationsNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'configurations', defaultOptions)
+    }
+
+    public getConfigurations(opts?: SendCommandOptions): Promise<Record<string, string>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/configuration`,
+            },
+            opts,
+        )
+    }
+}

package/src/namespaces/context.ts

@@ -0,0 +1,67 @@
+import type { BlipClient, Ticket } from '../index.ts'
+import { PluginSender } from '../sender/plugin/pluginsender.ts'
+import type { Account, BlipLanguage } from '../types/account.ts'
+import { Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class ContextNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, '', defaultOptions)
+    }
+
+    public async getCurrentTicket(): Promise<Ticket> {
+        const sender = this.checkSenderRealm('desk')
+        const { item } = await sender.channel.post<{ item: Ticket }>('currentTicket', null)
+        return item
+    }
+
+    public getUser(): Promise<Account> {
+        const sender = this.checkSenderRealm('portal')
+        return sender.channel.post('getUserContext', { command: 'getCurrentUser' })
+    }
+
+    public getLanguage(): Promise<BlipLanguage> {
+        const sender = this.checkSenderRealm()
+        return sender.channel.post('getCurrentLanguage', null)
+    }
+
+    public toast(type: 'success' | 'warning' | 'danger', message: string): void {
+        const sender = this.checkSenderRealm()
+        const fixedType = this.isOnBlipDesk() && type === 'danger' ? 'error' : type
+        sender.channel.post('toast', { type: fixedType, message }, { fireAndForget: true })
+    }
+
+    public changeHeight(height: number): void {
+        const sender = this.checkSenderRealm('portal')
+        sender.channel.post('heightChange', height, { fireAndForget: true })
+    }
+
+    public loading(show: boolean): void {
+        const sender = this.checkSenderRealm()
+        if (show) {
+            sender.channel.post('startLoading', {}, { fireAndForget: true })
+        } else {
+            sender.channel.post('stopLoading', {}, { fireAndForget: true })
+        }
+    }
+
+    public getUserToken(): Promise<string> {
+        const sender = this.checkSenderRealm('portal')
+        return sender.channel.post('getToken', null)
+    }
+
+    public isOnBlipDesk(): boolean {
+        return PluginSender.getRealm(this.blipClient) === 'desk'
+    }
+
+    public isOnPortal(): boolean {
+        return PluginSender.getRealm(this.blipClient) === 'portal'
+    }
+
+    private checkSenderRealm(realm?: 'portal' | 'desk') {
+        if (realm && PluginSender.getRealm(this.blipClient) !== realm) {
+            throw new Error(`This command is only allowed for ${realm} realm`)
+        }
+
+        return PluginSender.check(this.blipClient)
+    }
+}