@whitewall/blip-sdk 0.0.167 → 0.0.169

package/src/namespaces/desk.ts

@@ -364,7 +364,7 @@ export class DeskNamespace extends Namespace {
                     audience: {
                         recipient: phoneNumber,
                         recipientType: 'phoneNumber',
-                        channelType: 'whatsApp',
+                        channelType: 'whatsapp',
                         messageParams: { ...message.variables },
                     },
                     message: {
@@ -637,12 +637,11 @@ export class DeskNamespace extends Namespace {
                 ) {
                     delete extensions[id]
                 }
-
-                return await this.blipClient.account.setConfigurations(
-                    { Extensions: JSON.stringify(extensions) },
-                    { ...opts, ownerIdentity: this.identity },
-                )
             }
+            return await this.blipClient.account.setConfigurations(
+                { Extensions: JSON.stringify(extensions) },
+                { ...opts, ownerIdentity: this.identity },
+            )
         }
     }
 

package/src/schemas/index.ts

@@ -1,20 +1 @@
-import './utils/validate.ts'
-
 export * from './webhook.ts'
-
-import type { WebhookTypes } from '../types/webhook.ts'
-
-import { contactSchema, eventSchema, messageSchema } from './webhook.ts'
-
-export const isWebhookType = <T extends keyof WebhookTypes>(type: T, data: unknown): data is WebhookTypes[T] => {
-    switch (type) {
-        case 'contacts':
-            return !eventSchema.safeParse(data).success && contactSchema.safeParse(data).success
-        case 'messages':
-            return messageSchema.safeParse(data).success
-        case 'events':
-            return eventSchema.safeParse(data).success
-        default:
-            return false
-    }
-}

package/src/schemas/webhook.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod'
 import type { UnknownMessage } from '../types/index.ts'
+import './utils/validate.ts'
+import type { WebhookTypes } from '../types/webhook.ts'
 
