@sap/cds-dk 8.7.2 → 8.8.0

package/lib/bind/shared.js

@@ -0,0 +1,267 @@
+const os = require('node:os')
+const cds = require('../cds')
+const { exists, read, fs, path } = cds.utils
+const git = require('../util/git')
+const { bold } = require('../util/term')
+
+const KindToRequiresNameMap = {
+    xsuaa: 'auth',
+    'xsuaa-auth': 'auth',
+    'ias-auth': 'auth',
+    'hana-cloud': 'db',
+    hana: 'db',
+    'hana-mt': 'db', // For compatibility only
+    'sql-mt': 'db', // For compatibility only
+    destinations: 'destinations',
+    connectivity: 'connectivity',
+    'audit-log': 'auditlog',
+    'audit-log-to-restv2': 'auditlog',
+    'enterprise-messaging': 'messaging',
+    'enterprise-messaging-amqp': 'messaging',
+    'enterprise-messaging-http': 'messaging',
+    'enterprise-messaging-shared': 'messaging',
+    'redis-messaging': 'messaging',
+    'multitenancy': 'multitenancy'
+}
+
+const PreferredKinds = {
+    multitenancy: 1,
+    'hana-cloud': 1,
+    xsuaa: 1,
+    'xsuaa-auth': 1,
+    'ias-auth': 1,
+    'saas-registry': 1
+}
+
+async function bind(options) {
+    let on
+    switch (options.on) {
+        case 'k8s':
+        case 'kubernetes':
+            on = 'k8s'
+            break
+        case undefined:
+        case null:
+        case 'cf':
+        case 'cloudfoundry':
+            on = 'cf'
+            break
+        default:
+            throw `invalid value '${options.on}' for option --on.`
+    }
+    const plugin = require(`./${on}`)
+
+    if (!options['to-app-services']) console.log(`retrieving data from ${bold(plugin.displayName())}...`)
+
+    const services = options.to.split(/,/g)
+    const resolvedServices = await Promise.all(services.map(async service => {
+        const binding = { on, ...plugin.binding4(service) }
+        const resolved = await _resolveBinding(binding)
+        delete resolved.credentials
+        return resolved
+    }))
+    if (options.kind) {
+        resolvedServices.forEach(service => service.kind = options.kind)
+    } else {
+        _determineKinds(resolvedServices)
+    }
+    for (const resolved of resolvedServices) {
+        const { kind, binding, binding: { instance, secret } } = resolved
+        if (options.serviceArg) {
+            resolved.name = options.serviceArg
+        } else if (kind) {
+            const requiresName = KindToRequiresNameMap[kind]
+            if (!requiresName) throw new Error(`Unknown CDS service name for service ${bold(instance)}. Please specify as argument for ${bold('cds bind')}.`)
+            resolved.name = requiresName
+        }
+        resolved.name ??= `custom-service:${instance || secret}`
+        const kindText = kind ? ` with kind ${bold(kind)}` : ''
+        console.log(`binding ${bold(resolved.name)} to ${plugin.displayName()} ${_bindingText(binding)}${kindText}`)
+    }
+    return resolvedServices
+}
+
+async function storeBindings(resolvedServices, options) {
+    const cdsrcPrivate = '.cdsrc-private.json'
+    let jsonPath = options.out || cdsrcPrivate
+    if (jsonPath === cdsrcPrivate) {
+        await git.ensureFileIsGitignored(cdsrcPrivate)
+    }
+    jsonPath = jsonPath.replace(/~/g, os.homedir())
+    if (path.extname(jsonPath) !== '.json') {
+        jsonPath = path.join(jsonPath, '.cdsrc.json')
+    }
+    const conf = exists(jsonPath) ? await read(jsonPath) : {}
+    let cdsRoot
+    if (path.basename(jsonPath) === 'package.json') {
+        conf.cds = conf.cds || {}
+        cdsRoot = conf.cds
+    } else {
+        cdsRoot = conf
+    }
+    const profile = `[${options.for}]`
+    const features = cdsRoot.features?.[profile]
+    if (features) delete features.emulate_vcap_services
+    cdsRoot.requires ??= {}
+    const section = cdsRoot.requires[profile] ??= {}
+
+    for (const { name, kind, binding, credentials } of resolvedServices) {
+        const requireService = section[name] ??= {}
+        binding.credentials = _getServiceCredentials(binding, resolvedServices, options)
+        Object.assign(requireService, { binding: { ...binding, vcap: undefined }, credentials, kind, vcap: { name } })
+    }
+    await fs.promises.mkdir(path.dirname(jsonPath), { recursive: true })
+    await fs.promises.writeFile(jsonPath, JSON.stringify(conf, null, 2))
+    await fs.promises.chmod(jsonPath, 0o600)
+    console.log(`saving bindings to ${bold(jsonPath)} in profile ${bold(options.for)}`)
+}
+
+function mergeCredentials(credentials, customCredentials) {
+    if (!customCredentials) return credentials
+    for (const key in customCredentials) {
+        if (typeof customCredentials[key] === 'object') {
+            if (credentials[key] && typeof credentials[key] !== 'object') {
+                throw `Cannot merge credentials: '${key}' is not an object`
+            }
+            if (!credentials[key]) {
+                credentials[key] = {}
+            }
+            credentials[key] = mergeCredentials(credentials[key], customCredentials[key])
+        } else {
+            credentials[key] = customCredentials[key]
+        }
+    }
+    return credentials
+}
+
+async function bindingEnv(options) {
+    const bindings = _getUnresolvedBindings(options)
+    const resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
+    return resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : undefined
+}
+
+async function updateBindings(options, { onBeforeUpdate, onAfterUpdate } = {}) {
+    const bindings = _getUnresolvedBindings(options)
+    if (onBeforeUpdate) await onBeforeUpdate()
+    let resolvedBindings
+    try {
+        resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
+    } catch (error) {
+        console.error(error.message) // REVISIT: Why not throw here?
+        return
+    }
+    const env = resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : { VCAP_SERVICES: '{}' }
+    if (onAfterUpdate) await onAfterUpdate({ bindings: resolvedBindings, env })
+    return { bindings: resolvedBindings, env }
+}
+
+module.exports = { bind, storeBindings, mergeCredentials, bindingEnv, updateBindings }
+
+/* Private helpers */
+
+function _bindingText(binding) {
+    try { return require(`./${binding.on ?? binding.type}`).description4(binding) } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') throw `unsupported binding type ${bold(binding.on ?? binding.type)}.`
+    }
+}
+
+function _resolveBinding(binding, name) {
+    try { return require(`./${binding.on ?? binding.type}`).resolve(name, binding) } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') throw `unsupported binding type ${bold(binding.on ?? binding.type)} for service ${bold(name)}.`
+    }
+}
+
+function _determineKinds(services) {
+    const vcapServices = {}
+
+    // Build VCAP_SERVICES
+    for (const service of services) {
+        service.kindCandidates = []
+        const { vcap = {} } = service.binding || {}
+        const { label, type = label } = vcap
+        if (!type) continue
+        if (!vcapServices[type]) vcapServices[type] = []
+        vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service })
+    }
+
+     // Auto configure services based on VCAP_SERVICES
+    const cds = require('../cds')
+    const env = cds.env.for('cds', process.cwd())
+    if (!env._find_credentials_for_required_service) { // REVISIT: Proper API
+        throw new Error(`Please provide a service kind or update @sap/cds version to use the kind detection.`)
+    }
+    const requires = env.requires.kinds || {}
+    for (const [kind, service] of Object.entries(requires)) {
+        const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices)
+        if (!vcapService) continue
+        const isUniqueKind = !Object.values(requires).some(otherService =>
+            otherService !== service && otherService.kind === kind
+        )
+        if (isUniqueKind) vcapService.service.kindCandidates.push(kind)
+    }
+    for (const service of services) {
+        const preferredKind = service.kindCandidates.find(kind => kind in PreferredKinds)
+        if (preferredKind) {
+            service.kind = preferredKind
+        } else if (service.kindCandidates.length === 1) {
+            service.kind = service.kindCandidates[0]
+        }
+        delete service.kindCandidates
+    }
+}
+
+function _getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
+    if (!env) {
+        env = cds.env.for('cds', path.resolve(cwd)) // REVISIT: This might load cds.env too early!
+    }
+    const bindings = {}
+    const requires = env.requires || {}
+    for (const name in requires) {
+        const service = requires[name]
+        if (service?.binding && !service.binding.resolved) {
+            bindings[name] = { ...service.binding, kind: service.kind }
+        }
+    }
+    return bindings
+}
+
+async function _resolveBindings({ bindings, cwd = process.cwd(), env, cache = {}, silent }) {
+    bindings ??= _getUnresolvedBindings({ cwd, env })
+    if (Object.keys(bindings).length === 0) return undefined
+    if (!silent) console.log(`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]) {
+            resolvedBinding = cache[cacheKey] = await _resolveBinding(binding, name)
+            if (!silent) console.log(`bound ${bold(name)} to ${binding.type} ${_bindingText(binding)}`)
+        } else {
+            resolvedBinding = cache[cacheKey]
+        }
+        resolvedBindings[name] = resolvedBinding
+    }))
+    return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
+}
+
+function _toVcapServices(bindings) {
+    const services = {}
+    for (const name in bindings) {
+        const { binding, credentials } = bindings[name]
+        const vcap = binding.vcap ?? {}
+        const type = vcap.type ?? vcap.label
+        services[type] ??= []
+        services[type].push({ ...vcap, name, credentials })
+    }
+    return JSON.stringify(services)
+}
+
+function _getServiceCredentials(binding, services, options) {
+    const { to, credentials } = options
+    const { type } = binding
+    if (!credentials) return
+    const plugin = require(`./${type}`)
+    const service = plugin.service4(binding, to ?? services)
+    return credentials[service] ?? credentials
+}

package/lib/build/buildTaskEngine.js

@@ -261,7 +261,7 @@ The higher the value the earlier the plugin is run.`
     }
 
     _logTimer(start, end) {
-        console.log(`build completed in ${end - start} ms\n`)
+        console.log(`build completed in ${end - start} ms`)
     }
 
     _logTaskHandler(plugin) {

package/lib/build/plugins/helm/files/subcharts/content-deployment/Chart.yaml

@@ -1,7 +1,5 @@
 apiVersion: v2
 description: A Helm Chart for creating a Content Deployment job
 name: content-deployment
-sources:
-- https://github.tools.sap/unified-runtime/content-deployment
 type: application
 version: 1.7.1

package/lib/build/plugins/helm/files/subcharts/web-application/Chart.yaml

@@ -2,7 +2,5 @@ apiVersion: v2
 description: A Helm chart for web app
 kubeVersion: '>= 1.21'
 name: web-application
-sources:
-- https://github.tools.sap/unified-runtime/web-application
 type: application
-version: 1.22.0
+version: 1.23.0

package/lib/build/plugins/helm/files/subcharts/web-application/templates/service-binding.yaml

@@ -33,5 +33,8 @@ spec:
   {{- if $mergedParams.credentialsRotationPolicy }}
   credentialsRotationPolicy: {{ $mergedParams.credentialsRotationPolicy | toYaml | nindent 4 }}
   {{- end }}
+  {{- if $mergedParams.secretTemplate }}
+  secretTemplate: {{ $mergedParams.secretTemplate | toYaml | nindent 2}}
+  {{- end }}
 {{- end }}
 {{- end }}

package/lib/build/plugins/helm/files/subcharts/web-application/values.schema.json

@@ -793,6 +793,9 @@
                                 "secretName": {
                                     "type": "string"
                                 },
+                                "secretTemplate": {
+                                    "type": "string"
+                                },
                                 "secretKey": {
                                     "type": "string",
                                     "default": "credentials"

package/lib/build/plugins/helm/files/subcharts/web-application/values.yaml

@@ -14,7 +14,7 @@ global:
     _internal:
       web-application:
         versions:
-          1.22.0: true
+          1.23.0: true
 ## Will be used instead of the `.Chart.Name`, e.g. when generating the Deployment name.
 # nameOverride: name
 
@@ -258,6 +258,7 @@ bindings:
 #       enabled: false
 #   hana:
 #     serviceInstanceName: hana-manual
+#     secretTemplate: -> see https://github.com/SAP/sap-btp-service-operator?tab=readme-ov-file#custom-formats
 #   portal:
 #     fromSecret: manual-secret # user-provided-service
 

package/lib/build/util.js

@@ -134,7 +134,7 @@ async function getDefaultModelOptions(ws = false, filter) {
             workspaces.forEach(workspace => {
                 cds.root = path.join(root, workspace)
                 cds.env = cds.env.for('cds', cds.root)
-                paths = paths.concat(_filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false), filter).map(p => path.join(workspace, p)))
+                paths = paths.concat(_filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false), filter).map(p => normalizePath(path.join(workspace, p))))
             })
         } finally {
             cds.root = root

package/lib/compile/to-mermaid.js

@@ -114,7 +114,7 @@ module.exports = function to_mermaid (model, options={}) {
 }
 
 function resolveTargets (query) {
-  if (query.target)  return [ query.target.name ] // simple query, like projection on
+  if (query._target)  return [ query._target.name ] // simple query, like projection on
 
   // SELECT: { from: { args: [{ ref: ['t1'] }, { ref: ['t2'] }], join: ..., on: ... } }
   const targets = query.SELECT?.from?.args?.filter(arg => arg.ref?.length).map (arg => arg.ref[0])
@@ -205,4 +205,3 @@ function to_mta_mermaid (file) {
 
   return diag
 }
-

package/lib/deploy/to-hana/hana.js

@@ -14,7 +14,7 @@ const mtaUtil = require('./mtaUtil');
 
 const { bold, info, warn } = require('../../util/term');
 
-const { bind, storeBindings } = require('../../bind');
+const { bind, storeBindings } = require('../../bind/shared');
 const { BUILD_TASK_HANA, OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, OUTPUT_MODE_RESULT } = require('../../build/constants');
 
 const DEBUG = cds.debug('cli');
@@ -79,6 +79,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     if (dry) {
+      if (!buildResult) return
       const sortedResult = Array.from(buildResult.hana).sort();
       for (const file of sortedResult) {
         const srcPath = path.join(buildResult.dest, file);
@@ -87,7 +88,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
         console.log();
       }
     } else {
-      // the primary database is always built and deployed 
+      // the primary database is always built and deployed
       const dest = path.join(cds.env.build.target, cds.env.folders.db);
 
       let serviceName = pServiceName;
@@ -211,8 +212,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
       src: cds.env.folders.db,
       [OUTPUT_MODE]: OUTPUT_MODE_FILESYSTEM | OUTPUT_MODE_RESULT
     }
-    console.log(`Running build`);
-    
+
     // cds build throws an error if the src folder does not exist
     const buildResult = await build(buildTaskOptions);
     return buildResult[0].result;

package/lib/deploy/to-hana/mtaUtil.js

@@ -24,18 +24,6 @@ async function getHanaDbModuleDescriptor(projectPath, moduleName) {
     }
 }
 
-async function getServiceModuleDescriptor(projectPath, moduleName, moduleType) {
-    // mta might be null if mta.yaml does not exist
-    const mta = await _getMta(projectPath)
-    const projectInfo = await _getProjectInfo(projectPath, mta)
-    const appName = _getApplicationName(mta, moduleName, moduleType)
-
-    return {
-        project: projectInfo,
-        appName: appName ? appName : `${projectInfo.name}-${moduleName}`
-    }
-}
-
 async function _getProjectInfo(projectPath, mta) {
     const details = {
     }
@@ -166,6 +154,5 @@ function _findHdiResource(mta, moduleName) {
 
 module.exports = {
     getHanaDbModuleDescriptor,
-    getServiceModuleDescriptor,
     MTA_YAML
 }

package/lib/import/common.js

@@ -194,25 +194,24 @@ function _getServiceNames(csn) {
 }
 
 function _validateAndComputeOutputFilePath(outputFileLoc, as, destFilePath) {
-    let index, extension, expectedExtension, supportedExtension;
+    let extension, expectedExtension, supportedExtension;
     if (typeof (outputFileLoc) !== 'boolean') {
-        index = outputFileLoc.lastIndexOf(".");
-        extension = outputFileLoc.substring(index + 1);
+        extension = path.extname(outputFileLoc).substring(1);
         expectedExtension = (as) ? _getSuffix(as) : "csn";
-        supportedExtension = (index > 0) ? _supportedAsFormats().includes(extension) : false;
+        supportedExtension = extension ? _supportedAsFormats().includes(extension) : false;
     }
 
     if (outputFileLoc === true || // if output file is not mentioned
         outputFileLoc[0] === "-" || // if output file is missing and "--as" is considered as output file
         outputFileLoc.trim() === "") {
         throw new Error(messages.SPECIFY_OUTPUT_FILE);
-    } else if (index > 0 && !supportedExtension) {
+    } else if (extension && !supportedExtension) {
         // extension not supported, eg., "test.abs", "./sv/external.test.abcs", "./a."
         throw new Error(messages.INVALID_OUTPUT_FILE);
-    } else if (index > 0 && !as && extension != "json" && extension != "csn") {
+    } else if (extension && !as && extension != "json" && extension != "csn") {
         // --as option is not provided but output file is like: "test.cds", "./srv/external/test.cds"
         throw new Error(messages.INCORRECT_EXTENSION);
-    } else if (index > 0 && as && extension != expectedExtension) {
+    } else if (extension && as && extension != expectedExtension) {
         // extension not supported by --as option, e.g., "cds import <file> --out test.yml --as cds"
         throw new Error(messages.OUTPUT_FILE_MISMATCH);
     } else if (supportedExtension || (!outputFileLoc.endsWith("\\") && !outputFileLoc.endsWith("/"))) {

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [17, 21],
-    MAVEN_ARCHETYPE_VERSION: '3.7.1',
+    MAVEN_ARCHETYPE_VERSION: '3.7.2',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',

package/lib/init/merge.js

@@ -129,12 +129,17 @@ async function _mergeJSON(into, from, project, semantics) {
  * @throws {Error} Throws an error if empty target YAML is passed in
  */
 async function _mergeYAML(into, from, project, semantics = {}) {
-    const target = typeof into === 'string' ? await readYAML(into) : into instanceof YAML.Document ? into : new YAML.Document(into)
-    const source = typeof from === 'string' ? await readYAML(from, project) : from instanceof YAML.Document ? from : new YAML.Document(from)
+    const target = typeof into === 'string'      ? await readYAML(into) :
+                   into instanceof YAML.Document ? into :
+                   new YAML.Document(into)
+    const source = typeof from === 'string'      ? await readYAML(from, project) :
+                   from instanceof YAML.Document ? from :
+                   new YAML.Document(from)
 
     if (!target?.contents) {
         if (typeof into === 'string' && typeof from === 'string') {
-            project ? await writeYAML(into, source) : await copy(from, into)
+            if (project) await writeYAML(into, source)
+            else await copy(from, into)
             return source
         }
         throw new Error(`Target YAML doesn't exist`)
@@ -143,19 +148,19 @@ async function _mergeYAML(into, from, project, semantics = {}) {
     const entryMap = new Map, templateEntryMap = new Map
 
     const { additions, overwrites, deletions, relationships } = semantics
-    additions?.forEach(entry => {
+    for (const entry of additions ?? []) {
         entryMap.set(entry, undefined)
         templateEntryMap.set(entry, undefined)
-    })
-    deletions?.forEach(deletion => {
+    }
+    for (const deletion of deletions ?? []) {
         entryMap.set(deletion.item, undefined)
-    })
-    relationships?.forEach(relationship => {
+    }
+    for (const relationship of relationships ?? []) {
         const [entry] = relationship.into
         const [insertEntry] = relationship.insert
         const hash = JSON.stringify(insertEntry) + ' -> ' + JSON.stringify(entry)
         entryMap.set(hash, undefined)
-    })
+    }
 
     let collectionStack = [target.contents]
 
@@ -330,7 +335,7 @@ async function _mergeYAML(into, from, project, semantics = {}) {
                     })
                     .filter(item => !entryMap.get(item))
                     .forEach(item => {
-                        if (!templateEntryMap.get(item)) throw 'Error: did not find entry in template for ' + inspect(item, { colors }) + ' in ' + from
+                        if (!templateEntryMap.get(item)) throw 'Error: did not find entry in template for ' + inspect(item, { colors, depth:11 }) + ' in ' + from
                         const templateNode = templateEntryMap.get(item).node
                         item.at !== undefined ? targetNode.items.splice(item.at, 0, templateNode) : targetNode.add(templateNode)
                     })
@@ -347,32 +352,36 @@ async function _mergeYAML(into, from, project, semantics = {}) {
     // 7. Create missing relationships
     _traverseYAMLNode(target.contents, null, {
         mergeCollection: (targetNode, templateNode) => {
-            if (YAML.isSeq(templateNode)) {
-                const targetJSON = YAML.parse(String(targetNode))
-                const relationship = semantics.relationships?.filter(r => r)
-                    .find(relationship => {
-                        const [entry, keyPath] = relationship.into
-                        if (!entryMap.get(entry)) return false
-                        const existingNode = _getYAMLProperty(entryMap.get(entry).node, keyPath)
-                        return targetNode === existingNode
-                })
-                if (!relationship) return
-
-                const intoKey = relationship.into[relationship.into.length - 1]
-                const [entry, entryKeyPath] = relationship.insert
-                const missingPairs = [entry]
-                    .filter(item =>
-                        !targetJSON.some(targetItem =>
-                            _getProperty(entryMap.get(item).json, entryKeyPath) === targetItem[intoKey]
-                        )
-                    )
-                    .map(item => entryMap.get(item).node.get(intoKey))
-                missingPairs.forEach(pair => {
-                    targetNode.add({ [intoKey]: pair })
+          if (YAML.isSeq(templateNode)) {
+            const targetJSON = YAML.parse(String(targetNode))
+            const relationships = semantics.relationships?.filter(relationship => {
+              const [entry, keyPath] = relationship.into
+              if (!entryMap.get(entry)) return false
+              const existingNode = _getYAMLProperty(entryMap.get(entry).node, keyPath)
+              return targetNode === existingNode
+            }) ?? []
+
+            for (const { into, insert } of relationships) {
+              const intoKey = into[into.length - 1]
+              const [insEntry, entryKeyPath] = insert
+              const missingPairs = [insEntry]
+                .filter(item => {
+                  if (!entryMap.get(item)) {
+                    const spec = inspect(item, { colors, depth:11 })
+                    throw new Error(`Did not find entry in template for ${spec} in ${from}:\n${source}`)
+                  }
+                  return !targetJSON.some(targetItem =>
+                    _getProperty(entryMap.get(item).json, entryKeyPath) === targetItem[intoKey]
+                 )
                 })
+                .map(item => entryMap.get(item).node.get(intoKey))
+              for (const pair of missingPairs) {
+                targetNode.add({ [intoKey]: pair })
+              }
             }
+          }
         }
-    }, source.contents)
+      }, source.contents)
 
     typeof into === 'string' && await writeYAML(into, target)
     return target

package/lib/init/projectReader.js

@@ -125,7 +125,9 @@ module.exports = new class ProjectReader {
         const _uiEmbedded = () => exists(join(env.folders.app, 'xs-app.json'))
         const _uiModule = () => !_uiEmbedded() && isdir(env.folders.app) && fs.readdirSync(resolve(cds.root, env.folders.app)).length > 0
         const _isJava = () => this.isJava
-        const isApp = name => name !== 'appconfig' && !name.startsWith('_') && name !== 'router' && name !== 'portal'
+        const isApp = name => {
+            return name !== 'appconfig' && !name.startsWith('_') && name !== 'router' && name !== 'portal' && name !== 'workzone'
+        }
         const reserved = {
             dependencies: () => pkgJson().dependencies,
             has: x => _inProd(x),
@@ -152,7 +154,9 @@ module.exports = new class ProjectReader {
             },
             configFile: () => _isJava() ? '.cdsrc.json' : 'package.json',
             apps: () => {
-                const apps = fs.readdirSync(path.resolve(cds.root, cds.env.folders.app)).filter(e =>
+                const appPath = path.resolve(cds.root, cds.env.folders.app)
+                if (!exists(appPath)) return []
+                const apps = fs.readdirSync(appPath).filter(e =>
                     isdir(path.join(cds.root, cds.env.folders.app, e)) && isApp(e)
                 )
                 return apps.map((app, i) => {
@@ -164,14 +168,18 @@ module.exports = new class ProjectReader {
                     return { app, strippedApp: app.replace(/-/g, ''), vizId, isNotLast: i < apps.length - 1, manifestAppId: manifest?.['sap.app']?.id ?? app}
                 })
             },
-            appUIPaths: () => (fs.readdirSync(path.resolve(cds.root, cds.env.folders.app))).filter(e =>
-                isdir(join(cds.root, cds.env.folders.app, e)) && isApp(e)
-            ),
+            appUIPaths: () => {
+                const appPath = path.resolve(cds.root, cds.env.folders.app)
+                if (!exists(appPath)) return []
+                return fs.readdirSync(appPath).filter(e =>
+                    isdir(path.join(cds.root, cds.env.folders.app, e)) && isApp(e)
+                )
+            },
             hasIndexHtml: () => {},
             appPath: () => env.folders.app,
             appVersion: () => appVersion,
             jdkVersion: () => jdkVersion,
-            approuterPath: () => _uiEmbedded() ? join(env.folders.app) : join(env.folders.app, 'router'),
+            approuterPath: () => (_uiEmbedded() ? join(env.folders.app) : join(env.folders.app, 'router')).replace(/\\/g, '/'),
             appName: () => appName,
             cleanedAppName: () => appName.replaceAll('_', '-'),
             strippedAppName: () => appName.replace(/-/g, ''),
@@ -210,7 +218,7 @@ module.exports = new class ProjectReader {
 
 /**
  * Finds and reads SpringBoot configuration in `cds.root/srv` dir.
- * This is done in a best-effort way. In no way can we replciate all of SpringBoot's
+ * This is done in a best-effort way. In no way can we replicate all of SpringBoot's
  * config variants.
  * @param {string[]?} roots array of directories to search for application.yaml, like `srv`
  * @returns {Promise<object[]>} array of objects with `cds` property