@whitewall/blip-sdk 0.0.135 → 0.0.137

package/src/namespaces/namespace.ts

@@ -0,0 +1,125 @@
+import type { BlipClient } from '../client.ts'
+import { ConnectionSender } from '../sender/sender.ts'
+import { type Command, type CommandMethods, type Domain, type Identity, Node, type NodeLike } from '../types/index.ts'
+import { randomId } from '../utils/random.ts'
+import { type URI, uriToString } from '../utils/uri.ts'
+
+export type SendCommandOptions = {
+    to?: NodeLike
+    ownerIdentity?: Identity | Domain
+    domain?: Domain
+}
+
+export type ConsumeOptions = SendCommandOptions & {
+    take?: number
+    skip?: number
+    fetchall?: boolean
+    max?: number
+    // If true, it will try to parallel fetch data in chunks
+    // Be careful as this can be slower in situations with few data and will consume much more bandwidth
+    optimistic?: boolean
+}
+
+export class Namespace {
+    constructor(
+        protected readonly blipClient: BlipClient,
+        private readonly ownerSubdomain: string,
+        private readonly defaultOptions?: ConsumeOptions,
+    ) {}
+
+    get identity() {
+        return `postmaster@${this.ownerSubdomain ? `${this.ownerSubdomain}.` : ''}${this.defaultOptions?.domain ?? 'msging.net'}` as Identity
+    }
+
+    public async sendCommand<
+        TMethod extends CommandMethods,
+        TResponse = void,
+        TCollection = TResponse extends Array<unknown> ? true : false,
+    >(
+        command: Omit<Command<TMethod>, 'uri' | 'id' | 'to'> & {
+            uri: URI
+        },
+        opts?: ConsumeOptions & {
+            collection?: TCollection extends true ? true : never
+        },
+    ): Promise<TResponse> {
+        const options = { ...this.defaultOptions, ...opts }
+
+        let path = command.uri.path
+        const query = command.uri.query
+
+        const take = options?.take ?? Math.min(options?.max ?? 100, 100)
+
+        if (options?.collection) {
+            query.set('$take', take.toString())
+        }
+
+        if (options?.ownerIdentity) {
+            path = `lime://${options.ownerIdentity}${path}`
+        }
+
+        const domain =
+            options?.domain ??
+            (this.blipClient.sender instanceof ConnectionSender ? this.blipClient.sender.domain : 'msging.net')
+        const owner = new Node('postmaster', `${this.ownerSubdomain ? `${this.ownerSubdomain}.` : ''}${domain}`)
+
+        if (!options.collection) {
+            const commandToSend = {
+                id: randomId(),
+                to: options.to ?? owner,
+                ...command,
+                uri: uriToString({ path, query }),
+            } as Command<TMethod>
+            const response = await this.blipClient.sender.sendCommand(commandToSend)
+            return response as TResponse
+        }
+
+        if (options.optimistic && !options.max && !options.fetchall) {
+            throw new Error('Optimistic consume requires max or fetchall to be set')
+        }
+
+        let skip = options.skip ?? 0
+        let results: Array<TResponse> = []
+
+        while (true) {
+            const remaining = options.max !== undefined ? options.max - results.length : Number.POSITIVE_INFINITY
+            const potentialBatches = Math.ceil(remaining / take)
+            const batchSize = options.optimistic ? Math.min(potentialBatches, 20) : 1
+            const tasks = Array.from({ length: batchSize }, async (_, i: number) => {
+                const currentQuery = new Map(query)
+                currentQuery.set('$skip', (skip + i * take).toString())
+
+                const commandToSend = {
+                    id: randomId(),
+                    to: options.to ?? owner,
+                    ...command,
+                    uri: uriToString({ path, query: currentQuery }),
+                } as Command<TMethod>
+
+                const response = (await this.blipClient.sender.sendCommand(commandToSend)) as
+                    | { data: Array<TResponse> }
+                    | { items: Array<TResponse> }
+                const items: Array<TResponse> =
+                    'items' in response ? response.items : 'data' in response ? response.data : []
+
+                return items ?? []
+            })
+
+            const items = await Promise.all(tasks)
+            results = results.concat(items.flat())
+
+            if (
+                !options.fetchall ||
+                results.length % take !== 0 ||
+                results.length === 0 ||
+                (options.max !== undefined && results.length >= options.max)
+            ) {
+                break
+            }
+
+            skip += take * batchSize
+        }
+
+        return results as TResponse
+    }
+}

package/src/namespaces/plugins.ts

