@sap/cds-dk 4.9.5 → 6.0.1

package/bin/import.js

@@ -1,16 +1,18 @@
 
 module.exports = Object.assign(_import, {
     _name: 'import',
-    options: ['--out', '--into', '--as', '--include-namespaces'],
+    options: ['--out', '--as', '--include-namespaces', '--from'],
     flags: ['--dry', '--force', '--no-copy', '--no-save', '--keep-namespace'],
-    shortcuts: ['-o', '-in', '-as', '-ns', '-', '-f'],
+    shortcuts: ['-o', '-as', '-ns', undefined, '-', '-f'],
     help: `
 # SYNOPSIS
 
     *cds import* <source> [<options>]
 
     Imports the given source and converts it to CSN.
-    Currently only OData EDMX input is supported.
+    Currently following file formats are supported.
+    - EDMX and XML for OData V2 and V4
+    - JSON for OpenAPI
 
     Without any options the source is copied to ./srv/external and the csn
     output written next to it. Finally it will add an entry for the imported
@@ -25,13 +27,6 @@ module.exports = Object.assign(_import, {
     *--no-save*
         Skips updating ./package.json.
 
-    *--keep-namespace*
-        Keeps the original namespace from the edmx content instead of using
-        the filename by default.
-
-    *-in | --into* <filename>
-        Skips copying to ./srv/external and writes to the specified location.
-
     *-o | --out* <filename>
         Skips copying to ./srv/external and writes to the specified location.
 
@@ -39,194 +34,64 @@ module.exports = Object.assign(_import, {
         Writes the converted csn to stdout only.
 
     *-as | --as <output_file_format>*
-        Converts the input edmx or xml file into one of these supported formats "cds", "csn", "json"
+        Converts the input file into one of these supported formats "cds", "csn" or "json".
 
     *-f | --force*
         Forcefully overwrites the contents in the CDS file and updates the checksum
-        
+
+    *--from*
+        Imports the model from the one of the given options "edmx" or "openapi".
+
+    *Below options are valid for OData only*
+
+    *--keep-namespace*
+        Keeps the original namespace from the edmx content instead of using
+        the filename by default.
+
     *-ns | --include-namespaces <string_of_namespaces> or* "\x2A"
         Imports only entities matching to the given list of namespaces.
         For OData V2 attributes with the namespace "sap" & "m" are captured by default.
 
-       
+
 
 # EXAMPLES
 
     cds import ~/Downloads/API_BUSINESS_PARTNER.edmx
     cds import - ~/Downloads/API_BUSINESS_PARTNER.edmx
-    cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --as cds
+    cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --from edmx --as cds
     cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --include-namespaces "sap,c4c"
     cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --include-namespaces "\x2A"
+    cds import ~/Downloads/Petstore_OpenAPI.json
+    cds import ~/Downloads/Petstore_OpenAPI.json --from openapi
 
 `})
-const cds = require('@sap/cds/lib')
-const { fs, path, write, mkdirp, exists, read} = cds.utils
-const edm2csn = require('../lib/import')
 const messages = require('../lib/import/message').getMessages();
 const common = require('../lib/import/common');
