@botpress/webchat-client 0.1.0

package/dist/webchat-client9.js

@@ -0,0 +1,218 @@
+var R = Object.defineProperty;
+var T = (t, r, e) => r in t ? R(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var j = (t, r, e) => T(t, typeof r != "symbol" ? r + "" : r, e);
+var U = async (t, r) => {
+  let e = typeof r == "function" ? await r(t) : r;
+  if (e) return t.scheme === "bearer" ? `Bearer ${e}` : t.scheme === "basic" ? `Basic ${btoa(e)}` : e;
+}, A = { bodySerializer: (t) => JSON.stringify(t, (r, e) => typeof e == "bigint" ? e.toString() : e) }, _ = (t) => {
+  switch (t) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, z = (t) => {
+  switch (t) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+}, E = (t) => {
+  switch (t) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, x = ({ allowReserved: t, explode: r, name: e, style: l, value: n }) => {
+  if (!r) {
+    let s = (t ? n : n.map((i) => encodeURIComponent(i))).join(z(l));
+    switch (l) {
+      case "label":
+        return `.${s}`;
+      case "matrix":
+        return `;${e}=${s}`;
+      case "simple":
+        return s;
+      default:
+        return `${e}=${s}`;
+    }
+  }
+  let o = _(l), a = n.map((s) => l === "label" || l === "simple" ? t ? s : encodeURIComponent(s) : b({ allowReserved: t, name: e, value: s })).join(o);
+  return l === "label" || l === "matrix" ? o + a : a;
+}, b = ({ allowReserved: t, name: r, value: e }) => {
+  if (e == null) return "";
+  if (typeof e == "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+  return `${r}=${t ? e : encodeURIComponent(e)}`;
+}, $ = ({ allowReserved: t, explode: r, name: e, style: l, value: n }) => {
+  if (n instanceof Date) return `${e}=${n.toISOString()}`;
+  if (l !== "deepObject" && !r) {
+    let s = [];
+    Object.entries(n).forEach(([d, f]) => {
+      s = [...s, d, t ? f : encodeURIComponent(f)];
+    });
+    let i = s.join(",");
+    switch (l) {
+      case "form":
+        return `${e}=${i}`;
+      case "label":
+        return `.${i}`;
+      case "matrix":
+        return `;${e}=${i}`;
+      default:
+        return i;
+    }
+  }
+  let o = E(l), a = Object.entries(n).map(([s, i]) => b({ allowReserved: t, name: l === "deepObject" ? `${e}[${s}]` : s, value: i })).join(o);
+  return l === "label" || l === "matrix" ? o + a : a;
+}, W = /\{[^{}]+\}/g, D = ({ path: t, url: r }) => {
+  let e = r, l = r.match(W);
+  if (l) for (let n of l) {
+    let o = !1, a = n.substring(1, n.length - 1), s = "simple";
+    a.endsWith("*") && (o = !0, a = a.substring(0, a.length - 1)), a.startsWith(".") ? (a = a.substring(1), s = "label") : a.startsWith(";") && (a = a.substring(1), s = "matrix");
+    let i = t[a];
+    if (i == null) continue;
+    if (Array.isArray(i)) {
+      e = e.replace(n, x({ explode: o, name: a, style: s, value: i }));
+      continue;
+    }
+    if (typeof i == "object") {
+      e = e.replace(n, $({ explode: o, name: a, style: s, value: i }));
+      continue;
+    }
+    if (s === "matrix") {
+      e = e.replace(n, `;${b({ name: a, value: i })}`);
+      continue;
+    }
+    let d = encodeURIComponent(s === "label" ? `.${i}` : i);
+    e = e.replace(n, d);
+  }
+  return e;
+}, q = ({ allowReserved: t, array: r, object: e } = {}) => (l) => {
+  let n = [];
+  if (l && typeof l == "object") for (let o in l) {
+    let a = l[o];
+    if (a != null) {
+      if (Array.isArray(a)) {
+        n = [...n, x({ allowReserved: t, explode: !0, name: o, style: "form", value: a, ...r })];
+        continue;
+      }
+      if (typeof a == "object") {
+        n = [...n, $({ allowReserved: t, explode: !0, name: o, style: "deepObject", value: a, ...e })];
+        continue;
+      }
+      n = [...n, b({ allowReserved: t, name: o, value: a })];
+    }
+  }
+  return n.join("&");
+}, I = (t) => {
+  var e;
+  if (!t) return "stream";
+  let r = (e = t.split(";")[0]) == null ? void 0 : e.trim();
+  if (r) {
+    if (r.startsWith("application/json") || r.endsWith("+json")) return "json";
+    if (r === "multipart/form-data") return "formData";
+    if (["application/", "audio/", "image/", "video/"].some((l) => r.startsWith(l))) return "blob";
+    if (r.startsWith("text/")) return "text";
+  }
+}, k = async ({ security: t, ...r }) => {
+  for (let e of t) {
+    let l = await U(e, r.auth);
+    if (!l) continue;
+    let n = e.name ?? "Authorization";
+    switch (e.in) {
+      case "query":
+        r.query || (r.query = {}), r.query[n] = l;
+        break;
+      case "cookie":
+        r.headers.append("Cookie", `${n}=${l}`);
+        break;
+      case "header":
+      default:
+        r.headers.set(n, l);
+        break;
+    }
+    return;
+  }
+}, v = (t) => N({ baseUrl: t.baseUrl, path: t.path, query: t.query, querySerializer: typeof t.querySerializer == "function" ? t.querySerializer : q(t.querySerializer), url: t.url }), N = ({ baseUrl: t, path: r, query: e, querySerializer: l, url: n }) => {
+  let o = n.startsWith("/") ? n : `/${n}`, a = (t ?? "") + o;
+  r && (a = D({ path: r, url: a }));
+  let s = e ? l(e) : "";
+  return s.startsWith("?") && (s = s.substring(1)), s && (a += `?${s}`), a;
+}, g = (t, r) => {
+  var l;
+  let e = { ...t, ...r };
+  return (l = e.baseUrl) != null && l.endsWith("/") && (e.baseUrl = e.baseUrl.substring(0, e.baseUrl.length - 1)), e.headers = C(t.headers, r.headers), e;
+}, C = (...t) => {
+  let r = new Headers();
+  for (let e of t) {
+    if (!e || typeof e != "object") continue;
+    let l = e instanceof Headers ? e.entries() : Object.entries(e);
+    for (let [n, o] of l) if (o === null) r.delete(n);
+    else if (Array.isArray(o)) for (let a of o) r.append(n, a);
+    else o !== void 0 && r.set(n, typeof o == "object" ? JSON.stringify(o) : o);
+  }
+  return r;
+}, w = class {
+  constructor() {
+    j(this, "_fns");
+    this._fns = [];
+  }
+  clear() {
+    this._fns = [];
+  }
+  exists(t) {
+    return this._fns.indexOf(t) !== -1;
+  }
+  eject(t) {
+    let r = this._fns.indexOf(t);
+    r !== -1 && (this._fns = [...this._fns.slice(0, r), ...this._fns.slice(r + 1)]);
+  }
+  use(t) {
+    this._fns = [...this._fns, t];
+  }
+}, P = () => ({ error: new w(), request: new w(), response: new w() }), H = /* @__PURE__ */ q({ allowReserved: !1, array: { explode: !0, style: "form" }, object: { explode: !0, style: "deepObject" } }), J = { "Content-Type": "application/json" }, O = (t = {}) => ({ ...A, headers: J, parseAs: "auto", querySerializer: H, ...t }), B = (t = {}) => {
+  let r = g(O(), t), e = () => ({ ...r }), l = (a) => (r = g(r, a), e()), n = P(), o = async (a) => {
+    let s = { ...r, ...a, fetch: a.fetch ?? r.fetch ?? globalThis.fetch, headers: C(r.headers, a.headers) };
+    s.security && await k({ ...s, security: s.security }), s.body && s.bodySerializer && (s.body = s.bodySerializer(s.body)), (s.body === void 0 || s.body === "") && s.headers.delete("Content-Type");
+    let i = v(s), d = { redirect: "follow", ...s }, f = new Request(i, d);
+    for (let c of n.request._fns) f = await c(f, s);
+    let S = s.fetch, u = await S(f);
+    for (let c of n.response._fns) u = await c(u, f, s);
+    let h = { request: f, response: u };
+    if (u.ok) {
+      if (u.status === 204 || u.headers.get("Content-Length") === "0") return { data: {}, ...h };
+      let c = (s.parseAs === "auto" ? I(u.headers.get("Content-Type")) : s.parseAs) ?? "json";
+      if (c === "stream") return { data: u.body, ...h };
+      let m = await u[c]();
+      return c === "json" && (s.responseValidator && await s.responseValidator(m), s.responseTransformer && (m = await s.responseTransformer(m))), { data: m, ...h };
+    }
+    let y = await u.text();
+    try {
+      y = JSON.parse(y);
+    } catch {
+    }
+    let p = y;
+    for (let c of n.error._fns) p = await c(y, u, f, s);
+    if (p = p || {}, s.throwOnError) throw p;
+    return { error: p, ...h };
+  };
+  return { buildUrl: v, connect: (a) => o({ ...a, method: "CONNECT" }), delete: (a) => o({ ...a, method: "DELETE" }), get: (a) => o({ ...a, method: "GET" }), getConfig: e, head: (a) => o({ ...a, method: "HEAD" }), interceptors: n, options: (a) => o({ ...a, method: "OPTIONS" }), patch: (a) => o({ ...a, method: "PATCH" }), post: (a) => o({ ...a, method: "POST" }), put: (a) => o({ ...a, method: "PUT" }), request: o, setConfig: l, trace: (a) => o({ ...a, method: "TRACE" }) };
+}, V = B, G = O;
+export {
+  V as createClient,
+  G as createConfig
+};

package/openapi-ts.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from '@hey-api/openapi-ts'
+import openapi from '@bpinternal/webchat-http-client/src/gen/openapi.json'
+
+export default defineConfig({
+  input: openapi,
+  output: 'src/gen/client',
+  plugins: [{ name: '@hey-api/client-fetch', bundle: true, runtimeConfigPath: './src/client/config.ts' }],
+})

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@botpress/webchat-client",
+  "version": "0.1.0",
+  "description": "",
+  "main": "src/index.ts",
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "build": "openapi-ts && vite build",
+    "check:lint": "eslint .",
+    "fix:lint": "eslint --fix .",
+    "check:type": "tsc --noEmit"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/webchat-client.js",
+  "exports": {
+    ".": {
+      "import": "./dist/webchat-client.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "eventsource": "^3.0.6"
+  },
+  "devDependencies": {
+    "@bpinternal/webchat-http-client": "0.2.6",
+    "@hey-api/client-fetch": "^0.10.0",
+    "@hey-api/openapi-ts": "^0.66.4",
+    "@repo/eslint-config": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/event-source-polyfill": "^1.0.2",
+    "esbuild": "^0.16.12",
+    "glob": "^11.0.1",
+    "rollup-plugin-tree-shakeable": "^1.0.3",
+    "vite": "^5.4.8",
+    "vite-plugin-dts": "^3.5.4"
+  }
+}

package/src/client/client.ts

@@ -0,0 +1,193 @@
+import type * as ClientTypes from '../gen/client'
+import * as sdk from '../gen/client/sdk.gen'
+import { client as baseClient } from '../gen/client/client.gen'
+import { EventSource } from 'eventsource'
+import type { Signal } from './types/signals'
+import { EventEmitter } from './eventEmitter'
+
+type ConversationIdParam = {
+  conversationId: string
+}
+
+type NextTokenParam = {
+  nextToken?: string
+}
+
+type UserIdParam = {
+  userId: string
+}
+
+type MessageIdParam = {
+  messageId: string
+}
+
+type EventIdParam = {
+  eventId: string
+}
+
+const extractData = <T>(res: { data: T }): T => res.data
+
+type Event =
+  | Signal
+  | {
+      type: 'error'
+      data: any
+    }
+  | {
+      type: 'open'
+      data: any
+    }
+
+export type Client = {
+  createConversation: () => Promise<ClientTypes.CreateConversationResponse>
+  getConversation: (params: ConversationIdParam) => Promise<ClientTypes.GetConversationResponse>
+  deleteConversation: (params: ConversationIdParam) => Promise<ClientTypes.DeleteConversationResponse>
+  listConversations: (params: NextTokenParam) => Promise<ClientTypes.ListConversationsResponse>
+  listConversationMessages: (
+    params: ConversationIdParam & NextTokenParam
+  ) => Promise<ClientTypes.ListConversationMessagesResponse>
+  addParticipant: (params: ConversationIdParam & UserIdParam) => Promise<ClientTypes.AddParticipantResponse>
+  removeParticipant: (params: ConversationIdParam & UserIdParam) => Promise<ClientTypes.RemoveParticipantResponse>
+  getParticipant: (params: ConversationIdParam & UserIdParam) => Promise<ClientTypes.GetParticipantResponse>
+  listParticipants: (params: ConversationIdParam & NextTokenParam) => Promise<ClientTypes.ListParticipantsResponse>
+  createMessage: (params: ClientTypes.CreateMessageBody) => Promise<ClientTypes.CreateMessageResponse>
+  updateMessage: (params: MessageIdParam & ClientTypes.UpdateMessageBody) => Promise<ClientTypes.UpdateMessageResponse>
+  getMessage: (params: MessageIdParam) => Promise<ClientTypes.GetMessageResponse>
+  deleteMessage: (params: MessageIdParam) => Promise<ClientTypes.DeleteMessageResponse>
+  createFile: (params: ClientTypes.CreateFileBody) => Promise<ClientTypes.CreateFileResponse>
+  createUser: (params: ClientTypes.CreateUserBody) => Promise<ClientTypes.CreateUserResponse>
+  getUser: (params: UserIdParam) => Promise<ClientTypes.GetUserResponse>
+  updateUser: (params: ClientTypes.CreateUserBody) => Promise<ClientTypes.UpdateUserResponse>
+  deleteUser: (params: UserIdParam) => Promise<ClientTypes.DeleteUserResponse>
+  createEvent: (params: ClientTypes.CreateEventBody) => Promise<ClientTypes.CreateEventResponse>
+  getEvent: (params: EventIdParam) => Promise<ClientTypes.GetEventResponse>
+  listenConversation: (params: ConversationIdParam) => EventEmitter<Record<Event['type'], Event['data']>>['on']
+}
+const baseConfigs = {
+  throwOnError: true,
+} as const satisfies sdk.Options
+
+export const createUser = ({ clientId, apiUrl }: { clientId: string; apiUrl?: string }) => {
+  const baseUrl = `${apiUrl || baseClient.getConfig().baseUrl}/${clientId}`
+
+  const configs = {
+    ...baseConfigs,
+    baseUrl,
+  }
+  return sdk.createUser({ ...configs, body: {} }).then(extractData)
+}
+
+export const createClient = ({
+  userKey,
+  clientId,
+  apiUrl,
+}: {
+  userKey: string
+  clientId: string
+  apiUrl?: string
+}): Client => {
+  const headers = {
+    'x-user-key': userKey,
+  }
+
+  const baseUrl = `${apiUrl || baseClient.getConfig().baseUrl}/${clientId}`
+  const configs = {
+    ...baseConfigs,
+    baseUrl,
+  }
+
+  return {
+    createConversation: () => sdk.createConversation({ ...configs, headers, body: {} }).then(extractData),
+    getConversation: ({ conversationId }) =>
+      sdk.getConversation({ ...configs, headers, path: { id: conversationId } }).then(extractData),
+    deleteConversation: ({ conversationId }) =>
+      sdk.deleteConversation({ ...configs, headers, path: { id: conversationId } }).then(extractData),
+    listConversations: ({ nextToken }) =>
+      sdk.listConversations({ ...configs, headers, query: { nextToken } }).then(extractData),
+    listConversationMessages: ({ conversationId, nextToken }) =>
+      sdk
+        .listConversationMessages({
+          ...configs,
+          headers,
+          path: { id: conversationId },
+          query: { nextToken },
+        })
+        .then(extractData),
+    addParticipant: ({ conversationId, userId }) =>
+      sdk.addParticipant({ ...configs, headers, path: { id: conversationId }, body: { userId } }).then(extractData),
+    removeParticipant: ({ conversationId, userId }) =>
+      sdk.removeParticipant({ ...configs, headers, path: { id: conversationId, userId } }).then(extractData),
+    getParticipant: ({ conversationId, userId }) =>
+      sdk.getParticipant({ ...configs, headers, path: { id: conversationId, userId } }).then(extractData),
+    listParticipants: ({ conversationId, nextToken }) =>
+      sdk
+        .listParticipants({ ...configs, headers, path: { id: conversationId }, query: { nextToken } })
+        .then(extractData),
+    createMessage: (body) => sdk.createMessage({ ...configs, headers, body }).then(extractData),
+    updateMessage: ({ messageId, ...body }) =>
+      sdk.updateMessage({ ...configs, headers, path: { id: messageId }, body }).then(extractData),
+    getMessage: ({ messageId }) => sdk.getMessage({ ...configs, headers, path: { id: messageId } }).then(extractData),
+    deleteMessage: ({ messageId }) =>
+      sdk.deleteMessage({ ...configs, headers, path: { id: messageId } }).then(extractData),
+    createFile: (body) => sdk.createFile({ ...configs, headers, body }).then(extractData),
+    createUser: (body) => sdk.createUser({ ...configs, headers, body }).then(extractData),
+    getUser: () => sdk.getUser({ ...configs, headers }).then(extractData),
+    updateUser: (body) => sdk.updateUser({ ...configs, headers, body }).then(extractData),
+    deleteUser: () => sdk.deleteUser({ ...configs, headers }).then(extractData),
+    createEvent: (body) => sdk.createEvent({ ...configs, headers, body }).then(extractData),
+    getEvent: ({ eventId }) => sdk.getEvent({ ...configs, headers, path: { id: eventId } }).then(extractData),
+    listenConversation: ({ conversationId }) => {
+      const MAX_RETRIES = 5
+      const RETRY_INTERVAL = 3000 // ms
+      let retryCount = 0
+      let eventSource: EventSource | null = null
+      const eventEmitter = new EventEmitter<Record<Event['type'], Event['data']>>()
+
+      const connect = () => {
+        if (eventSource) {
+          eventSource.close()
+        }
+
+        const url = `${baseUrl}/conversations/${conversationId}/listen`
+
+        eventSource = new EventSource(url, {
+          fetch: (input, init) =>
+            fetch(input, {
+              ...init,
+              headers: {
+                ...init?.headers,
+                ...headers,
+                timeout: '60_000',
+              },
+            }),
+        })
+
+        eventSource.onopen = () => eventEmitter.emit('open')
+        eventSource.onerror = (err) => {
+          eventEmitter.emit('error', err)
+
+          // Attempt reconnect with limit
+          if (retryCount < MAX_RETRIES) {
+            retryCount++
+            // todo: fix this
+            // setTimeout(() => connect(), RETRY_INTERVAL)
+          }
+        }
+        eventSource.onmessage = (ev) => {
+          const event = safeJsonParse(ev.data) as Signal
+          eventEmitter.emit(event.type, event.data)
+        }
+      }
+      connect()
+      return eventEmitter.on.bind(eventEmitter)
+    },
+  }
+}
+
+const safeJsonParse = (data: any) => {
+  try {
+    return JSON.parse(data)
+  } catch {
+    return data
+  }
+}

package/src/client/config.ts

@@ -0,0 +1,15 @@
+import type { CreateClientConfig } from '../gen/client/client.gen'
+
+const _100mb = 100 * 1024 * 1024
+const maxBodyLength = _100mb
+const maxContentLength = _100mb
+const defaultHttpTimeout = 60_000
+
+export const createClientConfig: CreateClientConfig = (config) => ({
+  ...config,
+  withCredentials: true,
+  timeout: defaultHttpTimeout,
+  maxBodyLength,
+  maxContentLength,
+  throwOnError: true,
+})

package/src/client/eventEmitter.ts

@@ -0,0 +1,36 @@
+type CallbackFn<T> = (args: T) => void
+
+export class EventEmitter<T extends Record<string, any>> {
+  private readonly eventMap: Partial<Record<keyof T, Set<CallbackFn<any>>>>
+
+  constructor() {
+    this.eventMap = {}
+  }
+
+  on<U extends keyof T>(event: U, callback: CallbackFn<T[U]>): () => void {
+    if (!this.eventMap[event]) {
+      this.eventMap[event] = new Set<CallbackFn<T[U]>>()
+    }
+    this.eventMap[event]?.add(callback)
+
+    return () => {
+      this.eventMap[event]?.delete(callback)
+    }
+  }
+
+  emit<U extends keyof T>(event: U, arg?: T[U]): void {
+    this.eventMap[event]?.forEach((callback) => {
+      callback(arg)
+    })
+
+    this.eventMap['*']?.forEach((callback) => {
+      callback({ type: event, payload: arg })
+    })
+  }
+}
+
+export type Events = {
+  [key: string]: undefined
+}
+
+export const eventEmitter = new EventEmitter<Events>()

package/src/client/index.ts

@@ -0,0 +1,2 @@
+export * from './client'
+export * from './config'

package/src/client/types/signals/custom.ts

@@ -0,0 +1,8 @@
+export type Custom = {
+  type: 'custom'
+  data: {
+    event: {
+      [k: string]: any
+    }
+  }
+}

package/src/client/types/signals/index.ts

@@ -0,0 +1,16 @@
+import type { Custom } from './custom'
+import type { MessageCreated } from './messageCreated'
+import type { MessageUpdated } from './messageUpdated'
+import type { TypingStarted } from './typingStarted'
+import type { TypingStopped } from './typingStopped'
+import type { WebchatConfig } from './webchatConfig'
+import type { WebchatVisibility } from './webchatVisibility'
+
+export type Signal =
+  | MessageCreated
+  | MessageUpdated
+  | WebchatVisibility
+  | WebchatConfig
+  | Custom
+  | TypingStarted
+  | TypingStopped