@@ -0,0 +1,223 @@
+import type { BlipClient } from '../client.ts'
+import type { BlipLanguage } from '../types/account.ts'
+import type { Identity } from '../types/node.ts'
+import type { DetailedPlugin, Plugin, PluginSubscription } from '../types/plugins.ts'
+import type { Application } from '../types/portal.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class PluginsNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'plugins', { ...defaultOptions, domain: 'blip.ai' })
+    }
+
+    public getTenantApplicationsWithPlugin(
+        tenantId: string,
+        pluginId: string,
+        opts?: ConsumeOptions,
+    ): Promise<Array<Application>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/applications`,
+            },
+            {
+                ...opts,
+                collection: true,
+                // This route doesn't handle pagination correctly, it will always fetch all
+                fetchall: false,
+            },
+        )
+    }
+
+    public getInstalledPlugins(tenantId: string, opts?: ConsumeOptions): Promise<Array<Plugin>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/plugins?${{ charge: 'all', onlySubscribed: 'true' }}`,
+            },
+            {
+                collection: true,
+                // This route doesn't handle pagination correctly, it will always fetch all
+                fetchall: false,
+                ...opts,
+            },
+        )
+    }
+
+    /**
+     * @param tenantId - The tenant id to use when fetching the plugins, only works as blip.ai user and the user should be a member of the tenant
+     */
+    public getPlugins(tenantId?: string, opts?: ConsumeOptions): Promise<Array<Plugin>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: tenantId
+                    ? uri`/tenants/${tenantId}/plugins?${{ charge: 'all' }}`
+                    : uri`/plugins?${{ charge: 'all' }}`,
+            },
+            {
+                collection: true,
+                // This route doesn't handle pagination correctly, it will always fetch all
+                fetchall: false,
+                ...opts,
+            },
+        )
+    }
+
+    public getPlugin(
+        pluginId: string,
+        query?: { returnInstalledBots?: boolean; language?: BlipLanguage },
+        opts?: ConsumeOptions,
+    ): Promise<DetailedPlugin> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/plugins/${pluginId}?${{ language: query?.language, returnInstalledBots: query?.returnInstalledBots }}`,
+            },
+            opts,
+        )
+    }
+
+    public getPluginSubscription(
+        tenantId: string,
+        pluginId: string,
+        opts?: ConsumeOptions,
+    ): Promise<PluginSubscription> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/subscription`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param settings.hasPartnerService - Whether the plugin has a partner service (default value: false)
+     * @param settings.language - The language to send the communication emails (default value: pt)
+     * @param settings.plan - If the plugin has multiple plans, the plan to subscribe to
+     */
+    public subscribeToPlugin(
+        tenantId: string,
+        pluginId: string,
+        settings: {
+            plan: number
+            hasPartnerService?: boolean
+            language?: BlipLanguage
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return this.sendCommand(
+            {
+                method: 'set',
+                type: 'application/vnd.iris.plugins.subscribe+json',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/subscribe`,
+                resource: {
+                    hasPartnerService: settings.hasPartnerService ?? false,
+                    language: settings.language ?? 'pt',
+                    plan: settings.plan,
+                    pluginId,
+                    // That means that it will be charged to the tenant, not sure if exists other values
+                    chargeType: 3,
+                },
+            },
+            opts,
+        )
+    }
+
+    public upgradePluginSubscription(
+        tenantId: string,
+        pluginId: string,
+        settings: {
+            plan: number
+            language?: BlipLanguage
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return this.sendCommand(
+            {
+                method: 'set',
+                type: 'application/vnd.iris.plugins.subscribe+json',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/upgrade`,
+                resource: {
+                    pluginId,
+                    plan: settings.plan,
+                    language: settings.language ?? 'pt',
+                },
+            },
+            opts,
+        )
+    }
+
+    public cancelPluginSubscription(
+        tenantId: string,
+        pluginId: string,
+        settings?: {
+            language?: BlipLanguage
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/cancel?${{ language: settings?.language ?? 'pt' }}`,
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param settings.language - The language to send the communication emails (default value: pt)
+     * @param settings.applicationIdentity - The application identity to install the plugin
+     */
+    public installPlugin(
+        tenantId: string,
+        pluginId: string,
+        settings: {
+            applicationIdentity: Identity
+            language?: BlipLanguage
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return this.sendCommand(
+            {
+                method: 'set',
+                type: 'application/vnd.iris.plugins.install+json',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/install`,
+                resource: {
+                    applicationIdentity: settings.applicationIdentity,
+                    language: settings.language ?? 'pt',
+                },
+            },
+            opts,
+        )
+    }
+
+    /**
+     * @param settings.language - The language to send the communication emails (default value: pt)
+     * @param settings.applicationIdentity - The application identity to uninstall the plugin
+     */
+    public uninstallPlugin(
+        tenantId: string,
+        pluginId: string,
+        settings: {
+            applicationIdentity: Identity
+            language?: BlipLanguage
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return this.sendCommand(
+            {
+                method: 'set',
+                type: 'application/vnd.iris.plugins.install+json',
+                uri: uri`/tenants/${tenantId}/plugins/${pluginId}/uninstall`,
+                resource: {
+                    applicationIdentity: settings.applicationIdentity,
+                    language: settings.language ?? 'pt',
+                },
+            },
+            opts,
+        )
+    }
+}