@botpress/sdk 0.0.5

package/dist/integration/client.d.ts

@@ -0,0 +1,39 @@
+import type { Conversation, Message, User } from '@botpress/client';
+import { Axios as AxiosInstance } from 'axios';
+import type { IntegrationContext } from './context';
+import type { ActionPayload, CreateConversationPayload, CreateUserPayload, MessagePayload, RegisterPayload, UnregisterPayload, WebhookPayload } from './implementation';
+type Props<T = any> = {
+    url: string;
+    data: T;
+} & Omit<IntegrationContext, 'operation'>;
+/**
+ * @description Meant to query your integration server directly (e.g. without going through the Botpress API)
+ */
+export declare class IntegrationClient {
+    private axios;
+    constructor(axiosInstance?: AxiosInstance);
+    actionTriggered: (props: Props<ActionPayload<string, any>>) => Promise<import("axios").AxiosResponse<any, any>>;
+    messageCreated: (props: Props<MessagePayload<any, Message, Conversation, User>>) => Promise<import("axios").AxiosResponse<any, any>>;
+    register: (props: Props<RegisterPayload>) => Promise<import("axios").AxiosResponse<any, any>>;
+    unregister: (props: Props<UnregisterPayload>) => Promise<import("axios").AxiosResponse<any, any>>;
+    webhookReceived: (props: Props<WebhookPayload>) => Promise<import("axios").AxiosResponse<any, any>>;
+    createUser: (props: Props<CreateUserPayload>) => Promise<import("axios").AxiosResponse<{
+        user: {
+            id: User['id'];
+        };
+    }, any>>;
+    createConversation: (props: Props<CreateConversationPayload>) => Promise<import("axios").AxiosResponse<{
+        conversation: {
+            id: Conversation['id'];
+        };
+    }, any>>;
+}
+export declare function formatIntegrationHeaders(ctx: IntegrationContext): {
+    "x-bot-id": string;
+    "x-bp-operation": "register" | "unregister" | "ping" | "message_created" | "webhook_received" | "action_triggered" | "create_user" | "create_conversation";
+    "x-bot-user-id": string;
+    "x-integration-id": string;
+    "x-webhook-id": string;
+    "x-bp-configuration": string;
+};
+export {};

package/dist/integration/context.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const integrationOperationSchema: z.ZodEnum<["webhook_received", "message_created", "action_triggered", "register", "unregister", "ping", "create_user", "create_conversation"]>;
+export type IntegrationOperation = z.infer<typeof integrationOperationSchema>;
+export type IntegrationContext<Configuration = any> = {
+    botId: string;
+    botUserId: string;
+    integrationId: string;
+    webhookId: string;
+    operation: IntegrationOperation;
+    configuration: Configuration;
+};

package/dist/integration/definition.d.ts