-const cdsCompiler = require('../lib/compile').compile.to;
-const md5 = require('md5');
-let cwd;
-async function _import(file, { out, dry, into, as, 
-    'include-namespaces': include_namespaces,
-    'no-save': no_save,
-    'no-copy': no_copy,
-    'keep-namespace': keep_namespace,
-    force
-} = {}) {
-    if (!as) {
-        if (cds.env.import) as = cds.env.import.as;
-    }
-    if (!include_namespaces) {
-        if(cds.env.import) include_namespaces = cds.env.import.include_namespaces;
-    }
-    cwd = into || process.cwd();
-    if (as && !common.supportedFormats().includes(as)) 
-        throw new Error(messages.INVALID_AS_OPTION);
-    if (Array.isArray(file)) file = file[0]
-    if (!file) return this.help('import')
-    file = await edm2csn.isValidInputFile(path.resolve(cwd, file))
-    const external = path.resolve(cwd, 'srv/external')
-    const dst = path.join(external, path.basename(file))
-    if (!dry && !no_copy) file = await _copy_to_srv_external(file, dst)
-    const src = await edm2csn.getMetadataFromFile(file)
-    this.include_all_namespaces = false;
-    let namespaces = [];
-    if(include_namespaces) {
-        if(include_namespaces === "*") this.include_all_namespaces = true;
-        else if(typeof include_namespaces === 'string' && !include_namespaces.startsWith('-')) namespaces = include_namespaces.replace(/ /g, "").split(',');
-        else throw new Error(messages.INCORRECT_INPUT_NAMESPACES);
-    }
-    this.namespaces = namespaces;
-    let csn = await edm2csn.edmx2csn(src, !keep_namespace && file, this)
-    const service = _service_name_from(csn);
-    if (out) out = edm2csn.validateAndComputeOutputFilePath(out, as);
-    const result = await _getResult(csn, service, as, out || dst.replace(/\.[^.]+$/, ''), force);
-    const written = dry || await _write(result[0], result[1], result[2]);
-    const registered = dry || no_save || await _update_package_json(result[1].replace(/\.[^.]+$/, ''), service, this.oDataVersion);
-    if (dry) return console.log(result[0]);
-    return Promise.all([written, registered])
-}
-
-async function _generateChecksumValidate(dest, output, force) {
-    let fileExists = await exists(dest);
-
-    // force flag disabled and cds file already exists, then throw error
-    if (!force && fileExists) {
-        throw new Error(messages.FILE_MODIFIED);
-    }
-
-    const currentChecksum = md5(output);
-    let existingFileContent, existingFileContentWithoutChecksum;
-    let existingFileContentChecksum, existingChecksumValue;
-
-    if (fileExists) {
-        existingFileContent = await read(dest, "utf-8");
-        const checksumStartIndex = existingFileContent.indexOf(`/* checksum : `);
-        const checksumEndIndex = existingFileContent.indexOf(" */");
-
-        if (checksumStartIndex >= 0) {
-            existingFileContentWithoutChecksum = existingFileContent.substring(
-                checksumEndIndex + 4
-            );
-            existingChecksumValue = existingFileContent.substring(
-                checksumStartIndex + 14, checksumEndIndex
-            );
-            existingFileContentChecksum = md5(existingFileContentWithoutChecksum);
-        }
+const cdsImport = require('../lib/index');
+
+async function _import(file, options = {}) {
+    let csn = "";
+    let apiOptions = {};
+    // preprocess
+    let cwd = process.cwd();
+    if (Array.isArray(file)) file = file[0];
+    if (!file) return this.help('import');
+    //process options
+    await common.processOptions(options, apiOptions);
+    const [srcFilePath, destFilePath] = await common.preProcess(file, options, cwd);
+
+    // process - csn generation
+    // if --from option is given, call api directly accordingly
+    if (options.from) {
+        if (!cdsImport.import.from[options.from]) throw new Error(messages.INVALID_FROM_OPTION);
+        csn = await cdsImport.import.from[options.from](srcFilePath, apiOptions);
+    } else {
+        csn = await cdsImport.import(srcFilePath, apiOptions);
     }
 
-    // if force flag enbabled
-    if (force) {
-        // current and existing file content are same, and the existing
-        // checksum is not modified, then return the existing file content
-        if (currentChecksum == existingFileContentChecksum && 
-            currentChecksum == existingChecksumValue) {
-            return existingFileContent;
-        }
-    } 
-    /*
-     * 1. current and existing checksum are different.
-     * 2. checksum is missing in the existing file:
-     *     a. existing and current file content are same.
-     *     b. existing and current file content are different.
-     * 3. cds file doesn't exist.
-     * 4. checksum of the existing file is modified.
-     */
-    return "/* checksum : " + currentChecksum + " */\n" + output;
-}
-
-async function _getResult(output, service, as, dest, force) {
-    let using, message, extension;
-    as = (as === "cds") ? "cdl" : as;
-
-    if (!common.supportedFormats().includes(extension = dest.substring(dest.lastIndexOf(".") + 1))) {
-        // dest doesn't have any file extension, so get it
-        extension = common.getSuffix(as);
-    } 
-
-    dest = dest.replace('.' + extension, '');
-    using = `using { ${service} as external } from './${path.relative('srv', dest).replace(/\\/g, '/')}'`;
-    using = require('../lib/util/term').info(using);    
-    message = `[cds] - imported API to ${path.relative(cwd, dest)}
-> use it in your CDS models through the like of:
-
-${using}
-`;
-
-    dest += '.' + extension;
-
-    if (as && as != "csn" && as != "json") {
-        // cdsCompiler[as] will convert the csn output into various output formats
-        output = cdsCompiler[as](output);
-    }
-
-    switch(as) {
-        case "cdl":
-            output = await _generateChecksumValidate(dest, output, force);
-            break;
-        case undefined:
-        case "csn":
-        case "json":
-            output = JSON.stringify(output, null, '  ');
-            break;
-        default:
-            break;
-    }
+    //reads the file version 
+    options.inputFileVersion = apiOptions.inputFileVersion;
 
-    return [output, dest, message];
+    // postprocess
+    return await common.postProcess(destFilePath, options, csn, cwd);
 }
-
-async function _write(output, dest, message) {
-    await edm2csn.saveCSNModel(output, dest);
-    console.log(message);
-}
-
-async function _copy_to_srv_external(file, dst) {
-    const dstDir = path.dirname(dst), srcDir = path.dirname(file)
-    if (!file.startsWith(dstDir + path.sep)) {
-        await mkdirp(dstDir)
-        const copy_or_move = srcDir === cwd || srcDir == process.cwd() ? fs.renameSync : fs.copyFileSync
-        await copy_or_move(file, dst)
-        return dst
-    }
-    return file
-}
-
-function _service_name_from(csn) {
-    for (let each in csn.definitions) {
-        if (csn.definitions[each].kind === 'service') return each
-    }
-}
-
-async function _update_package_json(dest, service, version) {
-    const package_json = path.resolve(cwd, 'package.json')
-    const conf = await exists(package_json) ? require(package_json) : {}
-    const requires = ['cds', 'requires'].reduce((p, n) => p[n] || (p[n] = {}), conf)
-    if (!requires[service]) {
-        const model = path.relative(cwd, dest)
-        cds.env.requires[service] = requires[service] = { kind: (version === "V2") ? 'odata-v2' : 'odata', model }
-        await write(package_json, JSON.stringify(conf, null, '  '))
-        console.log(`[cds] - updated ./package.json`)
-    }
-}

package/bin/repl.js

@@ -22,7 +22,7 @@ function repl (_, options={}) {
     )
   }
 
-  const cds = require('@sap/cds/lib')
+  const cds = require('../lib/cds')
   const path = require('path')
   const {inspect} = require('util')
 

package/bin/watch.js

@@ -106,9 +106,10 @@ async function watch ([cwd], {
   log (`watching: ${ext}...`)
   if (liveReload) log (`live reload enabled for browsers`)
 
-  const bindingManager = new require('../lib/bind/bindingResolver').bindingManager({cwd})
-  const bindings = await bindingManager.resolve()
-  if (bindings) env = {...env, 'CDS_REQUIRES': JSON.stringify(bindings.requires)}
+  const BindingManager = require('../lib/bind/BindingManager')
+  const bindingManager = new BindingManager({cwd})
+  const bindingEnv = await bindingManager.bindingEnv()
+  if (bindingEnv) env = {...env, ...bindingEnv}
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
@@ -123,16 +124,14 @@ async function watch ([cwd], {
     this.delayed = setTimeout(()=>{
       bindingManager.update({
         onBeforeUpdate: () => watcher.stop(),
-        onAfterUpdate: bindings => {
-          watcher.setEnv('CDS_REQUIRES', bindings && JSON.stringify(bindings.requires))
+        onAfterUpdate: ({env}) => {
+          Object.keys(env).forEach( name => watcher.setEnv(name, env[name]) )
           watcher.restart()
         }
       })
-      log (`${t.bold}        _______________________\n`)
+      log (`\n${t.bold}        ___________________________\n\n`)
       FileHandlers.changed (files,cwd)
     }, 111)
-  }).on('quit', ()=>{
-    log (`${t.bold+t.green}\n[cds] - my watch has ended.\n`)
   }).on('message', async (msg) => { switch (msg.code) { // messages from child process
     case 'listening':
       env.PORT = (msg.address && msg.address.port) || msg.port
@@ -144,6 +143,7 @@ async function watch ([cwd], {
     default: console.error (msg)
   }})
 
+  process.on('exit', ()=> log (`${t.bold+t.green}\n[cds] - my watch has ended. ${t.reset}`))
   return watcher
 }
 
@@ -191,15 +191,10 @@ function paths (dir) {
 if (!module.parent) (async()=>{ // launched by nodemon
   // run through cli in order to use its error handling
   const bootstrap = require('./cds')(...JSON.parse(process.env._args))
-  const {cds} = global
+  const {cds} = global; cds.watched = true
 
-  cds.once('listening', ({server, url}) => {
+  cds.once('listening', ({server}) => {
     process.send ({ code:'listening', port: server.address().port })
-    // Need to give bindings an explicit call to purge,
-    // as its .exit handler has no chance to execute on Windows.
-    process.on ('message', (msg)=> { if (msg && msg.exit) { // see node-watch
-      (new cds.service.bindings(url)).purge()
-    }})
   })
 
   try {

package/lib/bind/BindingManager.js

@@ -0,0 +1,87 @@
+const cds = require('../cds')
+const LOG = cds.log('bind');
+const { resolveBindings, getUnresolvedBindings } = require('./bindingResolver')
+
+class BindingManager {
+    constructor(options) {
+        this.cache = {}
+        this.bindingsStr = ''
+        this.options = options
+    }
+
+    getBindings() {
+        const bindings = getUnresolvedBindings(this.options)
+        return bindings
+    }
+
+    async resolve(bindings) {
+        if (!bindings) {
+            bindings = this.getBindings(this.options)
+            this.bindingsStr = JSON.stringify(bindings)
+        }
+
+        return await resolveBindings({...this.options, bindings, cache: this.cache})
+    }
+
+    async bindingEnv(bindings) {
+        if (!bindings) bindings = await this.resolve()
+        if (bindings) {
+            const VCAP_SERVICES = JSON.stringify(this.toVcapServices(bindings))
+            return { VCAP_SERVICES }
+        } else {
+            return undefined
+        }
+    }
+
+    async update({ onBeforeUpdate, onAfterUpdate } = {}) {
+        const oldBindingsStr = this.bindingsStr
+        const bindings = this.getBindings()
+        const bindingsStr = JSON.stringify(bindings)
+        this.bindingsStr = bindingsStr
+
+        if (this.bindingsStr === oldBindingsStr) return // No change
+        if (onBeforeUpdate) await onBeforeUpdate()
+
+        try {
+            if (this.pendingUpdate) await this.pendingUpdate
+        } catch(error) {
+            // ignore
+        }
+        this.pendingUpdate = undefined
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+
+        let resolvedBindings
+        try {
+            this.pendingUpdate = this.resolve(bindings)
+            resolvedBindings = await this.pendingUpdate
+        } catch(error) {
+            LOG.error(error.message)
+            return
+        }
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+
+        const env = Object.assign({ VCAP_SERVICES: '{}' }, await this.bindingEnv(resolvedBindings));
+        if (onAfterUpdate) onAfterUpdate({bindings: resolvedBindings, env})
+    }
+
+    toVcapServices(bindings) {
+        const services = {}
+
+        for (const name in bindings) {
+            const binding = bindings[name]
+            const vcap = binding.binding.vcap || {}
+            const type = vcap.type || vcap.label
+            const serviceEntries = services[type] = services[type] || []
+
+            // setting the 'name' property is important to make CAP match the CDS service to the VCAP service
+            // it is also added to the 'vcap' property by 'cds bind'
+            serviceEntries.push({ ...vcap, name, credentials: binding.credentials})
+        }
+
+        return services
+    }
+}
+
+module.exports = BindingManager

package/lib/bind/bindingResolver.js

@@ -1,5 +1,5 @@
 const Config = require('@sap/cds/lib/env')
-const cds = require('@sap/cds/lib');
+const cds = require('../cds')
 const LOG = cds.log('bind');
 const resolveBinding = resolver(LOG);
 const { platformText, bindingText } = require('./bindingUtil');
@@ -8,8 +8,8 @@ function getUnresolvedBindings({cwd = process.cwd(), env}) {
     if (!env) env = Config.for('cds', cwd)
     if (feature(env) === false || feature(env) === "false") return {}
 
+    const bindings = {}
     const requires = env.requires || {}
-    let bindings = {}
     for (const name in requires) {
         const service = requires[name]
         if (service && service.binding && !service.binding.resolved) {
@@ -21,27 +21,27 @@ function getUnresolvedBindings({cwd = process.cwd(), env}) {
 }
 
 async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'info', cache = {} }) {
-    const config = { requires: { } }
     bindings = bindings || getUnresolvedBindings({cwd, env})
-    if (Object.keys(bindings).length===0) return config;
+    if (Object.keys(bindings).length===0) return undefined
     LOG[output](`resolving cloud service bindings...`)
+
+    const resolvedBindings = {}
+
     await Promise.all( Object.keys(bindings).map( async name => {
         const binding = bindings[name]
         const cacheKey = JSON.stringify(binding)
+        let resolvedBinding
         if (!cache[cacheKey]) {
-            cache[cacheKey] = config.requires[name] = await resolveBinding(name, binding)
+            resolvedBinding = cache[cacheKey] = await resolveBinding(name, binding)
             LOG[output](`bound ${name} to ${platformText(binding)} ${bindingText(binding)}`)
         } else {
-            config.requires[name] = cache[cacheKey]
+            resolvedBinding = cache[cacheKey]
         }
-    } ));
 
-    // Add kind to result, so that it can be applied to old @sap/cds versions that do not read `.cdsrc-private.json`
-    for (const name in config.requires) {
-        if (bindings[name].kind) config.requires[name].kind = bindings[name].kind
-    }
+        resolvedBindings[name] = resolvedBinding
+    } ))
 
-    return config
+    return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
 }
 
 let cfKeyProvider
@@ -68,83 +68,12 @@ function resolver(log) {
     }
 }
 
-async function applyTo(options) {
-    const config = await resolveBindings(options)
-    if (!config) return
-    const {env} = options
-    for (const name in config.requires) {
-        const service = config.requires[name]
-        const { binding, credentials } = service
-        Object.assign(env.requires[name], { binding, credentials })
-    }
-
-    if (env._emulate_vcap_services) {
-        env._emulate_vcap_services()
-    }
-}
-
-class BindingManager {
-    constructor(options) {
-        this.cache = {}
-        this.bindingsStr = ''
-        this.options = options
-    }
-
-    getBindings() {
-        const bindings = getUnresolvedBindings(this.options)
-        return bindings
-    }
-
-    async resolve(bindings) {
-        if (!bindings) {
-            bindings = this.getBindings(this.options)
-            this.bindingsStr = JSON.stringify(bindings)
-        }
-
-        const config = await resolveBindings({...this.options, bindings, cache: this.cache})
-        if (config && Object.keys(config.requires || {}).length > 0) return config;
-    }
-
-    async update({ onBeforeUpdate, onAfterUpdate } = {}) {
-        const oldBindingsStr = this.bindingsStr
-        const bindings = this.getBindings()
-        const bindingsStr = JSON.stringify(bindings)
-        this.bindingsStr = bindingsStr
-
-        if (this.bindingsStr === oldBindingsStr) return // No change
-        if (onBeforeUpdate) await onBeforeUpdate()
-
-        try {
-            if (this.pendingUpdate) await this.pendingUpdate
-        } catch(error) {
-            // ignore
-        }
-        this.pendingUpdate = undefined
-
-        if (this.bindingsStr !== bindingsStr) return // Next update in progress
-
-        let resolvedBindings
-        try {
-            this.pendingUpdate = this.resolve(bindings)
-            resolvedBindings = await this.pendingUpdate
-        } catch(error) {
-            LOG.error(error.message)
-            return
-        }
-
-        if (this.bindingsStr !== bindingsStr) return // Next update in progress
-        if (onAfterUpdate) onAfterUpdate(resolvedBindings)
-    }
-}
-
 function feature(env) {
     return env.features && env.features.dk && env.features.dk.resolveBindingsForTesting
 }
 
 module.exports = {
     resolver,
-    applyTo,
-    bindingManager: function(options) {
-        return new BindingManager(options)
-    }
+    resolveBindings,
+    getUnresolvedBindings
 }

package/lib/bind/bindingUtil.js

@@ -38,29 +38,36 @@ function determineKinds(services) {
     for (const service of services) {
         service.kindCandidates = [ ]
 
-        const { label, name, tags } = service.binding && service.binding.vcap || {};
-        if (!label) continue;
+        const { vcap = {} } = service.binding || {};
+        let { label, type } = vcap;
+        type = type || label;
+        if (!type) continue;
 
-        if (!vcapServices[label]) vcapServices[label] = [];
-        vcapServices[label].push({ credentials: { dummy: 'dummy' }, label, name, tags, service });
+        if (!vcapServices[type]) vcapServices[type] = [];
+        vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service });
     }
 
 // Auto configure services based on VCAP_SERVICES
 
-    const cds = require('@sap/cds/lib');
+    const cds = require('../cds');
     const env = cds.env.for('cds', process.cwd());
 
     if (!env._find_credentials_for_required_service) {
         throwError `Please provide a service kind or update @sap/cds version to use the kind detection.`;
     }
 
+    function findKindFor(kind, service) {
+        const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices);
+        if (!vcapService) return;
+        if (!Object.values(requires).find( require => require !== service && require.kind == kind ))
+            vcapService.service.kindCandidates.push(kind);
+    }
+
     const requires = env.requires.kinds || {};
     for (const kind of Object.keys(requires)) {
         const requireService = requires[kind];
-        const vcapService = env._find_credentials_for_required_service(kind, requireService, vcapServices);
-        if (!vcapService) continue;
-        if (!Object.values(requires).find( require => require !== requireService && require.kind == kind ))
-            vcapService.service.kindCandidates.push(kind);
+        findKindFor(kind, requireService);
+        findKindFor(kind, { kind });
     }
 
     // Check if one "kind" per service was found
@@ -76,10 +83,10 @@ function determineKinds(services) {
     }
 }
 
-function execAndExit(command, ...args) {
+function execAndExit(options, command, ...args) {
     const { spawnSync } = require('child_process');
     // use shell with Windows only; without output is not visible and some commands cannot be run
-    const result = spawnSync(command, args, { stdio: 'inherit', shell: IS_WIN });
+    const result = spawnSync(command, args, { stdio: 'inherit', shell: IS_WIN, ...options });
     process.exit(result.status);
 }