@sap/cds-dk 9.4.2 → 9.5.0

package/bin/util/containerize.js

@@ -0,0 +1,183 @@
+const cds = require('../../lib/cds')
+const { path } = cds.utils
+const { join } = path
+const { execSync } = require('node:child_process')
+const { highlight, info } = require('../../lib/util/term')
+const { calcDirChecksum } = require('../../lib/util/checksum')
+
+const buildpacks = new Set([
+  'java', 'nodejs', 'sap-machine', 'executable-jar', 'spring-boot', 'syft'
+])
+const builders = new Set([
+  'builder-jammy-base', 'builder-jammy-buildpackless-base', 'builder-jammy-full', 'builder-jammy-buildpackless-full'
+])
+
+const keyProcessorMap = {
+  dockerfile: processDockerfile,
+  commands: processCommands,
+  buildpack: processBuildpack
+}
+
+const run = (cmd, { continueOnFail = false, silent = false } = {}) => {
+  cmd = Array.isArray(cmd) ? cmd.join(' ') : cmd
+  console.log(highlight(cmd))
+  try {
+    return execSync(cmd, {
+      stdio: silent ? 'pipe' : 'inherit',
+      env: { ...process.env, FORCE_COLOR: cds.utils.colors.enabled }
+    })
+  } catch (error) {
+    if (continueOnFail) {
+      if (!silent)
+        console.error(error.message)
+      return
+    }
+    throw error.message
+  }
+}
+
+function appendSubcommand(param, subcommand) {
+  if (!param) return []
+  if (subcommand === '--env') {
+    return Object.entries(param).flatMap(([k, v]) =>
+      String(v).split(',').map(env => [subcommand, `${k}=${env.trim() || '""'}`])
+    ).flat()
+  }
+  return param.split(',').map(e => [subcommand, e.trim()]).flat()
+}
+
+function processDockerfile(bp, name, tag) {
+  if (!bp.dockerfile) return []
+  return [['docker', 'build',
+    ...appendSubcommand(`${name}:${tag ?? 'latest'}`, '-t'),
+    ...appendSubcommand(bp.dockerfile, '-f'),
+    '.']]
+}
+
+function processCommands(bp) {
+  return bp.commands ? bp.commands.map(c => c.trim().split(' ')) : []
+}
+function processBuildpack(bp, name, tag, clearCache = false) {
+  let { type, path, env, builder } = bp.buildpack
+  type = type ? type.split(',').map(t => buildpacks.has(t.trim()) ? `paketo-buildpacks/${t.trim()}` : t.trim()) : []
+  if (builders.has(builder)) builder = `paketobuildpacks/${builder}`
+  const cacheArgs = clearCache ? ['--clear-cache'] : []
+  return [['pack',
+    ...appendSubcommand(`${name}:${tag}`, 'build'),
+    ...appendSubcommand(path, '--path'),
+    ...type.flatMap(t => appendSubcommand(t, '--buildpack')),
+    ...appendSubcommand(builder, '--builder'),
+    ...appendSubcommand(env, '--env'),
+    ...cacheArgs
+  ]]
+}
+
+/**
+ * Parses a YAML configuration file to extract Docker build and push commands for modules.
+ *
+ * @param {string} filename - The path to the YAML file to parse.
+ * @param {string} [repoOpt=''] - Optional repository override. If not provided, uses the repository defined in the YAML file.
+ * @param {boolean} [clearCache=false] - Whether to clear cache for buildpack builds.
+ * @returns {Promise<{
+ *   commands: Array<{
+ *     name: string,
+ *     tag: string,
+ *     buildCmd: Array<string>,
+ *     tagCmd: Array<string>,
+ *     pushCmd: Array<string>,
+ *     image: string,
+ *     checksum: string|null
+ *     path: string
+ *   }>,
+ *   before_all: Array<Array<string>>,
+ *   repository: string
+ * }>} An object containing the commands for each module, any global pre-commands, and the repository name.
+ * @throws {Error} If modules are not defined in the YAML file or if build-parameters are invalid.
+ */
+async function parseYAML(filename, repoOpt = '', options) {
+  const file = cds.load.yaml(join(cds.root, filename))
+  const { repository: repoFile, modules, tag: globalTag = 'latest' } = file
+  const repository = repoOpt || repoFile
+  const before_all = file['before-all'] ? file['before-all'].map(c => c.trim().split(' ')) : []
+  if (!modules) throw `no modules defined in ${filename}`
+  const commands = await Promise.all(modules.map(async (m) => {
+    const name = m.name, tag = m.tag || globalTag, bp = m['build-parameters']
+    const rawImg = `${repository}/${name}`, source = `${name}:${tag}`, repoImg = `${repository}/${source}`
+    const key = Object.keys(bp)[0]
+    let checksum = null
+    if (bp.buildpack?.path)
+      checksum = await calcDirChecksum(
+        join(cds.root, bp.buildpack.path),
+        (dir) => !dir.includes('node_modules'),
+        'sha256',
+        [
+          join(cds.root, filename),
+          join(cds.root, 'package.json')
+        ]
+      )
+    const buildType = keyProcessorMap[key]
+
+    if (!buildType) throw `'build-parameters' ${Object.keys(bp)} in ${filename} is invalid`
+    return {
+      name,
+      tag,
+      buildCmd: buildType(bp, name, tag, key === 'buildpack' && options.clearCache),
+      tagCmd: [['docker', 'tag', source, repoImg]].concat(checksum ? [['docker', 'tag', source, `${rawImg}:${checksum}`]] : []),
+      pushCmd: ['docker', 'push', repoImg],
+      image: rawImg,
+      checksum,
+      path: bp.buildpack?.path
+    }
+  }))
+  return { commands, before_all, repository }
+}
+
+/**
+ * Executes the containerization commands for each module.
+ * @param {*} modules - The list of modules with their respective build, tag, and push commands.
+ * @param {*} options - Options object, e.g., { push: true } to push images after building.
+ */
+async function executeModules(modules, options) {
+  for (const m of modules) {
+    if (m.checksum) {
+      try {
+        run(`docker inspect --format='{{index .RepoTags 0}}' ${m.image}:${m.checksum}`, { silent: true })
+        console.log(info(`image ${m.image}:${m.checksum} already exists – skipping build and push`))
+        continue
+      } catch (error) {
+        // ignore
+      }
+    }
+
+    for (const cmd of m.buildCmd) run(cmd)
+    if (options.push) {
+      for (const cmd of m.tagCmd) run(cmd)
+      run(m.pushCmd)
+    }
+  }
+}
+
+/**
+ * Main function to containerize modules based on a YAML configuration file.
+ * @param {string} filename - The path to the YAML configuration file.
+ * @param {{ push: boolean, clearCache: boolean }} options - Options object, e.g., { push: true } to push images after building.
+ * @returns {Promise<Array<{
+ *    name: string,
+ *    tag: string,
+ *    buildCmd: Array<string>,
+ *    tagCmd: Array<string>,
+ *    pushCmd: Array<string>,
+ *    image: string,
+ *    checksum: string|null
+ *    path: string
+ * }>} - The list of modules that were containerized.
+ */
+async function containerize(filename = 'containerize.yaml', options = { clearCache: !!process.env.CLEAR_CACHE, push: true }) {
+  const { repository, before_all, commands: modules } = await parseYAML(filename, '', options)
+  if (!repository || !modules) return
+  for (const cmd of before_all) run(cmd)
+  await executeModules(modules, options)
+  return modules
+}
+
+module.exports = { containerize }

