@botpress/sdk 2.4.3 → 3.0.0

package/dist/plugin/server/types.d.ts

@@ -1 +1,241 @@
-export * from '../../bot/server/types';
+import * as client from '@botpress/client';
+import * as bot from '../../bot';
+import * as utils from '../../utils/type-utils';
+import * as proxy from '../action-proxy';
+import * as types from '../types';
+type EnumeratePluginEvents<TPlugin extends types.BasePlugin> = bot.EnumerateEvents<TPlugin> & types.EnumerateInterfaceEvents<TPlugin>;
+type _IncomingEvents<TPlugin extends types.BasePlugin> = {
+    [K in keyof EnumeratePluginEvents<TPlugin>]: utils.Merge<client.Event, {
+        type: K;
+        payload: EnumeratePluginEvents<TPlugin>[K];
+    }>;
+};
+type _IncomingMessages<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.Message, {
+        type: K;
+        payload: bot.GetMessages<TPlugin>[K];
+    }>;
+};
+type _IncomingStates<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateStates<TPlugin>]: utils.Merge<client.State, {
+        name: K;
+        payload: bot.EnumerateStates<TPlugin>[K];
+    }>;
+};
+type _OutgoingMessageRequests<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.ClientInputs['createMessage'], {
+        type: K;
+        payload: bot.GetMessages<TPlugin>[K];
+    }>;
+};
+type _OutgoingMessageResponses<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.ClientOutputs['createMessage'], {
+        message: utils.Merge<client.Message, {
+            type: K;
+            payload: bot.GetMessages<TPlugin>[K];
+        }>;
+    }>;
+};
+type _OutgoingCallActionRequests<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateActionInputs<TPlugin>]: utils.Merge<client.ClientInputs['callAction'], {
+        type: K;
+        input: bot.EnumerateActionInputs<TPlugin>[K];
+    }>;
+};
+type _OutgoingCallActionResponses<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateActionOutputs<TPlugin>]: utils.Merge<client.ClientOutputs['callAction'], {
+        output: bot.EnumerateActionOutputs<TPlugin>[K];
+    }>;
+};
+export type AnyIncomingEvent<_TPlugin extends types.BasePlugin> = client.Event;
+export type AnyIncomingMessage<_TPlugin extends types.BasePlugin> = client.Message;
+export type AnyOutgoingMessageRequest<_TPlugin extends types.BasePlugin> = client.ClientInputs['createMessage'];
+export type AnyOutgoingMessageResponse<_TPlugin extends types.BasePlugin> = client.ClientOutputs['createMessage'];
+export type AnyOutgoingCallActionRequest<_TPlugin extends types.BasePlugin> = client.ClientInputs['callAction'];
+export type AnyOutgoingCallActionResponse<_TPlugin extends types.BasePlugin> = client.ClientOutputs['callAction'];
+export type IncomingEvents<TPlugin extends types.BasePlugin> = _IncomingEvents<TPlugin> & {
+    '*': AnyIncomingEvent<TPlugin>;
+};
+export type IncomingMessages<TPlugin extends types.BasePlugin> = _IncomingMessages<TPlugin> & {
+    '*': AnyIncomingMessage<TPlugin>;
+};
+export type IncomingStates<_TPlugin extends types.BasePlugin> = _IncomingStates<_TPlugin> & {
+    '*': client.State;
+};
+export type OutgoingMessageRequests<TPlugin extends types.BasePlugin> = _OutgoingMessageRequests<TPlugin> & {
+    '*': AnyOutgoingMessageRequest<TPlugin>;
+};
+export type OutgoingMessageResponses<TPlugin extends types.BasePlugin> = _OutgoingMessageResponses<TPlugin> & {
+    '*': AnyOutgoingMessageResponse<TPlugin>;
+};
+export type OutgoingCallActionRequests<TPlugin extends types.BasePlugin> = _OutgoingCallActionRequests<TPlugin> & {
+    '*': AnyOutgoingCallActionRequest<TPlugin>;
+};
+export type OutgoingCallActionResponses<TPlugin extends types.BasePlugin> = _OutgoingCallActionResponses<TPlugin> & {
+    '*': AnyOutgoingCallActionResponse<TPlugin>;
+};
+export type PluginClient<_TPlugin extends types.BasePlugin> = bot.BotSpecificClient<types.BasePlugin>;
+export type PluginConfiguration<TPlugin extends types.BasePlugin> = TPlugin['configuration'];
+export type CommonHandlerProps<TPlugin extends types.BasePlugin> = {
+    ctx: bot.BotContext;
+    logger: bot.BotLogger;
+    client: PluginClient<TPlugin>;
+    configuration: PluginConfiguration<TPlugin>;
+    interfaces: types.PluginInterfaceExtensions<TPlugin>;
+    actions: proxy.ActionProxy<TPlugin>;
+};
+export type MessagePayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingMessages<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        message: IncomingMessages<TPlugin>[K];
+        user: client.User;
+        conversation: client.Conversation;
+        event: client.Event;
+        states: {
+            [TState in keyof TPlugin['states']]: {
+                type: 'user' | 'conversation' | 'bot';
+                payload: TPlugin['states'][TState];
+            };
+        };
+    };
+};
+export type MessageHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingMessages<TPlugin>]: (args: MessagePayloads<TPlugin>[K]) => Promise<void>;
+};
+export type EventPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingEvents<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        event: IncomingEvents<TPlugin>[K];
+    };
+};
+export type EventHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingEvents<TPlugin>]: (args: EventPayloads<TPlugin>[K]) => Promise<void>;
+};
+export type StateExpiredPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingStates<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        state: IncomingStates<TPlugin>[K];
+    };
+};
+export type StateExpiredHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingStates<TPlugin>]: (args: StateExpiredPayloads<TPlugin>[K]) => Promise<void>;
+};
+export type ActionHandlerPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof TPlugin['actions']]: CommonHandlerProps<TPlugin> & {
+        type?: K;
+        input: TPlugin['actions'][K]['input'];
+    };
+};
+export type ActionHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof TPlugin['actions']]: (props: ActionHandlerPayloads<TPlugin>[K]) => Promise<TPlugin['actions'][K]['output']>;
+};
+type BaseHookDefinition = {
+    stoppable?: boolean;
+    data: any;
+};
+type HookDefinition<THookDef extends BaseHookDefinition = BaseHookDefinition> = THookDef;
+/**
+ * TODO: add hooks for:
+ *   - before_register
+ *   - after_register
+ *   - before_state_expired
+ *   - after_state_expired
+ *   - before_incoming_call_action
+ *   - after_incoming_call_action
+ */
+export type HookDefinitionType = keyof HookDefinitions<types.BasePlugin>;
+export type HookDefinitions<TPlugin extends types.BasePlugin> = {
+    before_incoming_event: HookDefinition<{
+        stoppable: true;
+        data: _IncomingEvents<TPlugin> & {
+            '*': AnyIncomingEvent<TPlugin>;
+        };
+    }>;
+    before_incoming_message: HookDefinition<{
+        stoppable: true;
+        data: _IncomingMessages<TPlugin> & {
+            '*': AnyIncomingMessage<TPlugin>;
+        };
+    }>;
+    before_outgoing_message: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingMessageRequests<TPlugin> & {
+            '*': AnyOutgoingMessageRequest<TPlugin>;
+        };
+    }>;
+    before_outgoing_call_action: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingCallActionRequests<TPlugin> & {
+            '*': AnyOutgoingCallActionRequest<TPlugin>;
+        };
+    }>;
+    after_incoming_event: HookDefinition<{
+        stoppable: true;
+        data: _IncomingEvents<TPlugin> & {
+            '*': AnyIncomingEvent<TPlugin>;
+        };
+    }>;
+    after_incoming_message: HookDefinition<{
+        stoppable: true;
+        data: _IncomingMessages<TPlugin> & {
+            '*': AnyIncomingMessage<TPlugin>;
+        };
+    }>;
+    after_outgoing_message: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingMessageResponses<TPlugin> & {
+            '*': AnyOutgoingMessageResponse<TPlugin>;
+        };
+    }>;
+    after_outgoing_call_action: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingCallActionResponses<TPlugin> & {
+            '*': AnyOutgoingCallActionResponse<TPlugin>;
+        };
+    }>;
+};
+export type HookData<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookDefinitions<TPlugin>]: {
+        [T in keyof HookDefinitions<TPlugin>[H]['data']]: HookDefinitions<TPlugin>[H]['data'][T];
+    };
+};
+export type HookInputs<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: CommonHandlerProps<TPlugin> & {
+            data: HookData<TPlugin>[H][T];
+        };
+    };
+};
+export type HookOutputs<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: {
+            data?: HookData<TPlugin>[H][T];
+        } & (HookDefinitions<TPlugin>[H]['stoppable'] extends true ? {
+            stop?: boolean;
+        } : {});
+    };
+};
+export type HookHandlers<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: (input: HookInputs<TPlugin>[H][T]) => Promise<HookOutputs<TPlugin>[H][T] | undefined>;
+    };
+};
+export type MessageHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingMessages<TPlugin>]?: MessageHandlers<TPlugin>[T][];
+};
+export type EventHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingEvents<TPlugin>]?: EventHandlers<TPlugin>[T][];
+};
+export type StateExpiredHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingStates<TPlugin>]?: StateExpiredHandlers<TPlugin>[T][];
+};
+export type HookHandlersMap<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]?: HookHandlers<TPlugin>[H][T][];
+    };
+};
+export type PluginHandlers<TPlugin extends types.BasePlugin> = {
+    actionHandlers: ActionHandlers<TPlugin>;
+    messageHandlers: MessageHandlersMap<TPlugin>;
+    eventHandlers: EventHandlersMap<TPlugin>;
+    stateExpiredHandlers: StateExpiredHandlersMap<TPlugin>;
+    hookHandlers: HookHandlersMap<TPlugin>;
+};
+export {};

