@whitewall/blip-sdk 0.0.136 → 0.0.138

package/src/types/session.ts

@@ -0,0 +1,22 @@
+import type { Authentication } from '../sender/security.ts'
+import type { Envelope } from './envelope.ts'
+import type { Reason } from './reason.ts'
+
+export type Session = Envelope & {
+    state: 'new' | 'negotiating' | 'authenticating' | 'established' | 'finishing' | 'finished' | 'failed'
+
+    encryptionOptions?: Array<string>
+    compressionOptions?: Array<string>
+    schemeOptions?: Array<string>
+
+    encryption?: string
+    compression?: string
+    scheme?: string
+
+    authentication?: Omit<Authentication, 'scheme'>
+    reason?: Reason
+}
+
+export const isSession = (value: Envelope): value is Session => {
+    return 'state' in value
+}

package/src/types/whatsapp.ts

@@ -0,0 +1,84 @@
+export type WhatsappFlow = {
+    id: string
+    name: string
+    status: 'DRAFT' | 'PUBLISHED' | 'DEPRECATED'
+    categories: Array<string>
+    validation_errors: Array<{
+        error: string
+        error_type: string
+        message: string
+    }>
+    preview: {
+        preview_url: string
+        expires_at: string
+    }
+    endpoint_uri?: string
+}
+
+// Components ref.: https://developers.facebook.com/docs/whatsapp/business-management-api/message-templates/components
+
+export type HandleFormats = 'IMAGE' | 'VIDEO' | 'DOCUMENT'
+
+type ExampleType<T extends 'TEXT' | 'LOCATION' | HandleFormats> = T extends 'TEXT'
+    ? { header_text?: Array<string> }
+    : T extends HandleFormats
+      ? { header_handle?: Array<string> }
+      : never
+
+export type HeaderComponent<T extends 'TEXT' | 'LOCATION' | HandleFormats> = {
+    type: 'HEADER'
+    format: T
+    example: ExampleType<T>
+}
+
+export type BodyComponent = {
+    type: 'BODY'
+    text: string
+    example?: {
+        body_text: [Array<string>]
+    }
+}
+
+export type FooterComponent = {
+    type: 'FOOTER'
+    text: string
+}
+
+export type ButtonComponent = {
+    type: 'BUTTONS'
+    buttons: Array<{
+        type: string
+        // biome-ignore lint/suspicious/noExplicitAny: Too hard to type this properly
+        [key: string]: any
+    }>
+}
+
+export type CarouselComponent = {
+    type: 'CAROUSEL'
+    cards: Array<{
+        components: Array<UnknownComponent>
+    }>
+}
+
+export type UnknownComponent =
+    | HeaderComponent<'TEXT' | 'LOCATION' | HandleFormats>
+    | BodyComponent
+    | FooterComponent
+    | ButtonComponent
+    | CarouselComponent
+
+export type MessageTemplate = {
+    id: string
+    name: string
+    category: 'AUTHENTICATION' | 'MARKETING' | 'UTILITY'
+    status: 'APPROVED' | 'REJECTED' | 'PENDING'
+    rejected_reason: string
+    language: string
+    last_update_time: string
+    components: Array<UnknownComponent>
+}
+
+export type MessageTemplateVariable = {
+    type: 'BODY' | 'MEDIA' | 'BUTTON'
+    example?: string
+}

package/src/utils/odata.ts

