@whitewall/blip-sdk 0.0.174 → 0.0.176

package/src/namespaces/portal.ts

@@ -192,6 +192,116 @@ export class PortalNamespace extends Namespace {
         })
     }
 
+    public async getTenantActiveMessagesMetrics(
+        tenantId: string,
+        interval: 'D' | 'M' | 'NI',
+        filters?: {
+            applicationIdentity?: Identity
+            startDate?: Date | string
+            endDate?: Date | string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ intervalStart: string; intervalEnd: string; count: number }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/metrics/${tenantId}/active-messages/${interval}?${filters}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantReceivedMessagesMetrics(
+        tenantId: string,
+        interval: 'D' | 'M' | 'NI',
+        filters?: {
+            applicationIdentity?: Identity
+            startDate?: Date | string
+            endDate?: Date | string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ intervalStart: string; intervalEnd: string; count: number }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/metrics/${tenantId}/received-messages/${interval}?${filters}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantSentMessagesMetrics(
+        tenantId: string,
+        interval: 'D' | 'M' | 'NI',
+        filters?: {
+            applicationIdentity?: Identity
+            startDate?: Date | string
+            endDate?: Date | string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ intervalStart: string; intervalEnd: string; count: number }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/metrics/${tenantId}/sent-messages/${interval}?${filters}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantActiveUsersMetrics(
+        tenantId: string,
+        interval: 'D' | 'M' | 'NI',
+        filters?: {
+            applicationIdentity?: Identity
+            startDate?: Date | string
+            endDate?: Date | string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ intervalStart: string; intervalEnd: string; count: number }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/metrics/${tenantId}/active-users/${interval}?${filters}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantEngagedUsersMetrics(
+        tenantId: string,
+        interval: 'D' | 'M' | 'NI',
+        filters?: {
+            applicationIdentity?: Identity
+            startDate?: Date | string
+            endDate?: Date | string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<Array<{ intervalStart: string; intervalEnd: string; count: number }>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/metrics/${tenantId}/engaged-users/${interval}?${filters}`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
     public async tenantExists(tenantId: string): Promise<boolean> {
         try {
             await this.sendCommand({

package/src/namespaces/tunnel.ts

@@ -0,0 +1,58 @@
+import type { BlipClient } from '../client.ts'
+import { type Identity, Node } from '../types/index.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class TunnelNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'tunnel', defaultOptions)
+    }
+
+    /**
+     * Retrieves metadata information about the tunnel origin and destination
+     * This must only be called by a subbot
+     * @returns An object containing:
+     * - `owner` - The identity of the subbot owner (router)
+     * - `originator` - The identity of the originator on the router (user)
+     * - `destination` - The identity of the destination child (subbot)
+     */
+    public getTunnel(
+        tunnelIdentityOrName: Identity | string,
+        opts?: ConsumeOptions,
+    ): Promise<{
+        owner: Identity
+        originator: Identity
+        destination: Identity
+    }> {
+        const node =
+            typeof tunnelIdentityOrName === 'string'
+                ? new Node(tunnelIdentityOrName, 'tunnel.msging.net')
+                : Node.from(tunnelIdentityOrName)
+
+        if (node.getSource() !== 'Tunnel') {
+            throw new Error('Invalid tunnel identity or name')
+        }
+
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tunnels/${node.name}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * Retrieves the tunnel ID for a given originator and destination
+     * Must only be called by a router
+     * @param originator - The identity of the originator on the router (user)
+     * @param destination - The identity of the destination child (subbot)
+     * @returns The tunnel ID
+     */
+    public getTunnelId(originator: Identity, destination: Identity) {
+        return this.sendCommand({
+            method: 'get',
+            uri: uri`/tunnels/${originator}/${destination}`,
+        })
+    }
+}

package/src/namespaces/whatsapp.ts

@@ -1,16 +1,8 @@
 import type { BlipClient } from '../client.ts'
 import type { Identity } from '../types/index.ts'
-import type {
-    BodyComponent,
-    ButtonComponent,
-    HandleFormats,
-    HeaderComponent,
-    MessageTemplate,
-    MessageTemplateVariable,
-    WhatsAppTemplateLanguage,
-    WhatsappFlow,
-} from '../types/whatsapp.ts'
+import type { MessageTemplate, WhatsAppTemplateLanguage, WhatsappFlow } from '../types/whatsapp.ts'
 import { uri } from '../utils/uri.ts'
+import { getMessageTemplateVariables } from '../utils/whatsapp.ts'
 import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
 
 export class WhatsAppNamespace extends Namespace {
@@ -69,7 +61,7 @@ export class WhatsAppNamespace extends Namespace {
         templateName: string,
         language?: WhatsAppTemplateLanguage,
         opts?: ConsumeOptions,
-    ): Promise<(MessageTemplate & { variables: Array<MessageTemplateVariable> }) | undefined> {
+    ): Promise<(MessageTemplate & { variables: ReturnType<typeof getMessageTemplateVariables> }) | undefined> {
         let templates = await this.getMessageTemplates({ name: templateName }, opts)
         if (language) {
             templates = templates.filter((template) => template.language === language)
@@ -79,36 +71,9 @@ export class WhatsAppNamespace extends Namespace {
             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,
+            variables: getMessageTemplateVariables(template.components),
         }
     }
 

package/src/sender/http/httpsender.ts

@@ -1,4 +1,11 @@
-import type { Command, CommandMethods, Message, MessageTypes, UnknownCommandResponse } from '../../types/index.ts'
+import {
+    type Command,
+    type CommandMethods,
+    type Message,
+    type MessageTypes,
+    Node,
+    type UnknownCommandResponse,
+} from '../../types/index.ts'
 import { BlipError } from '../bliperror.ts'
 import { RetryableError } from '../retryableerror.ts'
 import { ConnectionSender, type ConnectionSenderConstructor, type Sender } from '../sender.ts'
@@ -6,7 +13,7 @@ import { EnvelopeThrottler } from '../throttler.ts'
 
 export class HttpSender extends ConnectionSender implements Sender {
     private readonly baseurl: string
-    private readonly token: string
+    private readonly authHeaders: Record<string, string>
     private readonly throttler = new EnvelopeThrottler()
 
     constructor(options: ConstructorParameters<ConnectionSenderConstructor>[0]) {
@@ -16,11 +23,18 @@ export class HttpSender extends ConnectionSender implements Sender {
         this.baseurl = `https://${prefix}http.${this.domain}`
 
         if (options.authentication.scheme === 'key') {
-            this.token = HttpSender.createToken(options.node, options.authentication.key)
+            const token = HttpSender.createToken(options.node, options.authentication.key)
+            this.authHeaders = { Authorization: `Key ${token}` }
         } else if (options.authentication.scheme === 'token') {
-            this.token = options.authentication.token
+            this.authHeaders = { Authorization: `Key ${options.authentication.token}` }
+        } else if (options.authentication.scheme === 'external') {
+            this.authHeaders = {
+                Authorization: `Bearer ${options.authentication.token}`,
+                'http-session-authentication-external-issuer': options.authentication.issuer,
+                'http-session-identity': Node.from(options.node).toIdentity(),
+            }
         } else {
-            throw new Error('HttpSender only supports key or token authentication')
+            throw new Error('HttpSender only supports key, token, or external authentication')
         }
     }
 
@@ -62,7 +76,7 @@ export class HttpSender extends ConnectionSender implements Sender {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                Authorization: `Key ${this.token}`,
+                ...this.authHeaders,
             },
             body,
         })

package/src/sender/multi/multisender.ts

@@ -4,12 +4,17 @@ import type { Sender } from '../sender.ts'
 
 export type SenderFactory = () => MaybePromise<Sender>
 
+const isSenderFactory = (value: Sender | SenderFactory): value is SenderFactory => value instanceof Function
+
+type SenderEntry = {
+    filter: (envelope: Envelope) => boolean | undefined
+    factory: () => Promise<Sender>
+    resolved?: Sender
+    resolving?: Promise<Sender>
+}
+
 export class MultiSender implements Sender, Closable {
-    private senders: Array<{
-        filter: (envelope: Envelope) => boolean | undefined
-        sender: Sender | SenderFactory
-        resolved?: Sender
-    }>
+    private senders: Array<SenderEntry>
 
     /**
      * @param initializers Array of objects containing a filter function and a sender or a factory function that returns a sender.
@@ -23,11 +28,14 @@ export class MultiSender implements Sender, Closable {
             sender: Sender | SenderFactory
         }>,
     ) {
-        this.senders = initializers.map(({ filter, sender }) => ({
-            filter: filter ?? (() => true),
-            sender,
-            resolved: sender instanceof Function ? undefined : sender,
-        }))
+        this.senders = initializers.map(({ filter, sender }) => {
+            const isFactory = isSenderFactory(sender)
+            return {
+                filter: filter ?? (() => true),
+                factory: isFactory ? () => Promise.resolve(sender()) : () => Promise.resolve(sender),
+                resolved: isFactory ? undefined : sender,
+            }
+        })
     }
 
     async sendMessage<Type extends MessageTypes>(message: Message<Type>): Promise<void> {
@@ -57,14 +65,30 @@ export class MultiSender implements Sender, Closable {
         return matched.resolved! as InstanceType<TProto>
     }
 
-    private async getSender(envelope: Envelope): Promise<Sender> {
+    private getSender(envelope: Envelope): Promise<Sender> {
         const matched = this.senders.find(({ filter }) => filter(envelope))
         if (!matched) throw new Error('No sender matched for envelope')
 
-        if (!matched.resolved) {
-            matched.resolved = typeof matched.sender === 'function' ? await matched.sender() : matched.sender
+        return this.resolveSender(matched)
+    }
+
+    private resolveSender(entry: SenderEntry): Promise<Sender> {
+        if (entry.resolved) return Promise.resolve(entry.resolved)
+
+        if (!entry.resolving) {
+            entry.resolving = entry
+                .factory()
+                .then((sender) => {
+                    entry.resolved = sender
+                    entry.resolving = undefined
+                    return sender
+                })
+                .catch((error) => {
+                    entry.resolving = undefined
+                    throw error
+                })
         }
 
-        return matched.resolved
+        return entry.resolving
     }
 }

package/src/sender/sessionnegotiator.ts

@@ -125,7 +125,7 @@ export class SessionNegotiator {
             return
         }
 
-        if (this.presencePromise) {
+        if (this.presencePromise !== null) {
             return this.presencePromise
         }
 

package/src/sender/tcp/tcpsender.ts

@@ -144,7 +144,7 @@ class TCPHandle<T> {
     }
 
     public async close() {
-        if (!this.closing && this.currentSocketPromise) {
+        if (!this.closing && this.currentSocketPromise !== null) {
             this.closing = true
             const current = await this.currentSocketPromise
             current.end().removeAllListeners().destroySoon()

package/src/sender/websocket/websocketsender.ts

@@ -138,7 +138,7 @@ class WebSocketHandle<T> {
     }
 
     public async close() {
-        if (!this.closing && this.currentWebSocketPromise) {
+        if (!this.closing && this.currentWebSocketPromise !== null) {
             this.closing = true
             const current = await this.currentWebSocketPromise
             current.close()

package/src/types/desk.ts

@@ -1,3 +1,5 @@
+import type { Identity } from './node.ts'
+
 export type TicketStatus =
     | 'Waiting'
     | 'Open'
@@ -12,6 +14,8 @@ export type AttendanceHour = {
     title: string
     description: string
     isMain: boolean
+    storageDate?: string
+    timeZoneId?: string
 }
 
 export enum DayOfWeek {
@@ -38,14 +42,75 @@ export type AttendanceHourOffItem = {
     endDate: string
 }
 
-export type Queue = {
+export type DescriptionDocument = {
     id: string
     description: string
 }
 
+export type Queue = DescriptionDocument
+
 export type DetailedAttendanceHour = {
     attendanceHour: AttendanceHour
     attendanceHourScheduleItems: Array<AttendanceHourScheduleItem>
     attendanceHourOffItems: Array<AttendanceHourOffItem>
     queues: Array<Queue>
+    attendants: Array<DescriptionDocument>
+}
+
+export type DeskAttendanceQueue = {
+    id?: string
+    ownerIdentity?: Identity
+    name: string
+    isActive: boolean
+    storageDate?: string
+    priority?: number
+    uniqueId?: string
+    attendanceHourId?: string
+}
+
+export type DeskAttendanceQueueTag = {
+    id?: string
+    attendanceQueueId?: string
+    ownerIdentity?: Identity
+    tag: string
+}
+
+export type DeskRuleRelation = 'Contains' | 'NotContains' | 'Equals' | 'NotEquals'
+
+export type DeskRuleOperator = 'Or' | 'And'
+
+export type DeskRuleCondition = {
+    property: string
+    relation: DeskRuleRelation
+    values: Array<string>
+}
+
+export type DeskRule = {
+    id?: string
+    ownerIdentity?: Identity
+    title: string
+    team: string
+    property?: string
+    relation?: DeskRuleRelation
+    isActive?: boolean
+    values?: Array<string>
+    conditions?: Array<DeskRuleCondition>
+    operator?: DeskRuleOperator
+    priority?: number
+    storageDate?: string
+    queueId?: string
+}
+
+export type DeskPriorityRule = {
+    id?: string
+    ownerIdentity?: Identity
+    title: string
+    queueId: string
+    isActive?: boolean
+    conditions?: Array<DeskRuleCondition>
+    operator?: DeskRuleOperator
+    priority?: number
+    urgency: number
+    applyConditions: boolean
+    storageDate?: string
 }