Version 2.7.2 (#51)

- Removed logging that might disclose sensitive info - Fixed name of bag item disambiguateMessage event in TypeScript - Added new CMM message types and properties - Typescript bots-node-sdk did not allow creating sub-type items for DateTime bag item.
oracle · Nov 22, 2023 · b94ee7d · b94ee7d
1 parent eea4ced
commit b94ee7d
Show file tree

Hide file tree

Showing 27 changed files with 563 additions and 58 deletions.
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
@@ -1,5 +1,6 @@
 # Release Notes
 
+- [Version 2.7.2](#v272)
 - [Version 2.7.1](#v271)
 - [Version 2.7.0](#v270)
 - [Version 2.6.8](#v268)
@@ -20,6 +21,17 @@
 - [Version 2.4.3](#v243)
 - [Version 2.4.2](#v242)
 
+## <a name="v272">Version 2.7.2 </a>
+
+### New Features
+- Added new CMM message types and properties 
+
+### Fixed Issues
+
+- Removed logging that might disclose sensitive info
+- Fixed name of bag item disambiguateMessage event in TypeScript
+- Fixed issue with nested items not supported in entity item event in TypeScript
+
 ## <a name="v271">Version 2.7.1 </a>
 
 ### Fixed Issues

diff --git a/lib/dataquery/utils.js b/lib/dataquery/utils.js
@@ -31,7 +31,6 @@ async function invokeDataQueryEventHandlers(component, context) {
           // update row with formatted value if attribute is included in the row and has a value
           if (row[attributeName]) {
             event.properties = {'attributeValue': row[attributeName]};
-            logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
             let returnValue = await Promise.resolve(handler(event.properties, context));
             if (returnValue) {
               row[attributeName] = returnValue
@@ -43,7 +42,6 @@ async function invokeDataQueryEventHandlers(component, context) {
         let metadata = context.getAttributeUISettings(attributeName);
         if (metadata) {
           event.properties = {'settings': metadata};
-          logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
           let returnValue = await Promise.resolve(handler(event.properties, context));
           if (returnValue) {
             context.setAttributeUISettings(attributeName, returnValue);
@@ -54,7 +52,6 @@ async function invokeDataQueryEventHandlers(component, context) {
         let settings = context.getUISettings();
         if (settings) {
           event.properties = {'settings': settings};
-          logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
           let returnValue = await Promise.resolve(handler(event.properties, context));
           if (returnValue) {
             context.setUISettings(returnValue);
@@ -63,21 +60,19 @@ async function invokeDataQueryEventHandlers(component, context) {
       } else if (handlerPath === `entity.changeResponseData`) {
         let data = context.getQueryResult() || [];
         event.properties = {'responseData': data};
-        logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
         let returnValue = await Promise.resolve(handler(event.properties, context));
         if (returnValue) {
           context.setQueryResult(returnValue);
         }
       } else if (handlerPath === `entity.changeBotMessages`) {
         event.properties = {'messages': context.getRequest().candidateMessages};
-        logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
         let returnValue = await Promise.resolve(handler(event.properties, context));
         if (returnValue) {
           context.getResponse().messages = returnValue;
         }
       }
     } else {
-      logger.debug(`No handler found for event: ${handlerPath}`);
+      logger.error(`No handler found for event: ${handlerPath}`);
       break;
     }              
   } 

diff --git a/lib/entity/utils.js b/lib/entity/utils.js
@@ -35,15 +35,13 @@ async function invokeResolveEntitiesEventHandlers(component, context) {
       handlerPath = `entity.${eventName}`;
     }
     if (handler) {
-      logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
       // event handlers can be async (returning a promise), but we dont want to enforce
       // every event handler is async, hence Promise.resolve wrapping of invocation
       let returnValue = await Promise.resolve(handler(event.properties || {}, context));
       // make sure return value is a boolean
       let retValue = returnValue === undefined ? true : (returnValue+''==='true')   
       logger.debug(`${eventName} returned ${retValue}`);
       if (eventName==='shouldPrompt') {        
-        logger.debug(`Adding ${itemName} to shouldPrompt cache with value ${retValue}`);
         context._getShouldPromptCache()[itemName] = retValue;
         if (retValue) {
           // only invoke next shouldPrompt handler when current handler returned false
@@ -62,7 +60,7 @@ async function invokeResolveEntitiesEventHandlers(component, context) {
         } 
       }
     } else {
-      logger.debug(`No handler found for event: ${handlerPath}`);
+      logger.error(`No handler found for event: ${handlerPath}`);
       break;
     }              
   } 

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@oracle/bots-node-sdk",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "Oracle Digital Assistant SDK for custom component development and webhook integrations",
   "main": "index.js",
   "browser": "index-browser.js",

diff --git a/ts/lib.ts b/ts/lib.ts
@@ -75,7 +75,7 @@ export namespace Lib {
 
   export type EntityItemPublishPromptMessageEvent = lib.EntityItemPublishPromptMessageEvent
 
-  export type EntityItemPublishDisambiguationMessageEvent = lib.EntityItemPublishDisambiguationMessageEvent
+  export type EntityItemPublishDisambiguateMessageEvent = lib.EntityItemPublishDisambiguateMessageEvent
 
   export type EntityItemMaxPromptsReachedEvent = lib.EntityItemMaxPromptsReachedEvent
 

diff --git a/ts/lib/component/kinds.ts b/ts/lib/component/kinds.ts
@@ -67,10 +67,11 @@ export interface EntityEvent {
 }
 
 export interface EntityItemEvents {
+  items?: EntityItems;
   shouldPrompt?(event: EntityValidateEvent, context: EntityResolutionContext): void
   validate?(event: EntityItemValidateEvent, context: EntityResolutionContext): void
   publishPromptMessage?(event: EntityItemPublishPromptMessageEvent, context: EntityResolutionContext): void
-  publishDisambiguationMessage?(event: EntityItemPublishDisambiguationMessageEvent, context: EntityResolutionContext): void
+  publishDisambiguateMessage?(event: EntityItemPublishDisambiguateMessageEvent, context: EntityResolutionContext): void
   maxPromptsReached?(event: EntityItemMaxPromptsReachedEvent, context: EntityResolutionContext): void
 }
 
@@ -139,7 +140,7 @@ export interface EntityItemPublishPromptMessageEvent extends EntityBaseEvent {
   promptCount: number;
 }
 
-export interface EntityItemPublishDisambiguationMessageEvent extends EntityBaseEvent {
+export interface EntityItemPublishDisambiguateMessageEvent extends EntityBaseEvent {
   disambiguationValues: object[];
 }
 

diff --git a/ts/lib/dataquery/utils.ts b/ts/lib/dataquery/utils.ts
@@ -34,7 +34,6 @@ export async function invokeDataQueryEventHandlers(component: DataQueryEventHand
           // update row with formatted value if attribute is included in the row and has a value
           if (row[attributeName]) {
             event.properties = {'attributeValue': row[attributeName]};
-            logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
             let returnValue = await Promise.resolve(handler(event.properties, context));
             if (returnValue) {
               row[attributeName] = returnValue
@@ -46,7 +45,6 @@ export async function invokeDataQueryEventHandlers(component: DataQueryEventHand
         let metadata = context.getAttributeUISettings(attributeName);
         if (metadata) {
           event.properties = {'settings': metadata};
-          logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
           let returnValue = await Promise.resolve(handler(event.properties, context));
           if (returnValue) {
             context.setAttributeUISettings(attributeName, returnValue);
@@ -57,7 +55,6 @@ export async function invokeDataQueryEventHandlers(component: DataQueryEventHand
         let settings = context.getUISettings();
         if (settings) {
           event.properties = {'settings': settings};
-          logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
           let returnValue = await Promise.resolve(handler(event.properties, context));
           if (returnValue) {
             context.setUISettings(returnValue);
@@ -66,21 +63,19 @@ export async function invokeDataQueryEventHandlers(component: DataQueryEventHand
       } else if (handlerPath === `entity.changeResponseData`) {
         let data = context.getQueryResult() || [];
         event.properties = {'responseData': data};
-        logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
         let returnValue = await Promise.resolve(handler(event.properties, context));
         if (returnValue) {
           context.setQueryResult(returnValue);
         }
       } else if (handlerPath === `entity.changeBotMessages`) {
         event.properties = {'messages': context.getRequest().candidateMessages};
-        logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
         let returnValue = await Promise.resolve(handler(event.properties, context));
         if (returnValue) {
           context.getResponse().messages = returnValue;
         }
       }
     } else {
-      logger.debug(`No handler found for event: ${handlerPath}`);
+      logger.error(`No handler found for event: ${handlerPath}`);
       break;
     }
   }

diff --git a/ts/lib/entity/utils.ts b/ts/lib/entity/utils.ts
@@ -33,15 +33,12 @@ export async function invokeResolveEntitiesEventHandlers(
       handlerPath = `entity.${eventName}`;
     }
     if (handler) {
-      logger.debug(`Invoking event handler ${handlerPath} with event: ${JSON.stringify(event)}`);
       // event handlers can be async (returning a promise), but we dont want to enforce
       // every event handler is async, hence Promise.resolve wrapping of invocation
       let returnValue = await Promise.resolve(handler(event.properties || {}, context));
       // make sure return value is a boolean
       let retValue = returnValue === undefined ? true : (returnValue + '' === 'true')
-      logger.debug(`${eventName} returned ${retValue}`);
       if (eventName === 'shouldPrompt') {
-        logger.debug(`Adding ${itemName} to shouldPrompt cache with value ${retValue}`);
         context._getShouldPromptCache()[itemName] = retValue;
         if (retValue) {
           // only invoke next shouldPrompt handler when current handler returned false
@@ -60,7 +57,7 @@ export async function invokeResolveEntitiesEventHandlers(
         }
       }
     } else {
-      logger.debug(`No handler found for event: ${handlerPath}`);
+      logger.error(`No handler found for event: ${handlerPath}`);
       break;
     }
   }

diff --git a/ts/lib2/llmcomponent/utils.ts b/ts/lib2/llmcomponent/utils.ts
@@ -24,14 +24,11 @@ export async function invokeLlmComponentHandlers(component: LlmComponentHandler,
     // event handlers can be async (returning a promise), but we dont want to enforce
     // every event handler is async, hence Promise.resolve wrapping of invocation
     if (eventName === `validateResponsePayload` || eventName === `validateRequestPayload`) {
-      logger.debug(`Invoking event handler ${eventName}`);
       let returnValue = await Promise.resolve(handler(event.properties, context));
       // make sure return value is a boolean
       let retValue = returnValue === undefined ? true : (returnValue + '' === 'true')
-      logger.debug(`${eventName} returned ${retValue}`);
       context.getResponse().valid = retValue;
     } else if (eventName === `changeBotMessages` ) {
-      logger.debug(`Invoking event handler ${eventName}`);
       // convert json messages to message class
       const mf = context.getMessageFactory();
       let messages = event.properties.messages.map(msg => mf.messageFromJson(msg));
@@ -48,11 +45,10 @@ export async function invokeLlmComponentHandlers(component: LlmComponentHandler,
       let currMessages = context.getResponse().messages || [];
       context.getResponse().messages = currMessages.concat(messages);
     } else {
-      logger.debug(`Invoking ${event.custom ? 'custom ' : ''}event handler ${eventName}`);
       await Promise.resolve(handler(event.properties, context));
     }
   } else {
-    logger.debug(`No handler found for event: ${eventName}`);
+    logger.error(`No handler found for event: ${eventName}`);
   }
 }
 

diff --git a/ts/lib2/llmtransformation/utils.ts b/ts/lib2/llmtransformation/utils.ts
@@ -18,20 +18,18 @@ export async function invokeLlmTransformationHandlers(component: LlmTransformati
     // event handlers can be async (returning a promise), but we dont want to enforce
     // every event handler is async, hence Promise.resolve wrapping of invocation
     if (eventName === `transformRequestPayload`) {
-      logger.debug(`Invoking event handler ${eventName}`);
       let returnValue = await Promise.resolve(handler(event.properties, context));
       if (returnValue) {
         context.setRequestPayload(returnValue);
       }
     } else if (eventName === `transformResponsePayload` || eventName === `transformErrorResponsePayload`) {
-      logger.debug(`Invoking event handler ${eventName}`);
       let returnValue = await Promise.resolve(handler(event.properties, context));
       if (returnValue) {
         context.setResponsePayload(returnValue);
       }
     }
   } else {
-    logger.debug(`No handler found for event: ${eventName}`);
+    logger.error(`No handler found for event: ${eventName}`);
   }
 }
 

diff --git a/ts/lib2/messagev2/action/action.ts b/ts/lib2/messagev2/action/action.ts
@@ -10,6 +10,7 @@ export class Action extends ChannelCustomizable {
   private voice?: Voice;
   private imageUrl?: string;
   private style?: ActionStyle;
+  private displayType?: DisplayType;
 
   /**
    * Deserialize nested object properties into corresponding class instances
@@ -119,6 +120,24 @@ export class Action extends ChannelCustomizable {
     return this;
   }
 
+  /**
+   * Gets the style of the action.
+   * @returns {DisplayType} The display type of the action.
+   */
+  public getDisplayType(): DisplayType {
+    return this.displayType;
+  }
+
+  /**
+   * Sets the display type of the action.
+   * @param {DisplayType} displayType - The display type to set.
+   * @returns The current instance of the Action class.
+   */
+  public setDisplayType(displayType: DisplayType): this {
+    this.displayType = displayType;
+    return this;
+  }
+
 }
 
 /**
@@ -129,3 +148,12 @@ export enum ActionStyle {
   danger = 'danger',
 }
 
+/**
+ * Represents the display type of an action.
+ */
+export enum DisplayType {
+  button = 'button',
+  link = 'link',
+  icon = 'icon',
+}
+
diff --git a/ts/lib2/messagev2/action/index.ts b/ts/lib2/messagev2/action/index.ts
@@ -1,4 +1,5 @@
 export * from './callAction';
+export * from './popupAction';
 export * from './action';
 export * from './keyword';
 export * from './locationAction';

diff --git a/ts/lib2/messagev2/action/popupAction.ts b/ts/lib2/messagev2/action/popupAction.ts
@@ -0,0 +1,53 @@
+import { Action, NonRawMessage, MessageUtil } from '../internal';
+
+/**
+ * Represents a popup action. When clicked a popup dialog opens that shows the popup content
+ * @extends Action
+ */
+export class PopupAction extends Action {
+  public readonly type: string = 'popup';
+  private popupContent: NonRawMessage;
+
+  /**
+   * Creates an instance of PopupAction.
+   * @param label - The label of the popup action.
+   * @param popupContent - The popup content associated with the popup action.
+   */
+  constructor(label: string, popupContent: NonRawMessage) {
+    super(label);
+    this.popupContent = popupContent;
+  }
+
+  /**
+   * Deserialize nested object properties into corresponding class instances
+   */
+  public deserializeNestedProperties(): void {
+    super.deserializeNestedProperties();
+    if (this.popupContent) {
+      this.popupContent = MessageUtil.deserializeMessage(this.popupContent);
+    }
+  }
+
+  /**
+   * Gets the popup content associated with the popup action.
+   * @returns The popup content associated with the popup action.
+   */
+  public getPopupContent(): NonRawMessage {
+    return this.popupContent;
+  }
+
+  /**
+   * Sets the popup content associated with the popup action.
+   * @param popupContent - The popup content to set.
+   * @returns The current instance of the PopupAction class.
+   */
+  public setPopupContent(popupContent: NonRawMessage): this {
+    this.popupContent = popupContent;
+    return this;
+  }
+
+}
+
+
+
+