package/bin/version.js

@@ -52,7 +52,7 @@ function list_versions (args, options) {
 
   process.stdout.isTTY && console.log()
   if (options.markdown || options.info) {
-    _markdown (versions)
+    _markdown (versions, options)
   } else {
     const mark = !colors ? s => s : require('../lib/util/term').info
     for (let each of Object.keys(versions))  console.log(`${mark(each)}: ${versions[each]}`)
@@ -81,7 +81,7 @@ function info({ root: cwd = process.cwd() }) {
 
   // Sort entries, with @sap/cds packages on top, followed by @cap-js packages
   const keys = Object.keys(versions).sort(), sorted={}
-  for (let k of ['@sap/cds','@sap/cds-dk']) if (!(k in sorted)) sorted[k] = versions[k]
+  for (let k of ['@sap/cds']) if (!(k in sorted)) sorted[k] = versions[k]
   for (let k of keys) if (!(k in sorted) && k.startsWith('@sap/cds')) sorted[k] = versions[k]
   for (let k of keys) if (!(k in sorted) && k.startsWith('@cap-js')) sorted[k] = versions[k]
   for (let k of keys) if (!(k in sorted)) sorted[k] = versions[k]
@@ -115,9 +115,9 @@ function _versions_from(pkg_path, pkg_label) {
   return versions
 }
 
-function _markdown (versions) {
+function _markdown (versions, { root: cwd = process.cwd() }) {
   const pkg = { name:'', repository:'', version:'' }; try {
-    Object.assign (pkg, require (resolve('package.json')))
+    Object.assign (pkg, require (require.resolve('./package.json', { paths:[cwd] })))
   } catch (e) {/* ignored */}
   const repo = pkg.repository.url || pkg.repository || 'https://github.com/<your/repo>'
   const valLength = Math.max(repo.length, versions.home.length)

package/lib/bind/k8s.js

@@ -32,7 +32,7 @@ module.exports = new class K8SBind extends require('./plugin') {
 
   services4(app) {
     const { execSync } = require('node:child_process')
-    const json = cmd => JSON.parse(execSync(cmd, { encoding: 'utf8' }))
+    const json = cmd => JSON.parse(execSync(cmd, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }))
 
     const bindings = json('kubectl get servicebindings -o json').items
       .filter(b => b.metadata.name.startsWith(app))

package/lib/build/buildTaskEngine.js

@@ -179,7 +179,7 @@ class BuildTaskEngine {
 
     /** @private */
     _resolveHandlerResponse(results, pluginMessages = []) {
-        /** @type {BuildError[]}*/
+        /** @type {(BuildError | Error)[]}*/
         const errors = []
         const resolvedResults = results.reduce((acc, r) => {
             if (r.status === 'fulfilled') {
@@ -195,7 +195,10 @@ class BuildTaskEngine {
             const error = errors.find(e => e.constructor.name !== COMPILATION_ERROR)
             if (error) {
                 // throw original BuildError including existing BuildMessages
-                error.messages = error.messages.map(m => typeof m === 'string' ? new BuildMessage(m, SEVERITY_ERROR) : m)
+                if (!(error instanceof BuildError)) {
+                    throw error
+                }
+                error.messages = error.messages?.map(m => typeof m === 'string' ? new BuildMessage(m, SEVERITY_ERROR) : m)
                 error.messages = this._sortMessagesUnique(pluginMessages.filter(m => m instanceof BuildMessage), error.messages)
                 throw error
             }

package/lib/build/plugin.js

@@ -126,7 +126,7 @@ class Plugin {
      * @abstract
      * Called by the framework to create the artifacts of this build plugin.
      */
-    async build() { /* abstract */}
+    async build() { /* abstract */ }
 
     /**
      * Called by the framework immediately before 'build' to delete any output created by this build plugin.

package/lib/build/plugins/helm/files/templates/_deployment_helpers.tpl

@@ -23,7 +23,7 @@ copied from web-application: web-application.fullname
 */}}
 {{- define "cap.deploymentHost" -}}
 {{- if .deployment.expose.host }}
-{{- .deployment.expose.host }}
+{{- tpl .deployment.expose.host . }}
 {{- else }}
 {{- $name := (include "cap.web-application.fullname" .) }}
 {{- if hasPrefix $name .Release.Namespace }}

package/lib/build/plugins/helm/index.js

@@ -1,6 +1,5 @@
 const cds = require('../../../cds')
-const yaml = require('yaml')
-const { exists, path, readFileSync } = cds.utils
+const { exists, path, readFileSync, yaml } = cds.utils
 const { Plugin, BuildError } = require('../..')
 const { join } = path
 const { readProject } = require('../../../init/projectReader')
@@ -11,7 +10,7 @@ module.exports = class HelmBuildPlugin extends Plugin {
   static hasTask() {
     if (exists('chart/Chart.yaml')) {
       const chartFile = readFileSync(join(cds.root, 'chart', 'Chart.yaml'), 'utf8')
-      const chartYaml = yaml.parseDocument(chartFile).toJS()
+      const chartYaml = yaml.parse(chartFile)
       return chartYaml.annotations?.["app.kubernetes.io/managed-by"] === 'cds-dk/helm'
     }
     return false
@@ -27,15 +26,16 @@ module.exports = class HelmBuildPlugin extends Plugin {
   }
 
   async build() {
-    if(!HelmBuildPlugin.hasTask()) {
-      this.pushMessage("Helm Chart not found. Execute `cds add helm` to add the helm chart.", Plugin.WARNING)
+    if (!HelmBuildPlugin.hasTask()) {
+      this.pushMessage("Helm Chart not found. Execute `cds add kyma` to add the helm chart.", Plugin.WARNING)
       return
     }
 
-    const { hasApprouter, hasConnectivity, hasHtml5Repo } = readProject()
+    const project = readProject()
+    const { hasApprouter, hasConnectivity, hasHtml5Repo } = project
 
     const chartFile = readFileSync(join(cds.root, 'chart', 'Chart.yaml'), 'utf8')
-    const chartYaml = yaml.parseDocument(chartFile).toJS()
+    const chartYaml = yaml.parse(chartFile)
     const isInternal = chartYaml.dependencies?.find(dep => dep.name === 'web-application')?.repository !== undefined
 
     if (!isInternal) {

package/lib/build/provider/hana/2migration.js

@@ -48,31 +48,23 @@ function _compileToHana(model, options, beforeImage) {
     let migrations = []
     let afterImage
 
-    if (cds.compile.to.hana) {
-        const result = cds.compile.to.hana(model, options, beforeImage);
-
-        for (const [content, { file }] of result) {
-            switch (file) {
-                case 'deletions.json':
-                    break
-                case 'migrations.json':
-                    migrations = content
-                    break
-                case 'afterImage.json':
-                    afterImage = content
-                    break
-                default: {
-                    const { name, ext: suffix } = path.parse(file)
-                    definitions.push({ name, suffix, sql: content })
-                }
+    const result = cds.compile.to.hana(model, options, beforeImage);
+
+    for (const [content, { file }] of result) {
+        switch (file) {
+            case 'deletions.json':
+                break
+            case 'migrations.json':
+                migrations = content
+                break
+            case 'afterImage.json':
+                afterImage = content
+                break
+            default: {
+                const { name, ext: suffix } = path.parse(file)
+                definitions.push({ name, suffix, sql: content })
             }
         }
-    } else {
-        // compatibility with cds < 8.0.0
-        const result = cdsc.to.hdi.migration(cds.minify(model), options, beforeImage)
-        definitions = result.definitions
-        migrations = result.migrations
-        afterImage = result.afterImage
     }
     let migrationTableNames = new Set()
     if (afterImage) {
@@ -97,7 +89,7 @@ function _compileToHana(model, options, beforeImage) {
  * @param {String} srcPath Fully qualified path of the directory containing .hdbmigrationtable files
  * @param {String} migration the migration descriptor
  * @param {String} tableSql SQL TABLE definition
- * @returns {Object} Providing access to 'content' and 'fileName'.
+ * @returns {Promise<Object>} Providing access to 'content' and 'fileName'.
  */
 async function _2migrationtable(srcPath, migration, tableSql) {
     let migrationTableModel = null

package/lib/build/provider/hana/index.js

@@ -21,6 +21,10 @@ const FILE_NAME_UNDEPLOY_JSON = "undeploy.json"
 const DEPLOY_FORMAT = "deploy-format"
 const DEBUG = cds.debug('cli|build')
 
+// Some HDI artifacts do not require explicit plugin specification in _.hdiconfig_.
+// This list contains exceptions which will be ignored during the consistency check.
+const PLUGINLESS_HDB_FILES = new Set([".hdbgrants", ".hdbrevokes"])
+
 class HanaBuildPlugin extends InternalBuildPlugin {
     init() {
         if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
@@ -473,8 +477,12 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             }
         }
         if (Object.keys(content['file_suffixes']).length < hdiPlugins.size) {
-            const missingPlugins = Array.from(hdiPlugins).filter(key => !content['file_suffixes'][key.slice(1)])
-            this.pushMessage(`'HANA database plugin not found for following file suffix [${missingPlugins.join(', ')}]`)
+            const missingPlugins = Array.from(hdiPlugins)
+                .filter(key => !content['file_suffixes'][key.slice(1)])
+                .filter(key => !PLUGINLESS_HDB_FILES.has(key))
+            if (missingPlugins.length) {
+                this.pushMessage(`'HANA database plugin not found for following file suffix [${missingPlugins.join(', ')}]`)
+            }
         }
         await this.write(content).to(hdiConfigPath)
     }
@@ -578,7 +586,7 @@ class HanaBuildPlugin extends InternalBuildPlugin {
     /**
      * Returns all hana native artifacts located in db/src/** workspace folders.
      * @param {Array} workspacePaths Array of workspace paths, 'cds.root' is excluded from the list
-     * @returns {Array} Array of workspace files, each entry contains the db src directory,
+     * @returns {Promise<Array>} Array of workspace files, each entry contains the db src directory,
      * the relative file path and the file name.
      */
     async _getWorkspaceFiles(workspacePaths) {

package/lib/build/provider/hana/template/.hdiconfig-all

@@ -167,6 +167,12 @@
         },
         "hdbschedulerjob" : {
             "plugin_name" : "com.sap.hana.di.schedulerjob"
+        },
+        "hdblogicalschema" : { 
+           "plugin_name" : "com.sap.hana.di.logicalschema"
+        }, 
+        "hdblogicalschemaconfig" : { 
+           "plugin_name" : "com.sap.hana.di.logicalschema.config" 
         }
     }
-}
+}

package/lib/build/provider/hana/template/package.json

@@ -1,7 +1,7 @@
 {
   "name": "deploy",
   "dependencies": {
-    "hdb": "^0",
+    "hdb": "^2.0.0",
     "@sap/hdi-deploy": "^5"
   },
   "engines": {

package/lib/build/provider/internalBuildPlugin.js

@@ -4,6 +4,7 @@ const cds = require('../../cds')
 const Plugin = require('../plugin')
 const { hasOptionValue, getFiles } = require('../util')
 const { FOLDER_GEN, DEFAULT_BUILTIN_PRIORITY_MAX } = require('../constants')
+const TRACE = cds.debug('trace')
 
 class InternalBuildPlugin extends Plugin {
     /**
@@ -116,7 +117,7 @@ class InternalBuildPlugin extends Plugin {
             cwd: cds.root,
             src: this.hasBuildOption('flatDeployLayout', true) || this.task.src === this.task.dest ? this.task.src : cds.root
         }
-        const csnStr = cds.compile.to.json(model, jsonOptions)
+        const csnStr = cds_compile_to_json(model, jsonOptions)
         await this.write(csnStr).to(csnFile)
         return csnStr
     }
@@ -156,4 +157,17 @@ class InternalBuildPlugin extends Plugin {
         return null
     }
 }
+
+// Emits the 'compile.for.runtime' event, as the produced CSN is for runtime usage.
+// Plugins use it to modify the CSN before it is stringified.
+function cds_compile_to_json (csn,o) {
+  TRACE?.time('cds.compile 2json'.padEnd(22)); try {
+    let result, next = ()=> result ??= cds.compile.to.json (csn,o)
+    cds.emit ('compile.for.runtime', csn, o, next)
+    return next() //> in case no handler called next
+  }
+  finally { TRACE?.timeEnd('cds.compile 2json'.padEnd(22)) }
+}
+
+
 module.exports = InternalBuildPlugin

package/lib/build/provider/java/index.js

@@ -7,6 +7,7 @@ const { OUTPUT_MODE, OUTPUT_MODE_RESULT, FILE_EXT_CDS, CONTENT_LANGUAGE_BUNDLES,
 const { getI18nDefaultFolder } = require('../../util')
 const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
 const DEBUG = cds.debug('cli|build')
+const LOG = cds.log('cli|build')
 
 class JavaBuildPlugin extends EdmxBuildPlugin {
     init() {
@@ -25,7 +26,17 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
 
         if (!this.hasBuildOption(CONTENT_EDMX, false)) {
             // generate edmx files containing all features - localized edmx for backward compatibility
-            if (this.hasBuildOption(CONTENT_LOCALIZED_EDMX, true)) {
+            let localized = this.hasBuildOption(CONTENT_LOCALIZED_EDMX, true)
+
+            // Force localized to true for OData v2
+            if (cds.env.odata.version === 'v2') {
+                if (!localized) {
+                    LOG.info('Forcing localized EDMX generation for OData v2')
+                    localized = true
+                }
+            }
+
+            if (localized) {
                 await this.compileToEdmx(model, compileDest, { [FLAVOR_LOCALIZED_EDMX]: true })
             }
             // non-localized edmx

package/lib/build/provider/mtx-sidecar/index.js

@@ -86,7 +86,8 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             return
         }
         const { dictionary, sources } = await this.compileAll(model, destMainSrv, destMain)
-        await this.collectAllLanguageBundles(dictionary, sources, destMainSrv, destMain)
+        // await this.collectAllLanguageBundles(dictionary, sources, destMainSrv, destMain)
+        await this.collectAllLanguageBundles(dictionary, sources, destMain, destMain)
 
         if (!this.hasBuildOption(CONTENT_EDMX, false)) {
             //inferred model expected by cds.compile.to.edmx()

package/lib/build/provider/nodejs/index.js

@@ -53,7 +53,8 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         if (model) {
             const { dictionary, sources } = await this.compileAll(model, destSrv, destRoot)
             // collect and write language bundles into single i18n.json file
-            await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
+            await this.collectAllLanguageBundles(dictionary, sources, destRoot, destRoot)
+            // await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
 
             if (!this.hasBuildOption(CONTENT_EDMX, false)) {
                 const compileOptions = { [FLAVOR_LOCALIZED_EDMX]: this.hasBuildOption(FLAVOR_LOCALIZED_EDMX, true) }

package/lib/build/util.js

@@ -165,9 +165,9 @@ function flatten(modelPaths) {
 
 function getI18nDefaultFolder() {
     // keep '_i18n' as preferred folder for compatibility reasons
-    if (cds.env.i18n.folders.includes('_i18n')) return '_i18n'
-    if (cds.env.i18n.folders.includes('i18n')) return 'i18n'
-    return cds.env.i18n.folders[0] ?? 'i18n'
+    // if (cds.env.i18n.folders.includes('_i18n')) return '_i18n'
+    // if (cds.env.i18n.folders.includes('i18n')) return 'i18n'
+    return cds.env.i18n.folders?.[0] ?? '_i18n'
 }
 
 async function pathExists(path) {

package/lib/compile/to_openapi.js

@@ -1,8 +1,4 @@
 const cds = require('../cds')
-const { compile } = cds._local('@cap-js/openapi') // load a local cap-js/openapi (fallback to our own)
-
-function cds_compile_to_openapi (csn, options) {
-  return compile(csn, options)
-}
+const { compile: cds_compile_to_openapi } = cds._local('@cap-js/openapi') // load a local cap-js/openapi (fallback to our own)
 
 module.exports = cds_compile_to_openapi

package/lib/import/common.js

@@ -336,12 +336,12 @@ function _printUsageHint(dest, service, cwd) {
     dest = dest.replace(extension, '');
     let using
     if (service.length > 1){
-        using = `using { ${service.join(', ')}} from './${path.relative(cds.env.folders.srv, dest).replace(/\\/g, '/')}'`;
+        using = `using { ${service.join(', ')}} from './${path.relative(cds.env.folders.srv, dest).replace(/\\/g, '/')}';`;
     } else {
-        using = `using { ${service} as external } from './${path.relative(cds.env.folders.srv, dest).replace(/\\/g, '/')}'`;
+        using = `using { ${service} as external } from './${path.relative(cds.env.folders.srv, dest).replace(/\\/g, '/')}';`;
     }
     const message = `\n[cds] - imported API to ${path.relative(cwd, dest)}
-> use it in your CDS models through the like of:
+> use it in your CDS models through the likes of:
 
 ${require('../util/term').info(using)}
 `;
@@ -510,7 +510,8 @@ async function postProcess(filePath, options, csn, cwd) {
         usingStatements.push(`using from './${path.basename(csnFile.replace(`'`, `''`))}';`);
     }
 
-    _printUsageHint(csnFile, services, cwd);
+    if (!options.dry)
+        _printUsageHint(csnFile, services, cwd);
 
     if (!options.dry && !options.no_copy)
         await _copyToSrvExternal(filePath, destFilePath, cwd);

package/lib/import/message.js

@@ -12,7 +12,7 @@ const messages = {
 	FILE_MODIFIED: 'The file with the same name exists and is been modified. Use --force flag to forcefully overwrite the file.',
 	OUTPUT_FILE_MISMATCH: 'Specify the file extension that --as option supports.',
 	INVALID_AS_OPTION: 'For --as option, please specify one of these output file format [cds, csn, json].',
-	UNSUPPORTED_FROM_OPTION: 'For --from option, please specify one of these types [edmx, openapi, asyncapi, rfc]. Make sure the required importer plugin is installed.',
+	UNSUPPORTED_FROM_OPTION: `No importer is installed for type '{0}'. Known import kinds are: {1}. Make sure the required importer plugin is installed.`,
 	INCORRECT_EXTENSION: 'If --as option is not provided, then please provide either .json or .csn output file extension.',
 	INCORRECT_INPUT_NAMESPACES: 'Invalid value for --include-namespaces option. Specify namespaces as comma-separated list or "*"',
 	MISSING_ASSOCIATION: 'Association is missing in the input file provided. Please check the edmx file.',

package/lib/import/odata/ParserContext.js

@@ -38,6 +38,7 @@ module.exports = class ParserContext {
         this.schemaAliasToNamespace = {};
         this.schemaToSchemaDataIndex = {};
         this.schemaToPrimarySchema = {};
+        this.schemaDetails = {};
         this.vocabNamespaceToAlias = {};
         this.entityToBoundActions = {};
         this.entityToBoundFunctions = {};