@@ -0,0 +1,114 @@
+type Primitive = string | number | Date | boolean
+
+export class ODataFilter<T> {
+    private filterParts: Array<string> = []
+
+    private getFormattedValue(value: Primitive | unknown): string {
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, '%27%27')}'`
+        } else if (value instanceof Date) {
+            return `datetimeoffset'${value.toISOString()}'`
+        } else if (typeof value === 'undefined' || value === null) {
+            return 'null'
+        } else {
+            return value.toString()
+        }
+    }
+
+    private addCondition(condition: string) {
+        this.filterParts.push(condition)
+    }
+
+    eq<K extends keyof T>(field: K, value: T[K]): ODataFilter<T> {
+        this.addCondition(`${String(field)} eq ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    ne<K extends keyof T>(field: K, value: T[K]): ODataFilter<T> {
+        this.addCondition(`${String(field)} ne ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    gt<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
+        this.addCondition(`${String(field)} gt ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    ge<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
+        this.addCondition(`${String(field)} ge ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    lt<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
+        this.addCondition(`${String(field)} lt ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    le<K extends keyof T>(field: K, value: T[K] | Date): ODataFilter<T> {
+        this.addCondition(`${String(field)} le ${this.getFormattedValue(value)}`)
+        return this
+    }
+
+    in<K extends keyof T>(field: K, values: Array<T[K]>): ODataFilter<T> {
+        const formattedValues = values.map((v) => this.getFormattedValue(v)).join(',')
+        this.addCondition(`${String(field)} in (${formattedValues})`)
+        return this
+    }
+
+    startsWith<K extends keyof T>(field: K, value: string): ODataFilter<T> {
+        this.addCondition(`startswith(${String(field)}, ${this.getFormattedValue(value)})`)
+        return this
+    }
+
+    endsWith<K extends keyof T>(field: K, value: string): ODataFilter<T> {
+        this.addCondition(`endswith(${String(field)}, ${this.getFormattedValue(value)})`)
+        return this
+    }
+
+    contains<K extends keyof T>(field: K, value: string): ODataFilter<T> {
+        this.addCondition(`contains(${String(field)}, ${this.getFormattedValue(value)})`)
+        return this
+    }
+
+    includes<K extends keyof T>(field: K, value: string): ODataFilter<T> {
+        this.addCondition(`substringof(${this.getFormattedValue(value)}, ${String(field)}) eq true`)
+        return this
+    }
+
+    notIncludes<K extends keyof T>(field: K, value: string): ODataFilter<T> {
+        this.addCondition(`substringof(${this.getFormattedValue(value)}, ${String(field)}) eq false`)
+        return this
+    }
+
+    and(filterBuilder: (filter: ODataFilter<T>) => ODataFilter<T>): ODataFilter<T> {
+        const newFilter = filterBuilder(new ODataFilter<T>())
+        if (newFilter.filterParts.length > 0) {
+            if (this.filterParts.length > 0) {
+                this.addCondition(`${this.toString()} and (${newFilter})`)
+            } else {
+                this.addCondition(`(${newFilter})`)
+            }
+            this.filterParts = [this.filterParts.pop()!] // keep only the latest compound condition
+        }
+        return this
+    }
+
+    or(filterBuilder: (filter: ODataFilter<T>) => ODataFilter<T>): ODataFilter<T> {
+        const newFilter = filterBuilder(new ODataFilter<T>())
+        if (newFilter.filterParts.length > 0) {
+            if (this.filterParts.length > 0) {
+                this.addCondition(`${this.toString()} or (${newFilter})`)
+            } else {
+                this.addCondition(`(${newFilter})`)
+            }
+            this.filterParts = [this.filterParts.pop()!] // keep only the latest compound condition
+        }
+        return this
+    }
+
+    toString(): string {
+        return this.filterParts.join(' and ')
+    }
+}
+
+export const filter = <T>(): ODataFilter<T> => new ODataFilter<T>()

package/src/utils/random.ts

@@ -0,0 +1,3 @@
+export const randomId = () => {
+    return Math.random().toString(36).substring(2)
+}

package/src/utils/uri.ts

@@ -0,0 +1,46 @@
+export interface URI {
+    path: string
+    // native URLSearchParams is not worth here
+    // we can't use URLSearchParams.toString() because it encodes the spaces as `+` instead of `%20`
+    // causing issues in some cases like odata queries
+    // also not encoding the keys is good for dev readability (lime doesn't care much about it)
+    query: Map<string, string>
+}
+
+export const uri = (parts: TemplateStringsArray, ...vars: Array<unknown>): URI => {
+    let queryObject: Record<string, unknown> | undefined
+    const last = vars[vars.length - 1]
+    if (last && last.constructor === Object) {
+        queryObject = last as Record<string, unknown>
+        vars.splice(vars.length - 1, 1)
+    }
+
+    const stringify = (v: unknown): string =>
+        v === undefined || v === null ? '' : v instanceof Date ? v.toISOString() : String(v)
+
+    const raw = parts.map((part, i) => part + encodeURIComponent(stringify(vars[i]))).join('')
+
+    const [path, rawQuery = ''] = raw.split('?', 2)
+    const query = new Map(new URLSearchParams(rawQuery))
+
+    if (queryObject) {
+        for (const [key, value] of Object.entries(queryObject)) {
+            if (value !== undefined && value !== null) {
+                query.set(key, stringify(value))
+            }
+        }
+    }
+
+    return { path, query }
+}
+
+export const uriToString = (uri: URI): string => {
+    if (uri.query.size === 0) {
+        return uri.path
+    }
+
+    const query = Array.from(uri.query)
+        .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+        .join('&')
+    return `${uri.path}?${query}`
+}