@botpress/sdk 4.9.0 → 4.11.0

package/dist/integration/implementation.d.ts

@@ -1,6 +1,6 @@
 import type { Server } from 'node:http';
 import { BaseIntegration } from './common';
-import { RegisterHandler as RegisterFunction, UnregisterHandler as UnregisterFunction, WebhookHandler as WebhookFunction, CreateUserHandler as CreateUserFunction, CreateConversationHandler as CreateConversationFunction, ActionHandlers as ActionFunctions, ChannelHandlers as ChannelFunctions } from './server';
+import { RegisterHandler as RegisterFunction, UnregisterHandler as UnregisterFunction, WebhookHandler as WebhookFunction, CreateUserHandler as CreateUserFunction, CreateConversationHandler as CreateConversationFunction, ActionHandlers as ActionFunctions, ChannelHandlers as ChannelFunctions, IntegrationOperationHandler as IntegrationOperationFunction } from './server';
 export type IntegrationImplementationProps<TIntegration extends BaseIntegration = BaseIntegration> = {
     register: RegisterFunction<TIntegration>;
     unregister: UnregisterFunction<TIntegration>;
@@ -15,6 +15,9 @@ export type IntegrationImplementationProps<TIntegration extends BaseIntegration
     createConversation?: CreateConversationFunction<TIntegration>;
     actions: ActionFunctions<TIntegration>;
     channels: ChannelFunctions<TIntegration>;
+    __advanced?: {
+        integrationOperationHandler?: IntegrationOperationFunction<TIntegration>;
+    };
 };
 export declare class IntegrationImplementation<TIntegration extends BaseIntegration = BaseIntegration> {
     readonly props: IntegrationImplementationProps<TIntegration>;
@@ -25,6 +28,7 @@ export declare class IntegrationImplementation<TIntegration extends BaseIntegrat
     readonly createUser: IntegrationImplementationProps<TIntegration>['createUser'];
     readonly createConversation: IntegrationImplementationProps<TIntegration>['createConversation'];
     readonly webhook: IntegrationImplementationProps<TIntegration>['handler'];
+    readonly integrationOperationHandler: NonNullable<IntegrationImplementationProps<TIntegration>['__advanced']>['integrationOperationHandler'];
     constructor(props: IntegrationImplementationProps<TIntegration>);
     readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
     readonly start: (port?: number) => Promise<Server>;

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

@@ -90,6 +90,9 @@ export type ChannelHandlers<TIntegration extends BaseIntegration> = {
         };
     };
 };
+export type IntegrationOperationHandler<TIntegration extends BaseIntegration> = (props: CommonHandlerProps<TIntegration> & {
+    req: Request;
+}) => Promise<Response | void>;
 export type IntegrationHandlers<TIntegration extends BaseIntegration> = {
     register: RegisterHandler<TIntegration>;
     unregister: UnregisterHandler<TIntegration>;
@@ -98,5 +101,6 @@ export type IntegrationHandlers<TIntegration extends BaseIntegration> = {
     createConversation?: CreateConversationHandler<TIntegration>;
     actions: ActionHandlers<TIntegration>;
     channels: ChannelHandlers<TIntegration>;
+    integrationOperationHandler?: IntegrationOperationHandler<TIntegration>;
 };
 export {};

package/dist/plugin/definition.d.ts

@@ -1,15 +1,61 @@
-import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, WorkflowDefinition } from '../bot/definition';
+import { StateDefinition as BotStateDefinition, EventDefinition as BotEventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition as BotActionDefinition, TableDefinition as BotTableDefinition, WorkflowDefinition } from '../bot/definition';
 import { IntegrationPackage, InterfacePackage } from '../package';