@@ -0,0 +1,465 @@
+import type { Merge } from 'type-fest';
+import { z } from 'zod';
+export declare const schemaSchema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+export declare const configurationDefinitionSchema: z.ZodObject<{
+    schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    schema: {};
+}, {
+    schema: {};
+}>;
+export declare const eventDefinitionSchema: z.ZodObject<{
+    schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    schema: {};
+}, {
+    schema: {};
+}>;
+export declare const actionDefinitionSchema: z.ZodObject<{
+    input: z.ZodObject<{
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        schema: {};
+    }, {
+        schema: {};
+    }>;
+    output: z.ZodObject<{
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        schema: {};
+    }, {
+        schema: {};
+    }>;
+}, "strip", z.ZodTypeAny, {
+    input: {
+        schema: {};
+    };
+    output: {
+        schema: {};
+    };
+}, {
+    input: {
+        schema: {};
+    };
+    output: {
+        schema: {};
+    };
+}>;
+export declare const messageDefinitionSchema: z.ZodObject<{
+    schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    schema: {};
+}, {
+    schema: {};
+}>;
+export declare const tagsDefinitionSchema: z.ZodObject<{
+    conversations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    messages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    conversations?: string[] | undefined;
+    users?: string[] | undefined;
+    messages?: string[] | undefined;
+}, {
+    conversations?: string[] | undefined;
+    users?: string[] | undefined;
+    messages?: string[] | undefined;
+}>;
+export declare const channelDefinitionSchema: z.ZodObject<{
+    tags: z.ZodOptional<z.ZodObject<Omit<{
+        conversations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        messages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "users">, "strip", z.ZodTypeAny, {
+        conversations?: string[] | undefined;
+        messages?: string[] | undefined;
+    }, {
+        conversations?: string[] | undefined;
+        messages?: string[] | undefined;
+    }>>;
+    messages: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        schema: {};
+    }, {
+        schema: {};
+    }>>, Record<string, {
+        schema: {};
+    }>, Record<string, {
+        schema: {};
+    }>>;
+    conversation: z.ZodOptional<z.ZodObject<{
+        creation: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            requiredTags: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            requiredTags: string[];
+        }, {
+            enabled: boolean;
+            requiredTags: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    }, {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    conversation?: {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    } | undefined;
+    tags?: {
+        conversations?: string[] | undefined;
+        messages?: string[] | undefined;
+    } | undefined;
+    messages: Record<string, {
+        schema: {};
+    }>;
+}, {
+    conversation?: {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    } | undefined;
+    tags?: {
+        conversations?: string[] | undefined;
+        messages?: string[] | undefined;
+    } | undefined;
+    messages: Record<string, {
+        schema: {};
+    }>;
+}>;
+export declare const stateDefinitionSchema: z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"integration">, z.ZodLiteral<"conversation">, z.ZodLiteral<"user">]>;
+    schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "conversation" | "integration";
+    schema: {};
+}, {
+    type: "user" | "conversation" | "integration";
+    schema: {};
+}>;
+export declare const integrationDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodObject<Pick<{
+        conversations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        messages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "users">, "strip", z.ZodTypeAny, {
+        users?: string[] | undefined;
+    }, {
+        users?: string[] | undefined;
+    }>>;
+    configuration: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        schema: {};
+    }, {
+        schema: {};
+    }>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        schema: {};
+    }, {
+        schema: {};
+    }>>>;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        input: z.ZodObject<{
+            schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            schema: {};
+        }, {
+            schema: {};
+        }>;
+        output: z.ZodObject<{
+            schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            schema: {};
+        }, {
+            schema: {};
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        input: {
+            schema: {};
+        };
+        output: {
+            schema: {};
+        };
+    }, {
+        input: {
+            schema: {};
+        };
+        output: {
+            schema: {};
+        };
+    }>>>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        tags: z.ZodOptional<z.ZodObject<Omit<{
+            conversations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            messages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "users">, "strip", z.ZodTypeAny, {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        }, {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        }>>;
+        messages: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            schema: {};
+        }, {
+            schema: {};
+        }>>, Record<string, {
+            schema: {};
+        }>, Record<string, {
+            schema: {};
+        }>>;
+        conversation: z.ZodOptional<z.ZodObject<{
+            creation: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                requiredTags: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                enabled: boolean;
+                requiredTags: string[];
+            }, {
+                enabled: boolean;
+                requiredTags: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        }, {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        conversation?: {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        } | undefined;
+        tags?: {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        } | undefined;
+        messages: Record<string, {
+            schema: {};
+        }>;
+    }, {
+        conversation?: {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        } | undefined;
+        tags?: {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        } | undefined;
+        messages: Record<string, {
+            schema: {};
+        }>;
+    }>>>;
+    states: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodUnion<[z.ZodLiteral<"integration">, z.ZodLiteral<"conversation">, z.ZodLiteral<"user">]>;
+        schema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, {}, {}>;
+    }, "strip", z.ZodTypeAny, {
+        type: "user" | "conversation" | "integration";
+        schema: {};
+    }, {
+        type: "user" | "conversation" | "integration";
+        schema: {};
+    }>>>;
+    user: z.ZodOptional<z.ZodObject<{
+        creation: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            requiredTags: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            requiredTags: string[];
+        }, {
+            enabled: boolean;
+            requiredTags: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    }, {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    }>>;
+    public: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    user?: {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    } | undefined;
+    configuration?: {
+        schema: {};
+    } | undefined;
+    tags?: {
+        users?: string[] | undefined;
+    } | undefined;
+    actions?: Record<string, {
+        input: {
+            schema: {};
+        };
+        output: {
+            schema: {};
+        };
+    }> | undefined;
+    channels?: Record<string, {
+        conversation?: {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        } | undefined;
+        tags?: {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        } | undefined;
+        messages: Record<string, {
+            schema: {};
+        }>;
+    }> | undefined;
+    icon?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    events?: Record<string, {
+        schema: {};
+    }> | undefined;
+    states?: Record<string, {
+        type: "user" | "conversation" | "integration";
+        schema: {};
+    }> | undefined;
+    public?: boolean | undefined;
+    name: string;
+    version: string;
+}, {
+    user?: {
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    } | undefined;
+    configuration?: {
+        schema: {};
+    } | undefined;
+    tags?: {
+        users?: string[] | undefined;
+    } | undefined;
+    actions?: Record<string, {
+        input: {
+            schema: {};
+        };
+        output: {
+            schema: {};
+        };
+    }> | undefined;
+    channels?: Record<string, {
+        conversation?: {
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        } | undefined;
+        tags?: {
+            conversations?: string[] | undefined;
+            messages?: string[] | undefined;
+        } | undefined;
+        messages: Record<string, {
+            schema: {};
+        }>;
+    }> | undefined;
+    icon?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    events?: Record<string, {
+        schema: {};
+    }> | undefined;
+    states?: Record<string, {
+        type: "user" | "conversation" | "integration";
+        schema: {};
+    }> | undefined;
+    public?: boolean | undefined;
+    name: string;
+    version: string;
+}>;
+export type ConfigurationDefinition = z.infer<typeof configurationDefinitionSchema>;
+export type EventDefinition = z.infer<typeof eventDefinitionSchema>;
+export type TagDefinition = z.infer<typeof tagsDefinitionSchema>;
+export type ChannelDefinition = z.infer<typeof channelDefinitionSchema>;
+export type ActionDefinition = z.infer<typeof actionDefinitionSchema>;
+export type MessageDefinition = z.infer<typeof messageDefinitionSchema>;
+export type StateDefinition = z.infer<typeof stateDefinitionSchema>;
+type IntegrationDefinitionOutput = z.infer<typeof integrationDefinitionSchema>;
+export type IntegrationDefinitionProps<T = z.ZodSchema<any>> = Omit<IntegrationDefinitionOutput, 'configuration' | 'events' | 'actions' | 'channels' | 'states'> & {
+    configuration?: Merge<ConfigurationDefinition, {
+        schema: T;
+    }>;
+    events?: Record<string, Merge<EventDefinition, {
+        schema: T;
+    }>>;
+    actions?: Record<string, Merge<ActionDefinition, {
+        input: {
+            schema: T;
+        };
+        output: {
+            schema: T;
+        };
+    }>>;
+    channels?: Record<string, Merge<ChannelDefinition, {
+        messages: Record<string, Merge<MessageDefinition, {
+            schema: T;
+        }>>;
+    }>>;
+    states?: Record<string, Merge<StateDefinition, {
+        schema: T;
+    }>>;
+};
+export declare class IntegrationDefinition {
+    readonly name: IntegrationDefinitionOutput['name'];
+    readonly version: IntegrationDefinitionOutput['version'];
+    readonly icon: IntegrationDefinitionOutput['icon'];
+    readonly title: IntegrationDefinitionOutput['title'];
+    readonly description: IntegrationDefinitionOutput['description'];
+    readonly tags: IntegrationDefinitionOutput['tags'];
+    readonly configuration: IntegrationDefinitionOutput['configuration'];
+    readonly events: IntegrationDefinitionOutput['events'];
+    readonly actions: IntegrationDefinitionOutput['actions'];
+    readonly channels: IntegrationDefinitionOutput['channels'];
+    readonly states: IntegrationDefinitionOutput['states'];
+    readonly user: IntegrationDefinitionOutput['user'];
+    readonly public: IntegrationDefinitionOutput['public'];
+    constructor(props: IntegrationDefinitionProps);
+}
+export {};

