Follow nuget package references. (#755)

* Bump version (#746)

* Bump version

* Update botframework-cli-mac.yml

* update package.json (#750)

* Adding Dialog to CLI core

* Follow nuget package references.
Fix some typos.

* Remove readme changes.

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

Author: 3 people

.vscode/launch.json

@@ -16,7 +16,7 @@
             ],
             "args": [
                 "luis:build",
-                "--luConfig", 
+                "--luConfig",
                 "${env:TEMP}/sandwich.out/luconfig.json"
             ],
             "internalConsoleOptions": "openOnSessionStart",
@@ -183,7 +183,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Dialog merge test schema",
+            "name": "Bot Builder merge test schema",
             "preLaunchTask": "${defaultBuildTask}",
             "program": "${workspaceFolder}/packages/dialog/bin/run",
             "outputCapture": "std",
@@ -200,6 +200,26 @@
             "internalConsoleOptions": "openOnSessionStart",
             "cwd": "${workspaceFolder}/packages/dialog/test/commands/dialog"
         },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Runbot schema",
+            "preLaunchTask": "${defaultBuildTask}",
+            "program": "${workspaceFolder}/packages/dialog/bin/run",
+            "outputCapture": "std",
+            "outFiles": [
+                "./packages/dialog/lib/**"
+            ],
+            "args": [
+                "dialog:merge",
+                "runbot.csproj",
+                "-o",
+                "runbot.schema",
+                "--verbose"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "cwd": "${workspaceFolder}/../botbuilder-samples/experimental/generation/runbot/"
+        },
         {
             "type": "node",
             "request": "launch",
@@ -213,10 +233,10 @@
             ],
             "args": [
                 "luis:build",
-                "--in",
-                ".",
                 "--luConfig",
-                "luconfig.json"
+                "luconfig.json",
+                "--authoringKey",
+                "${env:LUIS_AUTHORING_KEY}"
             ],
             "internalConsoleOptions": "openOnSessionStart",
             "cwd": "${env:TEMP}/sandwich.out"

packages/dialog/src/library/schemaMerger.ts

@@ -61,6 +61,7 @@ export default class SchemaMerger {
 
     // State tracking
     private readonly projects = {}
+    private nugetRoot = ''
     private readonly validator = new Validator()
     private metaSchemaId = ''
     private metaSchema: any
@@ -295,7 +296,78 @@ export default class SchemaMerger {
         return ppath.normalize(path)
     }
 
-    // Expand .csproj packages and projects
+    // Expand nuget package and all of its dependencies
+    async expandNuget(packageName: string, minVersion: string, root: boolean): Promise<string[]> {
+        let packages: string[] = []
+        let pkgPath = ppath.join(this.nugetRoot, packageName)
+        if (!this.projects[pkgPath] && !packageName.startsWith('System')) {
+            let oldFile = this.currentFile
+            try {
+                this.currentFile = pkgPath
+                this.projects[pkgPath] = true
+                let versions: string[] = []
+                if (await fs.pathExists(pkgPath)) {
+                    for (let pkgVersion of await fs.readdir(pkgPath)) {
+                        versions.push(pkgVersion.toLowerCase())
+                    }
+                    minVersion = minVersion || '0.0.0'
+                    // NOTE: The semver package does not handle more complex nuget range revisions
+                    // We get an exception and will ignore those dependencies.
+                    let version = semver.minSatisfying(versions, minVersion)
+                    pkgPath = this.normalize(ppath.join(pkgPath, version || ''))
+                    this.currentFile = pkgPath
+                    packages.push(pkgPath)
+                    if (this.verbose) {
+                        this.log(`  Following nuget ${this.prettyPath(pkgPath)}`)
+                    }
+                    let nuspecPath = ppath.join(pkgPath, `${packageName}.nuspec`)
+                    if (await fs.pathExists(nuspecPath)) {
+                        let nuspec = await this.xmlToJSON(nuspecPath)
+                        let dependencies: any[] = []
+                        walkJSON(nuspec, val => {
+                            if (val.dependencies) {
+                                // NOTE: We assume first framework with dependencies has schema files.
+                                for (let groups of val.dependencies) {
+                                    if (groups.dependency) {
+                                        // Direct dependencies
+                                        for (let dependency of groups.dependency) {
+                                            dependencies.push(dependency.$)
+                                        }
+                                        break
+                                    } else {
+                                        // Grouped dependencies
+                                        for (let group of groups.group) {
+                                            if (group.dependency) {
+                                                for (let dependency of group.dependency) {
+                                                    dependencies.push(dependency.$)
+                                                }
+                                                break
+                                            }
+                                        }
+                                    }
+                                }
+                                return true
+                            }
+                            return false
+                        })
+                        for (let dependent of dependencies) {
+                            let dependentPackages = await this.expandNuget(dependent.id, dependent.version, false)
+                            packages = [...packages, ...dependentPackages]
+                        }
+                    }
+                } else if (root) {
+                    this.parsingError('  Nuget package does not exist')
+                }
+            } catch (e) {
+                this.parsingWarning(e.message)
+            } finally {
+                this.currentFile = oldFile
+            }
+        }
+        return packages
+    }
+
+    // Expand .csproj packages, nugets and projects
     async expandCSProj(path: string): Promise<string[]> {
         let references: string[] = []
         if (!this.projects[path]) {
@@ -306,41 +378,30 @@ export default class SchemaMerger {
             }
             references.push(this.normalize(ppath.join(ppath.dirname(path), '/**/*.schema')))
             let json = await this.xmlToJSON(path)
-            let packages = await this.findGlobalNuget()
-            if (packages) {
+            await this.findGlobalNuget()
+            if (this.nugetRoot !== '') {
+                let nugetPackages: any[] = []
                 walkJSON(json, elt => {
                     if (elt.PackageReference) {
                         for (let pkgRef of elt.PackageReference) {
-                            let pkg = pkgRef.$
-                            let pkgName = pkg.Include
-                            let pkgPath = ppath.join(packages, pkgName)
-                            let versions: string[] = []
-                            if (fs.pathExistsSync(pkgPath)) {
-                                for (let version of fs.readdirSync(pkgPath)) {
-                                    versions.push(version.toLowerCase())
-                                }
-                                let baseVersion = pkg.Version || '0.0.0'
-                                let version = semver.minSatisfying(versions, `>=${baseVersion.toLowerCase()}`)
-                                pkgPath = this.normalize(ppath.join(pkgPath, version || '', '**/*.schema'))
-                                references.push(pkgPath)
-                                if (this.verbose) {
-                                    this.log(`  Following nuget ${this.prettyPath(pkgPath)}`)
-                                }
-                            } else {
-                                this.parsingError(`Nuget package does not exist ${pkgPath}`)
-                            }
+                            nugetPackages.push(pkgRef.$)
                         }
                         return true
                     }
                     return false
                 })
+                for (let pkg of nugetPackages) {
+                    let nugetReferences = await this.expandNuget(pkg.Include, pkg.Version, true)
+                    for (let nuget of nugetReferences) {
+                        references.push(this.normalize(ppath.join(nuget, '**/*.schema')))
+                    }
+                }
             }
             let projects: string[] = []
             walkJSON(json, elt => {
                 if (elt.ProjectReference) {
                     for (let ref of elt.ProjectReference) {
-                        let project = ref.$
-                        let projectPath = this.normalize(ppath.join(ppath.dirname(path), project.Include))
+                        let projectPath = this.normalize(ppath.join(ppath.dirname(path), ref.$.Include))
                         projects.push(projectPath)
                     }
                     return true
@@ -419,19 +480,20 @@ export default class SchemaMerger {
     }
 
     // Find the global nuget repository
-    async findGlobalNuget(): Promise<string> {
-        let result = ''
-        try {
-            const {stdout} = await exec('dotnet nuget locals global-packages --list')
-            const name = 'global-packages:'
-            let start = stdout.indexOf(name)
-            if (start > -1) {
-                result = stdout.substring(start + name.length).trim()
-            }
-        } catch {
-            this.parsingError('Cannot find global nuget packages')
+    async findGlobalNuget(): Promise<void> {
+        if (!this.nugetRoot) {
+            this.nugetRoot = ''
+            try {
+                const {stdout} = await exec('dotnet nuget locals global-packages --list')
+                const name = 'global-packages:'
+                let start = stdout.indexOf(name)
+                if (start > -1) {
+                    this.nugetRoot = stdout.substring(start + name.length).trim()
+                }
+            } catch {
+                this.parsingError('Cannot find global nuget packages')
+            }
         }
-        return result
     }
 
     // Convert XML to JSON

packages/qnamaker/src/commands/qnamaker/build.ts

@@ -35,7 +35,7 @@ export default class QnamakerBuild extends Command {
     fallbackLocale: flags.string({description: 'Locale to be used at the fallback if no locale specific recognizer is found. Only valid if --dialog is set'}),
     suffix: flags.string({description: 'Environment name as a suffix identifier to include in qnamaker kb name. Defaults to current logged in user alias'}),
     dialog: flags.string({description: 'Write out .dialog files whose recognizer type [multiLanguage|crosstrained] is specified by --dialog', default: 'multiLanguage'}),
-    force: flags.boolean({char: 'f', description: 'If --dialog flag is provided, overwirtes relevant dialog file', default: false}),
+    force: flags.boolean({char: 'f', description: 'If --dialog flag is provided, overwrites relevant dialog file', default: false}),
     log: flags.boolean({description: 'write out log messages to console', default: false}),
   }