@whitewall/blip-sdk 0.0.135 → 0.0.137

package/src/namespaces/whatsapp.ts

@@ -0,0 +1,383 @@
+import type { BlipClient } from '../client.ts'
+import type { Identity } from '../types/index.ts'
+import type {
+    BodyComponent,
+    ButtonComponent,
+    HandleFormats,
+    HeaderComponent,
+    MessageTemplate,
+    MessageTemplateVariable,
+    WhatsappFlow,
+} from '../types/whatsapp.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class WhatsAppNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'wa.gw', defaultOptions)
+    }
+
+    public async phoneToIdentity(phoneNumber: string, opts?: ConsumeOptions): Promise<Identity> {
+        const fixedPhoneNumber = phoneNumber[0] !== '+' ? `+${phoneNumber}` : phoneNumber
+
+        try {
+            const result = await this.sendCommand<
+                'get',
+                {
+                    alternativeAccount: Identity
+                }
+            >(
+                {
+                    method: 'get',
+                    uri: uri`/accounts/${fixedPhoneNumber}`,
+                },
+                opts,
+            )
+
+            return result.alternativeAccount
+        } catch {
+            return `${phoneNumber.replace('+', '')}@wa.gw.msging.net`
+        }
+    }
+
+    /**
+     * This is a heavily cached endpoint on Meta, so it may take a while to reflect changes
+     * @param filters.status - Filter by status of the message template
+     * @param filters.name - Filter by name of the message template, supports partial match
+     */
+    public async getMessageTemplates(
+        filters?: Partial<{
+            status: MessageTemplate['status']
+            name: string
+        }>,
+        opts?: ConsumeOptions,
+    ): Promise<Array<MessageTemplate>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/message-templates?${{ status: filters?.status?.toUpperCase(), templateName: filters?.name }}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getMessageTemplate(
+        templateName: string,
+        language?: string,
+        opts?: ConsumeOptions,
+    ): Promise<(MessageTemplate & { variables: Array<MessageTemplateVariable> }) | undefined> {
+        let templates = await this.getMessageTemplates({ name: templateName }, opts)
+        if (language) {
+            templates = templates.filter((template) => template.language === language)
+        }
+        const template = templates.find((template) => template.name === templateName)
+        if (!template) {
+            return
+        }
+
+        const variables: Array<MessageTemplateVariable> = []
+
+        const handleHeader = template.components.find(
+            (c): c is HeaderComponent<HandleFormats> =>
+                c.type === 'HEADER' && ['IMAGE', 'VIDEO', 'DOCUMENT'].includes(c.format),
+        )
+        if (handleHeader) {
+            variables.push({ type: 'MEDIA', example: handleHeader.example.header_handle?.[0] })
+        }
+
+        const body = template.components.find((c): c is BodyComponent => c.type === 'BODY')
+        if (body?.example?.body_text) {
+            variables.push(...body.example.body_text[0].map((text) => ({ type: 'BODY' as const, example: text })))
+        } else if (body) {
+            variables.push(...(body.text.match(/{{(\d)}}/g)?.map(() => ({ type: 'BODY' as const })) ?? []))
+        }
+
+        const button = template.components.find((c): c is ButtonComponent => c.type === 'BUTTONS')
+        if (button) {
+            const urlButton = button.buttons.find((b) => b.type === 'URL')
+            if (urlButton?.example?.length) {
+                variables.push(...urlButton.example.map((example: string) => ({ type: 'BUTTON', example })))
+            } else if (urlButton) {
+                variables.push(...(urlButton.url.match(/{{(\d)}}/g)?.map(() => ({ type: 'BUTTON' })) ?? []))
+            }
+        }
+
+        return {
+            ...template,
+            variables,
+        }
+    }
+
+    public async createMessageTemplateAttachment(
+        url: string,
+        opts?: ConsumeOptions,
+    ): Promise<{
+        uploadSessionId: string
+        fileHandle: string
+        fileSize: string
+        fileSizeUploaded: string
+    }> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/message-templates-attachment`,
+                type: 'application/vnd.lime.media-link+json',
+                resource: {
+                    uri: url,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async createMessageTemplate(
+        template: Pick<MessageTemplate, 'name' | 'category' | 'language' | 'components'>,
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/message-templates`,
+                type: 'application/json',
+                resource: template,
+            },
+            opts,
+        )
+    }
+
+    public async createMessageTemplateAndPoll(
+        template: Pick<MessageTemplate, 'name' | 'category' | 'language' | 'components'>,
+        opts?: ConsumeOptions,
+    ): Promise<MessageTemplate> {
+        await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/message-templates`,
+                type: 'application/json',
+                resource: template,
+            },
+            opts,
+        )
+
+        while (true) {
+            await new Promise((resolve) => setTimeout(resolve, 3000))
+
+            const created = await this.getMessageTemplate(template.name, template.language, opts)
+            if (!created) {
+                throw new Error(`Template ${template.name} was not created`)
+            }
+
+            if (created.status !== 'PENDING') {
+                if (created.status === 'APPROVED') {
+                    return created
+                }
+
+                throw new Error(`Template ${template.name} was rejected: ${created.rejected_reason}`)
+            }
+        }
+    }
+
+    public async deleteMessageTemplate(templateName: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/message-templates/${templateName}`,
+            },
+            opts,
+        )
+    }
+
+    public async createFlow(
+        flow: { name: string; category: string; endpointUri?: string },
+        opts?: ConsumeOptions,
+    ): Promise<{ id: string }> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/whatsapp-flows`,
+                type: 'application/json',
+                resource: {
+                    name: flow.name,
+                    categories: [flow.category],
+                    endpoint_uri: flow.endpointUri,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async updateFlow(
+        id: string,
+        flow: { name?: string; endpointUri?: string },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/whatsapp-flows/${id}`,
+                type: 'application/json',
+                resource: {
+                    name: flow.name,
+                    endpoint_uri: flow.endpointUri,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async updateFlowJson(id: string, json: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/whatsapp-flows/flow-json/${id}`,
+                type: 'application/json',
+                resource: JSON.parse(json),
+            },
+            opts,
+        )
+    }
+
+    public async updateFlowsPublicKey(publicKey: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/whatsapp-flows/public-key/upload`,
+                type: 'application/json',
+                resource: {
+                    business_public_key: publicKey,
+                },
+            },
+            opts,
+        )
+    }
+
+    public async getFlows(opts?: ConsumeOptions): Promise<Array<WhatsappFlow>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/whatsapp-flows`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getFlow(id: string, opts?: ConsumeOptions): Promise<WhatsappFlow> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/whatsapp-flows/${id}`,
+            },
+            opts,
+        )
+    }
+
+    public async publishFlow(id: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/whatsapp-flows/publish/${id}`,
+            },
+            opts,
+        )
+    }
+
+    public async deprecateFlow(id: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/whatsapp-flows/deprecate/${id}`,
+            },
+            opts,
+        )
+    }
+
+    public async getFlowAssets(
+        id: string,
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ name: string; download_url: string }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/whatsapp-flows/assets/${id}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async deleteFlow(id: string, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/whatsapp-flows/${id}`,
+            },
+            opts,
+        )
+    }
+
+    public async isChannelActive(opts?: ConsumeOptions): Promise<boolean> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        return 'IsChannelActive' in configurations && configurations.IsChannelActive === 'True'
+    }
+
+    public async getWabaDetails(opts?: ConsumeOptions): Promise<{
+        id: string
+        name: string
+        reviewStatus: 'APPROVED' | 'PENDING' | 'REJECTED'
+        currency: string
+        messageTemplateNamespace: string
+    }> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/wabas/details`,
+            },
+            opts,
+        )
+    }
+
+    public async getPhoneNumberDetails(opts?: ConsumeOptions): Promise<{
+        id: string
+        account_mode: 'SANDBOX' | 'LIVE'
+        name_status: 'APPROVED' | 'DECLINED' | 'EXPIRED' | 'PENDING_REVIEW' | 'NONE'
+        new_name_status: 'APPROVED' | 'DECLINED' | 'EXPIRED' | 'PENDING_REVIEW' | 'NONE'
+        verified_name: string
+        display_phone_number: string
+        quality_rating: 'GREEN' | 'YELLOW' | 'RED' | 'UNKNOWN'
+        quality_score: {
+            score: 'GREEN' | 'YELLOW' | 'RED' | 'UNKNOWN'
+        }
+    }> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/phone-number-details`,
+            },
+            opts,
+        )
+    }
+
+    public async getPhoneNumber(opts?: ConsumeOptions): Promise<string> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+        if ('PhoneNumber' in configurations && 'CountryCode' in configurations) {
+            return `+${configurations.CountryCode}${configurations.PhoneNumber}`
+        }
+
+        throw new Error('Phone number not found')
+    }
+}

package/src/sender/bliperror.ts

@@ -0,0 +1,42 @@
+import type { CommandMethods, CommandResponse } from '../types/command.ts'
+import type { Reason } from '../types/reason.ts'
+import { ReasonCodes } from '../types/reason.ts'
+
+export class BlipError extends Error {
+    constructor(
+        public readonly uri: string,
+        public readonly cause: Reason,
+        public commandResponse?: CommandResponse<unknown, CommandMethods, 'failure'>,
+    ) {
+        super(`Blip command for ${uri} failed (${cause.code}): ${cause.description}`)
+    }
+
+    public get code(): number {
+        return this.cause.code
+    }
+
+    public static isFailedCommandResponse(
+        maybeCommandResponse: unknown,
+    ): maybeCommandResponse is CommandResponse<unknown, CommandMethods, 'failure'> {
+        return (
+            typeof maybeCommandResponse === 'object' &&
+            maybeCommandResponse !== null &&
+            'status' in maybeCommandResponse &&
+            maybeCommandResponse.status === 'failure'
+        )
+    }
+
+    public static commandResponseToBlipError(
+        uri: string,
+        commandResponse: CommandResponse<unknown, CommandMethods, 'failure'>,
+    ): BlipError {
+        return new BlipError(uri, commandResponse.reason, commandResponse)
+    }
+
+    static retryableBlipErrors = [
+        ReasonCodes.PipelineTimeout,
+        ReasonCodes.MaxThroughputExceeded,
+        ReasonCodes.GeneralError,
+        ReasonCodes.FailedToSendEnvelopeViaHTTP,
+    ]
+}

package/src/sender/enveloperesolver.ts

@@ -0,0 +1,148 @@
+import {
+    type CommonNotification,
+    type Envelope,
+    type FailedNotification,
+    type JsonObject,
+    type MaybePromise,
+    Node,
+    type Notification,
+    type UnknownCommand,
+    type UnknownMessage,
+    isCommand,
+    isMessage,
+    isNotification,
+} from '../types/index.ts'
+import { ReasonCodes } from '../types/reason.ts'
+import type { OpenConnectionSender } from './sender.ts'
+
+export type EventMap = {
+    message: (message: UnknownMessage) => MaybePromise<void>
+    command: (command: UnknownCommand) => MaybePromise<string | JsonObject> | MaybePromise<void>
+    notification: (notification: Notification) => MaybePromise<void>
+}
+
+export type Listener<K extends keyof EventMap> = {
+    predicate?: (...args: Parameters<EventMap[K]>) => boolean
+    callback: (...args: Parameters<EventMap[K]>) => ReturnType<EventMap[K]>
+}
+
+type Listeners = {
+    [K in keyof EventMap]: Array<Listener<K>>
+}
+
+export class EnvelopeResolver {
+    private readonly listeners: Listeners = {
+        message: [],
+        command: [],
+        notification: [],
+    }
+
+    private readonly waitingEnvelopeResponseResolvers: Record<string, (response: Envelope) => void> = {}
+
+    constructor(private readonly sender: OpenConnectionSender) {}
+
+    public async resolve(envelope: Envelope) {
+        const deferred = this.waitingEnvelopeResponseResolvers[envelope.id]
+        if (deferred) {
+            delete this.waitingEnvelopeResponseResolvers[envelope.id]
+            deferred(envelope)
+        } else if (isCommand(envelope)) {
+            if (envelope.method === 'get' && envelope.uri === '/ping') {
+                await this.sender.sendCommandResponse({
+                    id: envelope.id,
+                    to: envelope.from,
+                    method: 'get',
+                    type: 'application/vnd.lime.ping+json',
+                    status: 'success',
+                    resource: {},
+                })
+            } else {
+                try {
+                    const response = await this.emit('command', envelope)
+                    const type = typeof response === 'string' ? 'text/plain' : response ? 'application/json' : undefined
+                    const resource = typeof response === 'string' || response ? response : undefined
+                    await this.sender.sendCommandResponse({
+                        id: envelope.id,
+                        method: envelope.method,
+                        to: envelope.from,
+                        status: 'success',
+                        type,
+                        resource,
+                    })
+                } catch (err) {
+                    await this.sender.sendCommandResponse({
+                        id: envelope.id,
+                        method: envelope.method,
+                        to: envelope.from,
+                        status: 'failure',
+                        reason: {
+                            code: ReasonCodes.GeneralError,
+                            description: err instanceof Error ? err.message : String(err),
+                        },
+                    })
+                }
+            }
+        } else if (isMessage(envelope)) {
+            const shouldNotify =
+                !envelope.to || this.sender.session?.localNode.toIdentity() === Node.from(envelope.to).toIdentity()
+            const notify = async (notification: CommonNotification | FailedNotification) => {
+                if (shouldNotify) {
+                    await this.sender.sendNotification({
+                        ...notification,
+                        id: envelope.id,
+                        to: notification.event === 'failed' ? envelope.from : (envelope.pp ?? envelope.from),
+                    })
+                }
+            }
+
+            await notify({ event: 'received' })
+            try {
+                await this.emit('message', envelope)
+                await notify({ event: 'consumed' })
+            } catch (err) {
+                await notify({
+                    event: 'failed',
+                    reason: {
+                        code: ReasonCodes.GeneralError,
+                        description: err instanceof Error ? err.message : String(err),
+                    },
+                })
+            }
+        } else if (isNotification(envelope)) {
+            await this.emit('notification', envelope)
+        }
+    }
+
+    public createEnvelopeResponsePromise(id: string): Promise<Envelope> {
+        return new Promise((resolve) => {
+            this.waitingEnvelopeResponseResolvers[id] = resolve
+        })
+    }
+
+    public addListener<K extends keyof EventMap>(ev: K, listener: Listener<K>) {
+        if (this.listeners[ev].some((l) => l.callback === listener.callback)) {
+            throw new Error(`Listener for '${ev}' already exists.`)
+        }
+
+        this.listeners[ev].push(listener)
+    }
+
+    public removeListener<K extends keyof EventMap>(ev: K, callback: Listener<K>['callback']) {
+        this.listeners[ev] = this.listeners[ev].filter((l) => l.callback !== callback) as Listeners[K]
+    }
+
+    private async emit<K extends keyof EventMap>(
+        ev: K,
+        ...args: Parameters<EventMap[K]>
+    ): Promise<unknown | undefined> {
+        for (const listener of this.listeners[ev]) {
+            if (!listener.predicate || listener.predicate(...args)) {
+                const result = await listener.callback(...args)
+                if (result !== undefined) {
+                    return result
+                }
+            }
+        }
+        return undefined
+    }
+}

package/src/sender/gateway/customgatewaysender.ts

@@ -0,0 +1,43 @@
+import type { Message, MessageTypesContent } from '../../types/index.ts'
+import { ConnectionSender, type ConnectionSenderConstructor, type Sender } from '../sender.ts'
+
+export class CustomGatewayHttpSender extends ConnectionSender implements Sender {
+    private readonly baseurl: string
+    private readonly token: string
+
+    constructor(options: ConstructorParameters<ConnectionSenderConstructor>[0]) {
+        super(options)
+
+        if (options.authentication.scheme === 'plain') {
+            this.token = CustomGatewayHttpSender.createToken(options.node, btoa(options.authentication.password))
+        } else if (options.authentication.scheme === 'token') {
+            this.token = options.authentication.token
+        } else {
+            throw new Error('CustomGatewayHttpSender only supports plain or token authentication')
+        }
+
+        const prefix = options.tenantId ? `${options.tenantId}.` : ''
+        this.baseurl = `https://${prefix}custom.gw.${this.domain}`
+    }
+
+    public async sendMessage<Type extends keyof MessageTypesContent>(message: Message<Type>): Promise<void> {
+        const response = await fetch(`${this.baseurl}/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Basic ${this.token}`,
+            },
+            body: JSON.stringify(message),
+        })
+
+        if (!response.ok) {
+            throw new Error(`Failed to send message: ${response.statusText}`)
+        }
+    }
+
+    sendCommand(): Promise<unknown> {
+        throw new Error('Custom gateway clients cannot send commands')
+    }
+
+    public static login = ConnectionSender.login<CustomGatewayHttpSender>
+}