package/dist/integration/implementation.d.ts

@@ -0,0 +1,91 @@
+import type { Client, Conversation, Message, User } from '@botpress/client';
+import { Request, Response } from '../serve';
+import type { IntegrationContext } from './context';
+import { integrationHandler } from './server';
+type IntegrationProps<Configuration> = {
+    ctx: IntegrationContext<Configuration>;
+    client: Client;
+};
+export type RegisterPayload = {
+    webhookUrl: string;
+};
+export type UnregisterPayload = {
+    webhookUrl: string;
+};
+export type WebhookPayload = {
+    req: Request;
+};
+export type ActionPayload<T, I> = {
+    type: T;
+    input: I;
+};
+export type EventPayload<E> = {
+    event: E;
+};
+export type CreateUserPayload = {
+    tags: Tags;
+};
+export type CreateConversationPayload = {
+    channel: string;
+    tags: Tags;
+};
+type Tags = {
+    [key: string]: string;
+};
+export type AckFunction = (props: {
+    tags: Tags;
+}) => Promise<void>;
+export type MessagePayload<P, M, C, U> = {
+    payload: P;
+    conversation: C;
+    message: M;
+    user: U;
+    type: string;
+};
+type ActionDefinitions = {
+    [actionType: string]: {
+        input: any;
+        output: any;
+    };
+};
+type ChannelDefinitions = {
+    [channelName: string]: MessageDefinitions;
+};
+type EventDefinitions = {
+    [eventName: string]: any;
+};
+type MessageDefinitions = {
+    [messageType: string]: any;
+};
+type ActionFunctions<Configuration, A extends ActionDefinitions> = {
+    [actionType in keyof A]: (props: IntegrationProps<Configuration> & ActionPayload<actionType, A[actionType]['input']>) => Promise<A[actionType]['output']>;
+};
+type MessageHandlerProps = {
+    ack: AckFunction;
+};
+export type ChannelFunctions<Configuration, C extends ChannelDefinitions> = {
+    [channelName in keyof C]: {
+        messages: {
+            [messageType in keyof C[channelName]]: (props: IntegrationProps<Configuration> & MessagePayload<C[channelName][messageType], Message, Conversation, User> & MessageHandlerProps) => Promise<void>;
+        };
+    };
+};
+export type IntegrationImplementationProps<Configuration = any, Actions extends ActionDefinitions = any, Channels extends ChannelDefinitions = any, _Events extends EventDefinitions = any> = {
+    register: (props: IntegrationProps<Configuration> & RegisterPayload) => Promise<void>;
+    unregister: (props: IntegrationProps<Configuration> & UnregisterPayload) => Promise<void>;
+    handler: (props: IntegrationProps<Configuration> & WebhookPayload) => Promise<Response | void>;
+    createUser?: (props: IntegrationProps<Configuration> & CreateUserPayload) => Promise<Response | void>;
+    createConversation?: (props: IntegrationProps<Configuration> & CreateConversationPayload) => Promise<Response | void>;
+    actions: ActionFunctions<Configuration, Actions>;
+    channels: ChannelFunctions<Configuration, Channels>;
+};
+export declare class IntegrationImplementation<Configuration = any, Actions extends ActionDefinitions = any, Channels extends ChannelDefinitions = any, Events extends EventDefinitions = any> {
+    readonly actions: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['actions'];
+    readonly channels: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['channels'];
+    readonly register: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['register'];
+    readonly unregister: IntegrationImplementationProps<Configuration, Actions, Channels, Events>['unregister'];
+    readonly handler: ReturnType<typeof integrationHandler>;
+    readonly start: (port?: number) => Promise<void>;
+    constructor(props: IntegrationImplementationProps<Configuration, Actions, Channels, Events>);
+}
+export {};

package/dist/integration/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './context';
+export * from './definition';
+export * from './implementation';
+export * from './server';

package/dist/integration/server.d.ts

@@ -0,0 +1,12 @@
+import { Conversation, Message, User } from '@botpress/client';
+import { Request, Response } from '../serve';
+import type { IntegrationImplementationProps as Integration } from './implementation';
+export declare const serveIntegration: (integration: Integration, port?: number) => Promise<void>;
+export declare const integrationHandler: (integration: Integration) => (req: Request) => Promise<Response | void>;
+export type MessageCreatedPayload = {
+    conversation: Conversation;
+    user: User;
+    message: Message;
+    payload: any;
+    type: string;
+};

package/dist/log.d.ts

@@ -0,0 +1,7 @@
+export type Logger = {
+    debug(message: string, metadata?: any): void;
+    info(message: string, metadata?: any): void;
+    warn(message: string, metadata?: any): void;
+    error(message: string, metadata?: any): void;
+};
+export declare const log: Logger;