-import { ZuiObjectSchema } from '../zui';
-export { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, IntegrationConfigInstance, WorkflowDefinition, } from '../bot/definition';
+import * as typeUtils from '../utils/type-utils';
+import { ZuiObjectSchema, ZuiObjectOrRefSchema, z } from '../zui';
+export { ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, IntegrationConfigInstance, WorkflowDefinition, } from '../bot/definition';
 type BaseConfig = ZuiObjectSchema;
-type BaseStates = Record<string, ZuiObjectSchema>;
-type BaseEvents = Record<string, ZuiObjectSchema>;
-type BaseActions = Record<string, ZuiObjectSchema>;
-type BaseInterfaces = Record<string, any>;
-type BaseIntegrations = Record<string, any>;
-type BaseTables = Record<string, ZuiObjectSchema>;
+type BaseStates = Record<string, ZuiObjectOrRefSchema>;
+type BaseEvents = Record<string, ZuiObjectOrRefSchema>;
+type BaseActions = Record<string, ZuiObjectOrRefSchema>;
+type BaseInterfaces = Record<string, InterfacePackage>;
+type BaseIntegrations = Record<string, IntegrationPackage>;
+type BaseTables = Record<string, ZuiObjectOrRefSchema>;
 type BaseWorkflows = Record<string, ZuiObjectSchema>;
+export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = typeUtils.Merge<BotTableDefinition, {
+    schema: TTable;
+}>;
+export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = typeUtils.Merge<BotStateDefinition, {
+    schema: TState;
+}>;
+export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = typeUtils.Merge<BotEventDefinition, {
+    schema: TEvent;
+}>;
+export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = typeUtils.Merge<BotActionDefinition, {
+    input: {
+        schema: TAction;
+    };
+    output: {
+        schema: ZuiObjectOrRefSchema;
+    };
+}>;
+export type RecurringEventDefinition<TEvents extends BaseEvents = BaseEvents> = {
+    [K in keyof TEvents]: TEvents[K] extends ZuiObjectSchema ? {
+        type: K;
+        payload: z.infer<TEvents[K]>;
+        schedule: {
+            cron: string;
+        };
+    } : never;
+}[keyof TEvents];
+export type ZuiSchemaWithEntityReferences<TInterfaces extends BaseInterfaces, TReturnType extends ZuiObjectOrRefSchema> = ((props: {
+    entities: {
+        [TInterfaceAlias in keyof TInterfaces]: {
+            [TEntityName in keyof TInterfaces[TInterfaceAlias]['definition']['entities']]: z.ZodRef;
+        };
+    };
+}) => TReturnType) | TReturnType;
+type GenericDefinition<TInterfaces extends BaseInterfaces, TDefinition extends {
+    schema: ZuiObjectOrRefSchema;
+}> = typeUtils.Merge<TDefinition, {
+    schema: ZuiSchemaWithEntityReferences<TInterfaces, TDefinition['schema']>;
+}>;
+type GenericNestedDefinition<TInterfaces extends BaseInterfaces, TDefinition extends {
+    [k: string]: any;
+}, TKeys extends string> = Omit<TDefinition, TKeys> & {
+    [TKey in TKeys]: Omit<TDefinition[TKey], 'schema'> & {
+        schema: ZuiSchemaWithEntityReferences<TInterfaces, TDefinition[TKey]['schema']>;
+    };
+};
 export type PluginDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
     name: TName;
     version: TVersion;
@@ -18,28 +64,24 @@ export type PluginDefinitionProps<TName extends string = string, TVersion extend
     icon?: string;
     readme?: string;
     attributes?: Record<string, string>;