-export const contactSchema = z.object({
+export const contactsSchema = z.object({
     identity: z.string().identity(),
     name: z.string().optional(),
     group: z.string().optional(),
@@ -13,9 +15,9 @@ export const contactSchema = z.object({
     extras: z.record(z.string(), z.string().or(z.null())).optional(),
 })
 
-export const messageSchema = z
+export const messagesSchema = z
     .object({
-        id: z.string().optional(),
+        id: z.string(),
         type: z.string(),
         from: z.string().identity(),
         to: z.string().identity(),
@@ -31,7 +33,7 @@ export const messageSchema = z
             },
     )
 
-export const eventSchema = z.object({
+export const eventtrackingsSchema = z.object({
     identity: z.string().identity().optional(),
     messageId: z.string().optional(),
     category: z.string(),
@@ -44,4 +46,17 @@ export const eventSchema = z.object({
 
 // The order is important here. We must try to parse more specific types first.
 // e.g., if contact came before event, no event would be ever caught as such
-export const blipWebhookSchema = eventSchema.or(messageSchema).or(contactSchema)
+export const blipWebhookSchema = eventtrackingsSchema.or(messagesSchema).or(contactsSchema)
+
+export const isWebhookType = <T extends keyof WebhookTypes>(type: T, data: unknown): data is WebhookTypes[T] => {
+    switch (type) {
+        case 'contacts':
+            return !eventtrackingsSchema.safeParse(data).success && contactsSchema.safeParse(data).success
+        case 'messages':
+            return messagesSchema.safeParse(data).success
+        case 'eventtrackings':
+            return eventtrackingsSchema.safeParse(data).success
+        default:
+            return false
+    }
+}

package/src/sender/enveloperesolver.ts

@@ -2,15 +2,15 @@ import {
     type CommonNotification,
     type Envelope,
     type FailedNotification,
+    isCommand,
+    isMessage,
+    isNotification,
     type Json,
     type MaybePromise,
     Node,
     type Notification,
     type UnknownCommand,
     type UnknownMessage,
-    isCommand,
-    isMessage,
-    isNotification,
 } from '../types/index.ts'
 import { ReasonCodes } from '../types/reason.ts'
 import { RetryableError } from './retryableerror.ts'

package/src/sender/index.ts

@@ -1,8 +1,8 @@
-export * from './sender.ts'
 export * from './bliperror.ts'
 export * from './gateway/customgatewaysender.ts'
-export * from './plugin/pluginsender.ts'
+export * from './http/httpsender.ts'
 export * from './multi/multisender.ts'
-export * from './websocket/websocketsender.ts'
+export * from './plugin/pluginsender.ts'
+export * from './sender.ts'
 export * from './tcp/tcpsender.ts'
-export * from './http/httpsender.ts'
+export * from './websocket/websocketsender.ts'

package/src/sender/sessionnegotiator.ts

@@ -23,13 +23,10 @@ export class SessionNegotiator {
         private readonly sendSession: (session: Session) => void,
     ) {}
 
-    public async negotiate(options: {
-        node: NodeLike
-        authentication: Authentication
-    }): Promise<void> {
-        const timeout = setTimeout(() => {
+    public async negotiate(options: { node: NodeLike; authentication: Authentication }): Promise<void> {
+        const timeout = setTimeout(async () => {
             if (this.negotiating) {
-                this.sender.close()
+                await this.sender.close()
                 throw new Error('Negotiation timeout')
             }
         }, 60000) // 60 seconds

package/src/sender/tcp/tcpsender.ts

@@ -33,7 +33,7 @@ export class TCPSender extends OpenConnectionSender {
         this.connectionHandle = new TCPHandle<Envelope>(
             `${prefix}tcp.${this.domain}`,
             443,
-            async (socket) => {
+            (socket) => {
                 this.sessionNegotiator = new SessionNegotiator(this, (session) => {
                     socket.write(JSON.stringify(session))
                 })

package/src/types/index.ts

@@ -1,13 +1,13 @@
-export * from './node.ts'
+export * from './account.ts'
+export * from './analytics.ts'
+export * from './command.ts'
+export * from './commons.ts'
+export * from './desk.ts'
 export * from './envelope.ts'
+export * from './flow.ts'
 export * from './message.ts'
-export * from './command.ts'
+export * from './node.ts'
 export * from './notification.ts'
-export * from './desk.ts'
-export * from './account.ts'
-export * from './whatsapp.ts'
-export * from './portal.ts'
 export * from './plugins.ts'
-export * from './analytics.ts'
-export * from './flow.ts'
-export * from './commons.ts'
+export * from './portal.ts'
+export * from './whatsapp.ts'

package/src/types/message.ts

@@ -101,7 +101,7 @@ export const isMessage = (envelope: Envelope): envelope is UnknownMessage =>
     'type' in envelope && 'content' in envelope && typeof envelope.type === 'string'
 
 export const isMessageOfType = <Type extends MessageTypes>(
-    message: UnknownMessageContent,
+    message: UnknownMessage,
     type: Type,
 ): message is Message<Type> => message.type === type
 

package/src/types/webhook.ts

@@ -1,8 +1,10 @@
 import type { z } from 'zod'
-import type { contactSchema, eventSchema, messageSchema } from '../schemas/index.ts'
+import type { contactsSchema, eventtrackingsSchema, messagesSchema } from '../schemas/index.ts'
 
 export type WebhookTypes = {
-    contacts: z.TypeOf<typeof contactSchema>
-    messages: z.TypeOf<typeof messageSchema>
-    events: z.TypeOf<typeof eventSchema>
+    contacts: z.TypeOf<typeof contactsSchema>
+    messages: z.TypeOf<typeof messagesSchema>
+    eventtrackings: z.TypeOf<typeof eventtrackingsSchema>
 }
+
+export const webhookTypes = ['contacts', 'messages', 'eventtrackings'] as const satisfies Array<keyof WebhookTypes>

package/src/utils/logger.ts

@@ -23,6 +23,7 @@ export const logger = {
         }
 
         const prefix = `[${module}] ${message}`
+        // biome-ignore lint/suspicious/noConsole: it is the logger
         console[level].apply(console, [prefix, ...args])
     },
     error: function (module: string, message: string, ...args: Array<unknown>): void {