fix: Check all expressions in dialog

Composer/packages/client/__tests__/utils/convertUtils/parsePathToFocused.test.ts

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License
+
+import { parsePathToFocused } from '../../../src/utils/convertUtils';
+
+describe('parsePathToFocused', () => {
+  it('should return focusedPath', () => {
+    expect(parsePathToFocused('')).toBe('');
+    expect(parsePathToFocused('main.triggers[0].actions[0]')).toBe('triggers[0].actions[0]');
+    expect(parsePathToFocused('main.triggers[0].actions[0].actions[1]')).toBe('triggers[0].actions[0].actions[1]');
+    expect(parsePathToFocused('main.triggers[0].actions[0].elseActions[1]')).toBe(
+      'triggers[0].actions[0].elseActions[1]'
+    );
+  });
+});

Composer/packages/lib/shared/__tests__/convertUtils/parsePathToSelected.test.ts → Composer/packages/client/__tests__/utils/convertUtils/parsePathToSelected.test.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License
 
-import { parsePathToSelected } from '../../src';
+import { parsePathToSelected } from '../../../src/utils/convertUtils';
 
 describe('parsePathToSelected', () => {
   it('should return selected path', () => {

Composer/packages/lib/shared/__tests__/convertUtils/parseTypeToFragment.test.ts → Composer/packages/client/__tests__/utils/convertUtils/parseTypeToFragment.test.ts

@@ -1,7 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License
+import { PromptTab } from '@bfc/shared';
 
-import { parseTypeToFragment, PromptTab } from './../../src';
+import { parseTypeToFragment } from '../../../src/utils/convertUtils';
 
 describe('parseTypeToFragment', () => {
   it('should return corrent tab name', () => {

Composer/packages/client/src/utils/convertUtils/parsePathToFocused.ts

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { parsePathToSelected } from './parsePathToSelected';
+
+export function parsePathToFocused(path: string): string {
+  //path is like main.trigers[0].actions[0]
+
+  const trigger = parsePathToSelected(path);
+
+  const list = path.split('.');
+
+  const matchActions = list.filter(x => x.startsWith('actions') || x.startsWith('elseActions'));
+
+  if (matchActions.length > 0) {
+    return trigger + '.' + matchActions.join('.');
+  }
+  return '';
+}

Composer/packages/client/src/utils/convertUtils/parseTypeToFragment.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { dialogGroups, DialogGroup, PromptTab } from '@bfc/shared';
+
+export function parseTypeToFragment(type: string, property: string): string {
+  const inputTypes = dialogGroups[DialogGroup.INPUT].types;
+  const index = inputTypes.findIndex(t => t === type);
+  if (index >= 0) {
+    switch (property) {
+      case 'prompt':
+        return PromptTab.BOT_ASKS;
+      case 'property':
+      case 'choices':
+      case 'outputFormat':
+        return PromptTab.USER_INPUT;
+      default:
+        return PromptTab.OTHER;
+    }
+  }
+  return '';
+}

Composer/packages/client/src/utils/navigation.ts

@@ -4,10 +4,10 @@
 import cloneDeep from 'lodash/cloneDeep';
 import { navigate, NavigateOptions } from '@reach/router';
 import { Diagnostic } from '@bfc/indexers';
-import { parsePathToFocused, parsePathToSelected, parseTypeToFragment } from '@bfc/shared';
 
 import { BreadcrumbItem, DesignPageLocation } from '../store/types';
 
+import { parsePathToFocused, parsePathToSelected, parseTypeToFragment } from './convertUtils';
 import { BASEPATH } from './../constants/index';
 import { resolveToBasePath } from './fileUtil';
 

Composer/packages/lib/indexers/src/dialogIndexer.ts

@@ -4,13 +4,13 @@
 import has from 'lodash/has';
 import uniq from 'lodash/uniq';
 
+import { checkerFuncs } from './dialogUtils/dialogChecker';
 import { ITrigger, DialogInfo, FileInfo } from './type';
 import { JsonWalk, VisitorFunc } from './utils/jsonWalk';
 import { getBaseName } from './utils/help';
 import { Diagnostic } from './diagnostic';
 import { extractLgTemplateRefs } from './lgUtils/parsers/parseLgTemplateRef';
-import { getExpressionProperties } from './dialogUtils/extractExpressionDefinitions';
-import { IsExpression } from './dialogUtils';
+
 // find out all lg templates given dialog
 function ExtractLgTemplates(dialog): string[] {
   const templates: string[] = [];
@@ -127,27 +127,26 @@ function ExtractReferredDialogs(dialog): string[] {
 
 // check all fields
 function CheckFields(dialog, id: string, schema: any): Diagnostic[] {
-  const errors: Diagnostic[] = [];
-  const expressionProperties = getExpressionProperties(schema);
+  const diagnostics: Diagnostic[] = [];
   /**
    *
    * @param path , jsonPath string
    * @param value , current node value    *
    * @return boolean, true to stop walk
    * */
   const visitor: VisitorFunc = (path: string, value: any): boolean => {
-    // it's a valid schema dialog node.
-    if (has(value, '$type') && has(expressionProperties, value.$type)) {
-      const diagnostics = IsExpression(path, value, { ...expressionProperties[value.$type] });
-
-      if (diagnostics) {
-        errors.push(...diagnostics);
-      }
+    if (has(value, '$type')) {
+      checkerFuncs.forEach(checkerFunc => {
+        const result = checkerFunc(path, value, value.$type, schema.definitions[value.$type]);
+        if (result) {
+          diagnostics.splice(0, 0, ...result);
+        }
+      });
     }
     return false;
   };
   JsonWalk(id, dialog, visitor);
-  return errors.map(e => {
+  return diagnostics.map(e => {
     e.source = id;
     return e;
   });
@@ -164,6 +163,7 @@ function validate(id: string, content, schema: any): Diagnostic[] {
 function parse(id: string, content: any, schema: any) {
   const luFile = typeof content.recognizer === 'string' ? content.recognizer : '';
   const lgFile = typeof content.generator === 'string' ? content.generator : '';
+
   return {
     content,
     diagnostics: validate(id, content, schema),

Composer/packages/lib/indexers/src/dialogUtils/dialogChecker.ts

@@ -11,30 +11,91 @@ import { CheckerFunc } from './types';
 
 const ExpressionParser = new ExpressionEngine();
 
-export const IsExpression: CheckerFunc = (
-  path,
-  value,
-  optional: { properties: string[]; requiredTypes: { [key: string]: boolean } }
-) => {
-  const { properties, requiredTypes } = optional;
-  return properties.reduce((result: Diagnostic[], property) => {
-    let message = '';
-    const exp = get(value, property);
-    if (!exp && requiredTypes[property]) {
-      message = formatMessage(`is missing or empty`);
-    } else {
-      try {
-        ExpressionParser.parse(exp);
-      } catch (error) {
-        message = `${formatMessage('must be an expression:')} ${error})`;
+const createPath = (path: string, type: string): string => {
+  const steps = ['triggers', 'actions', 'elseActions'];
+  let list = path.split('.');
+  const matchs = list.filter(x => !steps.every(step => !x.startsWith(step)));
+
+  const focused = matchs.join('.');
+  list = path.split(`${focused}.`);
+  if (list.length !== 2) return path;
+
+  return `${list[0]}${focused}#${type}#${list[1]}`;
+};
+
+export const checkExpression = (exp: string, required: boolean, path: string, type: string): Diagnostic | null => {
+  let message = '';
+  if (!exp && required) {
+    message = formatMessage(`is missing or empty`);
+  } else {
+    try {
+      ExpressionParser.parse(exp);
+    } catch (error) {
+      message = `${formatMessage('must be an expression:')} ${error})`;
+    }
+  }
+  if (message) {
+    const diagnostic = new Diagnostic(message, '');
+    diagnostic.path = createPath(path, type);
+    return diagnostic;
+  }
+
+  return null;
+};
+
+function findAllRequiredType(schema: any): { [key: string]: boolean } {
+  const types = schema.anyOf?.filter(x => x.title === 'Type');
+  const required = {};
+  if (types && types.length) {
+    types[0].required.forEach((element: string) => {
+      required[element] = true;
+    });
+  }
+
+  if (schema.required) {
+    schema.required.forEach((element: string) => {
+      required[element] = true;
+    });
+  }
+  return required;
+}
+
+export const IsExpression: CheckerFunc = (path, value, type, schema) => {
+  const diagnostics: Diagnostic[] = [];
+  const requiredTypes = findAllRequiredType(schema);
+  Object.keys(value).forEach(key => {
+    const property = value[key];
+    if (Array.isArray(property)) {
+      const itemsSchema = schema.properties[key].items;
+      if (itemsSchema?.$role === 'expression') {
+        property.forEach((child, index) => {
+          const diagnostic = checkExpression(child, !!requiredTypes[key], `${path}.${key}[${index}]`, type);
+          if (diagnostic) diagnostics.push(diagnostic);
+        });
+      } else if (itemsSchema?.type === 'object') {
+        property.forEach((child, index) => {
+          const result = IsExpression(`${path}.${key}[${index}]`, child, type, itemsSchema);
+          if (result) diagnostics.splice(0, 0, ...result);
+        });
       }
+    } else if (get(schema.properties[key], '$role') === 'expression') {
+      const diagnostic = checkExpression(property, !!requiredTypes[key], `${path}.${key}`, type);
+      if (diagnostic) diagnostics.push(diagnostic);
     }
-    if (message) {
-      const diagnostic = new Diagnostic(message, '');
-      diagnostic.path = `${path}#${value.$type}#${property}`;
-      result.push(diagnostic);
+  });
+  return diagnostics;
+};
+
+//the type of 'Microsoft.ChoiceInput' has anyof schema in choices
+export const checkChoices: CheckerFunc = (path, value, type, schema) => {
+  if (type === 'Microsoft.ChoiceInput') {
+    const choices = value.choices;
+    if (typeof choices === 'string') {
+      const diagnostic = checkExpression(choices, false, `${path}.choices`, type);
+      if (diagnostic) return [diagnostic];
     }
-    return result;
-  }, []);
+  }
   return null;
 };
+
+export const checkerFuncs: CheckerFunc[] = [IsExpression, checkChoices];

Composer/packages/lib/indexers/src/dialogUtils/index.ts

@@ -2,5 +2,4 @@
 // Licensed under the MIT License.
 
 export * from './dialogChecker';
-export * from './extractExpressionDefinitions';
 export * from './types';

Composer/packages/lib/indexers/src/dialogUtils/types.ts

@@ -23,4 +23,4 @@ export interface IExpressionProperties {
   };
 }
 
-export type CheckerFunc = (path: string, value: any, optional?: any) => Diagnostic[] | null; // error msg
+export type CheckerFunc = (path: string, value: any, type: string, schema: any) => Diagnostic[] | null; // error msg