package/dist/plugin/types/common.d.ts

@@ -0,0 +1,41 @@
+import { BaseInterface } from '../../interface';
+import { Cast, Join, UnionToIntersection } from '../../utils/type-utils';
+import { BasePlugin } from './generic';
+type EventKey<TIntegrationName extends string, TEventName extends string> = string extends TIntegrationName ? string : string extends TEventName ? string : Join<[TIntegrationName, ':', TEventName]>;
+export type EnumerateInterfaceEvents<TPlugin extends BasePlugin> = UnionToIntersection<{
+    [TInterfaceName in keyof TPlugin['interfaces']]: {
+        [TEventName in keyof TPlugin['interfaces'][TInterfaceName]['events'] as EventKey<Cast<TInterfaceName, string>, Cast<TEventName, string>>]: TPlugin['interfaces'][TInterfaceName]['events'][TEventName];
+    };
+}[keyof TPlugin['interfaces']]>;
+/**
+ * Used by a bot to tell the plugin what integration should be used to implement an interface.
+ */
+export type PluginInterfaceExtension<TInterface extends BaseInterface = BaseInterface> = {
+    id?: string;
+    name: string;
+    version: string;
+    entities: {
+        [K in keyof TInterface['entities']]: {
+            name: string;
+        };
+    };
+    actions: {
+        [K in keyof TInterface['actions']]: {
+            name: string;
+        };
+    };
+    events: {
+        [K in keyof TInterface['events']]: {
+            name: string;
+        };
+    };
+    channels: {
+        [K in keyof TInterface['channels']]: {
+            name: string;
+        };
+    };
+};
+export type PluginInterfaceExtensions<TPlugin extends BasePlugin = BasePlugin> = {
+    [K in keyof TPlugin['interfaces']]: PluginInterfaceExtension<TPlugin['interfaces'][K]>;
+};
+export {};