-    integrations?: {
-        [K in keyof TIntegrations]: IntegrationPackage;
-    };
-    interfaces?: {
-        [K in keyof TInterfaces]: InterfacePackage;
-    };
+    integrations?: TIntegrations;
+    interfaces?: TInterfaces;
     user?: UserDefinition;
     conversation?: ConversationDefinition;
     message?: MessageDefinition;
     states?: {
-        [K in keyof TStates]: StateDefinition<TStates[K]>;
+        [K in keyof TStates]: GenericDefinition<TInterfaces, StateDefinition<TStates[K]>>;
     };
     configuration?: ConfigurationDefinition<TConfig>;
     events?: {
-        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+        [K in keyof TEvents]: GenericDefinition<TInterfaces, EventDefinition<TEvents[K]>>;
     };
     recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
     actions?: {
-        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+        [K in keyof TActions]: GenericNestedDefinition<TInterfaces, ActionDefinition<TActions[K]>, 'input' | 'output'>;
     };
     tables?: {
-        [K in keyof TTables]: TableDefinition<TTables[K]>;
+        [K in keyof TTables]: GenericDefinition<TInterfaces, TableDefinition<TTables[K]>>;
     };
     /**
      * # EXPERIMENTAL
@@ -63,12 +105,37 @@ export declare class PluginDefinition<TName extends string = string, TVersion ex
     readonly user: this['props']['user'];
     readonly conversation: this['props']['conversation'];
     readonly message: this['props']['message'];
-    readonly states: this['props']['states'];
+    readonly states: {
+        [K in keyof TStates]: StateDefinition<TStates[K]>;
+    };
     readonly configuration: this['props']['configuration'];
-    readonly events: this['props']['events'];
+    readonly events: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
     readonly recurringEvents: this['props']['recurringEvents'];
-    readonly actions: this['props']['actions'];
-    readonly tables: this['props']['tables'];
+    readonly actions: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+    readonly tables: {
+        [K in keyof TTables]: TableDefinition<TTables[K]>;
+    };
     readonly workflows: this['props']['workflows'];
     constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables, TWorkflows>);
+    /**
+     * Returns a copy of the plugin definition where all entity references are
+     * resolved to the base entity schema defined by the interface. This does not
+     * include any additional properties that may be added to the entity by the
+     * backing integration.
+     *
+     * If `intersectWithUnknownRecord` is `true` (default), the entity schemas
+     * will be intersected with `z.record(z.string(), z.unknown())` to make it
+     * explicit that the backing integration may have added additional properties.
+     */
+    dereferenceEntities({ intersectWithUnknownRecord }?: {
+        intersectWithUnknownRecord?: boolean;
+    }): this;
+    private _buildZuiReferenceMap;
+    private _dereferenceZuiSchema;
+    private _dereferenceDefinitionSchemas;
+    private _dereferenceActionDefinitionSchemas;
 }

package/dist/schema.d.ts

@@ -4,10 +4,10 @@ type SchemaOptions<T> = {
     examples: T[];
 };
 type IsEmptyObject<T> = keyof T extends never ? true : false;
-type UiDefinition<TSchema extends z.ZuiObjectSchema = z.ZuiObjectSchema> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
+type UiDefinition<TSchema extends z.ZuiObjectOrRefSchema = z.ZuiObjectOrRefSchema> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
     [K in keyof z.infer<TSchema>]: Partial<SchemaOptions<z.infer<TSchema>[K]>>;
 };
-export type SchemaDefinition<TSchema extends z.ZuiObjectSchema = z.ZuiObjectSchema> = {
+export type SchemaDefinition<TSchema extends z.ZuiObjectOrRefSchema = z.ZuiObjectOrRefSchema> = {
     schema: TSchema;
     /**
      * @deprecated

package/dist/zui.d.ts

@@ -2,5 +2,6 @@ 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 type ZuiObjectOrRefSchema = ZuiObjectSchema | z.ZodRef;
 export declare const mergeObjectSchemas: (a: ZuiObjectSchema, b: ZuiObjectSchema) => ZuiObjectSchema;
 export default z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "4.9.0",
+  "version": "4.11.0",
   "description": "Botpress SDK",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -16,7 +16,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "1.15.2",
+    "@botpress/client": "1.15.3",
     "browser-or-node": "^2.1.1"
   },
   "devDependencies": {