@botpress/sdk 2.5.0 → 3.0.1

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,23 +1,27 @@
 {
   "name": "@botpress/sdk",
-  "version": "2.5.0",
+  "version": "3.0.1",
   "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"
+    "@botpress/client": "0.41.1",
+    "browser-or-node": "^2.1.1"
   },
   "devDependencies": {
     "esbuild": "^0.16.12",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
     "tsup": "^8.0.2"
   },
   "peerDependencies": {

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;