package/dist/plugin/types/generic.d.ts

@@ -5,6 +5,114 @@ export type BaseAction = {
     input: any;
     output: any;
 };
+export type BaseTable = {
+    /**
+     * Required. This name is used to identify your table.
+     */
+    name: string;
+    /**
+     * The 'factor' multiplies the row's data storage limit by 4KB and its quota count, but can only be set at table creation and not modified later. For instance, a factor of 2 increases storage to 8KB but counts as 2 rows in your quota. The default factor is 1.
+     */
+    factor?: number;
+    /**
+     * A table designated as "frozen" is immutable in terms of its name and schema structure; modifications to its schema or a renaming operation are not permitted. The only action that can be taken on such a table is deletion. The schema established at the time of creation is locked in as the final structure. To implement any changes, the table must be duplicated with the desired alterations.
+     */
+    frozen?: boolean;
+    schema: {
+        $schema?: string;
+        /**
+         * List of keys/columns in the table.
+         */
+        properties: {
+            [k: string]: {
+                type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+                format?: 'date-time';
+                description?: string;
+                /**
+                 * String properties must match this pattern
+                 */
+                pattern?: string;
+                /**
+                 * String properties must be one of these values
+                 */
+                enum?: string[];
+                /**
+                 * Defines the shape of items in an array
+                 */
+                items?: {
+                    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+                    [k: string]: any;
+                };
+                nullable?: boolean;
+                properties?: {
+                    [k: string]: {
+                        type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+                        [k: string]: any;
+                    };
+                };
+                'x-zui': {
+                    index: number;
+                    /**
+                     * Indicates if the column is vectorized and searchable.
+                     */
+                    searchable?: boolean;
+                    /**
+                     * Indicates if the field is hidden in the UI
+                     */
+                    hidden?: boolean;
+                    /**
+                     * Order of the column in the UI
+                     */
+                    order?: number;
+                    /**
+                     * Width of the column in the UI
+                     */
+                    width?: number;
+                    computed?: {
+                        action: 'ai' | 'code' | 'workflow';
+                        dependencies?: string[];
+                        /**
+                         * Prompt when action is "ai"
+                         */
+                        prompt?: string;
+                        /**
+                         * Code to execute when action is "code"
+                         */
+                        code?: string;
+                        /**
+                         * Model to use when action is "ai"
+                         */
+                        model?: string;
+                        /**
+                         * ID of Workflow to execute when action is "workflow"
+                         */
+                        workflowId?: string;
+                        enabled?: boolean;
+                    };
+                };
+            };
+        };
+        /**
+         * Additional properties can be provided, but they will be ignored if no column matches.
+         */
+        additionalProperties: true;
+        /**
+         * Array of required properties.
+         */
+        required?: string[];
+        type: 'object';
+    };
+    /**
+     * Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.
+     */
+    tags?: {
+        [k: string]: string;
+    };
+    /**
+     * Indicates if the table is enabled for computation.
+     */
+    isComputeEnabled?: boolean;
+};
 export type BasePlugin = {
     configuration: any;
     integrations: Record<string, BaseIntegration>;
@@ -12,7 +120,7 @@ export type BasePlugin = {
     events: Record<string, any>;
     states: Record<string, any>;
     actions: Record<string, BaseAction>;
-    unknownDefinitions: true;
+    tables: Record<string, BaseTable>;
 };
 export type InputBasePlugin = utils.DeepPartial<BasePlugin>;
 export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
@@ -20,7 +128,7 @@ export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
     events: utils.Default<B['events'], BasePlugin['events']>;
     states: utils.Default<B['states'], BasePlugin['states']>;
     actions: utils.Default<B['actions'], BasePlugin['actions']>;
-    unknownDefinitions: utils.Default<B['unknownDefinitions'], BasePlugin['unknownDefinitions']>;
+    tables: utils.Default<B['tables'], BasePlugin['tables']>;
     integrations: undefined extends B['integrations'] ? BasePlugin['integrations'] : {
         [K in keyof B['integrations']]: DefaultIntegration<utils.Cast<B['integrations'][K], InputBaseIntegration>>;
     };

package/dist/plugin/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './generic';

package/dist/serve.d.ts

@@ -1,4 +1,4 @@
-import { Server } from 'node:http';
+import * as http from 'node:http';
 export type Request = {
     body?: string;
     path: string;
@@ -17,4 +17,4 @@ export type Response = {
 };
 export type Handler = (req: Request) => Promise<Response | void>;
 export declare function parseBody<T>(req: Request): T;
-export declare function serve(handler: Handler, port?: number, callback?: (port: number) => void): Promise<Server>;
+export declare function serve(handler: Handler, port?: number, callback?: (port: number) => void): Promise<http.Server>;

package/dist/utils/record-utils.d.ts

@@ -1,3 +1,5 @@
 export declare const pairs: <K extends string, V>(obj: Record<K, V>) => [K, V][];
 export declare const values: <K extends string, V>(obj: Record<K, V>) => V[];
 export declare const mapValues: <K extends string, V, R>(obj: Record<K, V>, fn: (value: V, key: K) => R) => Record<K, R>;
+export declare const stripUndefinedProps: <K extends string, V>(obj: Record<K, V | undefined>) => Record<K, V>;
+export declare const mergeRecords: <K extends string, V>(a: Record<K, V>, b: Record<K, V>, merge: (v1: V, v2: V) => V) => Record<K, V>;

package/dist/utils/record-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/type-utils.d.ts

@@ -6,11 +6,25 @@ export type Writable<T> = {
     -readonly [K in keyof T]: T[K];
 };
 export type Default<T, U> = undefined extends T ? U : T;
+export type AtLeastOne<T> = [T, ...T[]];
+export type AtLeastOneProperty<T> = {
+    [K in keyof T]?: T[K];
+} & {
+    [K in keyof T]: Pick<T, K>;
+}[keyof T];
+export type ExactlyOneProperty<T> = {
+    [K in keyof T]: {
+        [P in K]: T[P];
+    } & {
+        [P in Exclude<keyof T, K>]?: never;
+    };
+}[keyof T];
 export type IsExtend<X, Y> = X extends Y ? true : false;
 export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
 export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
 export type AssertExtends<_A extends B, B> = true;
+export type AssertNotExtends<A, B> = A extends B ? false : true;
 export type AssertTrue<_T extends true> = true;
 export type AssertAll<_T extends true[]> = true;
 export type Join<S extends (string | number | symbol)[]> = S extends [infer H, ...infer T] ? `${Cast<H, string>}${Join<Cast<T, string[]>>}` : S extends [infer H] ? Cast<H, string> : '';
@@ -30,4 +44,5 @@ type DeepPartialObject<T extends object> = T extends infer O ? {
     [K in keyof O]?: DeepPartial<O[K]>;
 } : never;
 export type DeepPartial<T> = T extends (...args: infer A) => infer R ? (...args: DeepPartial<A>) => DeepPartial<R> : T extends Array<infer E> ? Array<DeepPartial<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<DeepPartial<E>> : T extends Promise<infer R> ? Promise<DeepPartial<R>> : T extends Buffer ? Buffer : T extends object ? DeepPartialObject<T> : T;
+export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
 export {};

package/dist/zui.d.ts

@@ -2,4 +2,5 @@ import { z } from '@bpinternal/zui';
 export * from '@bpinternal/zui';
 export type GenericZuiSchema<A extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny = z.ZodTypeAny> = (typeArguments: A) => R;
 export type ZuiObjectSchema = z.ZodObject | z.ZodRecord;
+export declare const mergeObjectSchemas: (a: ZuiObjectSchema, b: ZuiObjectSchema) => ZuiObjectSchema;
 export default z;

package/package.json

@@ -1,26 +1,36 @@
 {
   "name": "@botpress/sdk",
-  "version": "2.4.3",
+  "version": "3.0.0",
   "description": "Botpress SDK",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "scripts": {
     "check:type": "tsc --noEmit",
     "build:type": "tsc --emitDeclarationOnly --declaration",
-    "build:node": "ts-node -T build.ts",
-    "build": "pnpm build:type && pnpm build:node"
+    "build:browser": "ts-node -T ./build.ts --browser",
+    "build:node": "ts-node -T ./build.ts --node",
+    "build": "pnpm build:type && pnpm build:node && pnpm build:browser"
   },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.41.0"
-  },
-  "peerDependencies": {
-    "@bpinternal/zui": "^0.13.5"
+    "@botpress/client": "0.41.0",
+    "browser-or-node": "^2.1.1"
   },
   "devDependencies": {
     "esbuild": "^0.16.12",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
     "tsup": "^8.0.2"
+  },
+  "peerDependencies": {
+    "@bpinternal/zui": "^0.13.5",
+    "esbuild": "^0.16.12"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
   }
 }

package/dist/bot/merge-bots.d.ts

@@ -1,2 +0,0 @@
-import { BotHandlers } from './server';
-export declare const mergeBots: (dest: BotHandlers<any>, src: BotHandlers<any>) => void;