Switch to interface/implements in dialog:merge. (#621)

Co-authored-by: Emilio Munoz <[email protected]>

Author: Chris McConnell

libraries/Microsoft.Bot.Builder.Dialogs.Adaptive/Schemas/Microsoft.AdaptiveDialog.schema

@@ -146,7 +146,7 @@ export default class DialogMerge extends Command {
                         }
                         let filename = schemaPath.split(/[\\\/]/).pop() as string
                         let kind = filename.substr(0, filename.lastIndexOf('.'))
-                        if (!schema.type && !this.isUnion(schema)) {
+                        if (!schema.type && !this.isInterface(schema)) {
                             schema.type = 'object'
                         }
                         definitions[kind] = schema
@@ -157,7 +157,7 @@ export default class DialogMerge extends Command {
                 this.addKindTitles(definitions)
                 this.expandKinds(definitions)
                 this.addStandardProperties(definitions, metaSchema)
-                this.sortUnions(definitions)
+                this.sortImplementations(definitions)
                 let finalDefinitions: any = {}
                 for (let key of Object.keys(definitions).sort()) {
                     finalDefinitions[key] = definitions[key]
@@ -169,7 +169,7 @@ export default class DialogMerge extends Command {
                     title: 'Component kinds',
                     description: 'These are all of the kinds that can be created by the loader.',
                     oneOf: Object.keys(definitions)
-                        .filter(schemaName => !this.isUnion(definitions[schemaName]))
+                        .filter(schemaName => !this.isInterface(definitions[schemaName]))
                         .sort()
                         .map(schemaName => {
                             return {
@@ -360,7 +360,7 @@ export default class DialogMerge extends Command {
     }
 
     processRole(role: string, elt: any, kind: string, definitions: any, key?: string): void {
-        const prefix = 'union('
+        const prefix = 'implements('
         if (role === 'expression') {
             const reserved = ['title', 'description', 'examples', '$role']
             if (elt.kind) {
@@ -400,29 +400,29 @@ export default class DialogMerge extends Command {
                     choices.push({ type: 'string', title: 'Expression' })
                 }
             }
-        } else if (role === 'union') {
+        } else if (role === 'interface') {
             if (key) {
-                this.error(`${this.currentFile}:error: union $role can only be defined at the top of the schema definition.`)
+                this.error(`${this.currentFile}:error: interface $role can only be defined at the top of the schema definition.`)
             }
         } else if (role.startsWith(prefix) && role.endsWith(')')) {
-            let union = role.substring(prefix.length, role.length - 1)
-            if (!definitions[union]) {
-                this.error(`${this.currentFile}:error: union ${union} is not defined.`)
-            } else if (!this.isUnion(definitions[union])) {
-                this.error(`${this.currentFile}:error: is missing $role of union.`)
+            let interfaceName = role.substring(prefix.length, role.length - 1)
+            if (!definitions[interfaceName]) {
+                this.error(`${this.currentFile}:error: interface ${interfaceName} is not defined.`)
+            } else if (!this.isInterface(definitions[interfaceName])) {
+                this.error(`${this.currentFile}:error: is missing $role of interface.`)
             } else {
                 let definition = definitions[kind]
-                let unionDefinition = definitions[union]
-                if (!unionDefinition.oneOf) {
-                    unionDefinition.oneOf = [
+                let interfaceDefinition = definitions[interfaceName]
+                if (!interfaceDefinition.oneOf) {
+                    interfaceDefinition.oneOf = [
                         {
                             type: 'string',
-                            title: `Reference to ${union}`,
-                            description: `Reference to ${union} .dialog file.`
+                            title: `Reference to ${interfaceName}`,
+                            description: `Reference to ${interfaceName} .dialog file.`
                         }
                     ]
                 }
-                unionDefinition.oneOf.push({
+                interfaceDefinition.oneOf.push({
                     title: kind,
                     description: definition.description || '',
                     $ref: `#/definitions/${kind}`
@@ -478,7 +478,7 @@ export default class DialogMerge extends Command {
     addStandardProperties(definitions: any, dialogSchema: any): void {
         for (let kind in definitions) {
             let definition = definitions[kind]
-            if (!this.isUnion(definition)) {
+            if (!this.isInterface(definition)) {
                 // Reorder properties to put $ first.
                 let props: any = {
                     $kind: clone(dialogSchema.definitions.kind),
@@ -516,10 +516,10 @@ export default class DialogMerge extends Command {
         }
     }
 
-    sortUnions(definitions: any): void {
+    sortImplementations(definitions: any): void {
         for (let key in definitions) {
             let definition = definitions[key]
-            if (this.isUnion(definition) && definition.oneOf) {
+            if (this.isInterface(definition) && definition.oneOf) {
                 definition.oneOf = definition.oneOf.sort((a: any, b: any) => a.title.localeCompare(b.title))
             }
         }
@@ -573,8 +573,8 @@ export default class DialogMerge extends Command {
         })
     }
 
-    isUnion(schema: any): boolean {
-        return schema.$role === 'union'
+    isInterface(schema: any): boolean {
+        return schema.$role === 'interface'
     }
 
     missing(kind: string): void {

packages/dialog/src/commands/dialog/merge.ts

@@ -2,7 +2,7 @@
 
 ## Merge
 
-Ths will merge together [Microsoft Bot Builder](https://github.com/Microsoft/BotBuilder) .schema JSON schema files into a single JSON schema file. You can point to the files either directly with a glob pattern or indirectly through a glob pattern that matches a package.json, packages.config or \*.csproj file. The .schema files should have a unique filename that is used to refer to that type using `$kind`. The .schema files can optionally include a `$schema: "https://raw.githubusercontent.com/Microsoft/botbuilder-tools/SchemaGen/packages/DialogSchema/src/dialogSchema.schema"` which defines the schema they are validated against. Within a schema definition you can use `$role:"union(<kind>)` to project the type definition into union types defined using `$role:"union"` while merging. To refer to a type in a property, just use `"$kind":"<kind>"`. The merger combines all of the component .schema files into a single .schema file that has resolved all external `$ref`, merged `allOf` and connected together schemas through `$role` and `$kind`.
+Ths will merge together [Microsoft Bot Builder](https://github.com/Microsoft/BotBuilder) .schema JSON schema files into a single JSON schema file. You can point to the files either directly with a glob pattern or indirectly through a glob pattern that matches a package.json, packages.config or \*.csproj file. The .schema files should have a unique filename that is used to refer to that type using `$kind`. The .schema files can optionally include a `$schema: "https://raw.githubusercontent.com/Microsoft/botbuilder-tools/SchemaGen/packages/DialogSchema/src/dialogSchema.schema"` which defines the schema they are validated against. Within a schema definition you can use `$role:"implements(<kind>)` to project the type definition into interface types defined using `$role:"interface"` while merging. To refer to a type in a property, just use `"$kind":"<kind>"`. The merger combines all of the component .schema files into a single .schema file that has resolved all external `$ref`, merged `allOf` and connected together schemas through `$role` and `$kind`.
 
 In addition to types you can also mark properties with a `$role` which will define the underlying type and restrictions. This is also useful information for UI tools to help you construct values. Roles include:
 
@@ -13,7 +13,7 @@ In addition to types you can also mark properties with a `$role` which will defi
 For example look at these files:
 
 - [IRecognizer.schema](test/schemas/IRecognizer.schema) defines the place holder for `IRecognizer` including a default option which is a bare string.
-- [Recognizer.schema](test/schemas/Recognizer.schema) includes `$role:"union(IRecognizer)"` which extends the `IRecognizer` definition when merged.
+- [Recognizer.schema](test/schemas/Recognizer.schema) includes `$role:"implements(IRecognizer)"` which extends the `IRecognizer` definition when merged.
 - [root.schema](test/schemas/root.schema) is a schema file that includes `$kind:"IRecognizer"` in order to make use of the `IRecognizer` place holder.
 - [app.schema](test/examples/app.schema) was created by this tool shows how all of these definitions are merged together. In particular if you look at `IRecognizer` you will see the definition that includes a string, or the complete definition of `Recognizer`.
 

packages/dialog/src/commands/dialog/readme.md

@@ -47,7 +47,7 @@
             "title": "$role",
             "description": "Defines the role played in the dialog schema [expression|union|union(Kind)].",
             "type": "string",
-            "pattern": "^((expression)|(union)|(union\\([a-zA-Z][a-zA-Z0-9.]*\\)))$"
+            "pattern": "^((expression)|(interface)|(implements\\([a-zA-Z][a-zA-Z0-9.]*\\)))$"
         },
         "id": {
             "title": "$id",
@@ -104,6 +104,10 @@
             "type": "boolean",
             "default": false
         },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
         "examples": {
             "type": "array",
             "items": true

packages/dialog/src/library/array.md

@@ -30,16 +30,16 @@ export class SchemaTracker {
             added = true
             if (schemaObject.oneOf) {
                 const defRef = '#/definitions/'
-                const unionRole = 'union('
+                const implementsRole = 'implements('
                 let processRole = (role: string, type: Type) => {
-                    if (role.startsWith(unionRole)) {
-                        role = role.substring(unionRole.length, role.length - 1)
-                        let union = this.typeToType.get(role)
-                        if (!union) {
-                            union = new Type(role)
-                            this.typeToType.set(role, union)
+                    if (role.startsWith(implementsRole)) {
+                        role = role.substring(implementsRole.length, role.length - 1)
+                        let interfaceDefinition = this.typeToType.get(role)
+                        if (!interfaceDefinition) {
+                            interfaceDefinition = new Type(role)
+                            this.typeToType.set(role, interfaceDefinition)
                         }
-                        union.addImplementation(type)
+                        interfaceDefinition.addImplementation(type)
                     }
                 }
                 for (let one of schemaObject.oneOf) {
@@ -134,25 +134,25 @@ export class Type {
     // Paths to lg properties for concrete types.
     lgProperties: string[]
 
-    // Possible types for a union type.
+    // Possible types for an interface type.
     implementations: Type[]
 
-    // Union types this type is part of.
-    unions: Type[]
+    // Interface types this type implements.
+    interfaces: Type[]
 
     constructor(name: string, schema?: any) {
         this.name = name
         this.lgProperties = []
         this.implementations = []
-        this.unions = []
+        this.interfaces = []
         if (schema) {
             this.walkProps(schema, name)
         }
     }
 
     addImplementation(type: Type) {
         this.implementations.push(type)
-        type.unions.push(this)
+        type.interfaces.push(this)
     }
 
     toString(): string {

packages/dialog/src/library/component.schema

@@ -30,10 +30,10 @@
         "INothing": {
             "title": "Microsoft Nothing",
             "description": "Definition of a union type with no implementations.",
-            "$role": "union"
+            "$role": "interface"
         },
         "IRecognizer": {
-            "$role": "union",
+            "$role": "interface",
             "oneOf": [
                 {
                     "title": "Recognizer",
@@ -48,7 +48,7 @@
             ]
         },
         "Recognizer": {
-            "$role": "union(IRecognizer)",
+            "$role": "implements(IRecognizer)",
             "properties": {
                 "$kind": {
                     "title": "$kind",
@@ -116,7 +116,7 @@
             ]
         },
         "RecognizerTypeMismatch": {
-            "$role": "union(IRecognizer)",
+            "$role": "implements(IRecognizer)",
             "type": "object",
             "properties": {
                 "$kind": {

packages/dialog/src/library/schemaTracker.ts

@@ -2,5 +2,5 @@
     "$schema": "https://raw.githubusercontent.com/microsoft/botbuilder-dotnet/master/schemas/component.schema",
     "title": "Microsoft Nothing",
     "description": "Definition of a union type with no implementations.",
-    "$role":"union"
+    "$role":"interface"
 }

packages/dialog/test/commands/dialog/examples/app.schema

@@ -1,4 +1,4 @@
 {
     "$schema": "https://raw.githubusercontent.com/microsoft/botbuilder-dotnet/master/schemas/component.schema",
-    "$role": "union"
+    "$role": "interface"
 }

packages/dialog/test/commands/dialog/schemas/INothing.schema

@@ -1,6 +1,6 @@
 {
     "$schema": "https://raw.githubusercontent.com/microsoft/botbuilder-dotnet/master/schemas/component.schema",
-    "$role": "union(IRecognizer)",
+    "$role": "implements(IRecognizer)",
     "properties": {
         "req": {
             "$role": "expression"