@sap/cds 7.9.4 → 8.0.4

package/eslint.config.mjs

@@ -0,0 +1,133 @@
+/**
+ * Recommended ESLint config for @sap/cds projects.
+ */
+export const defaults = {
+
+  rules: {
+    'no-unused-vars': 'warn',
+    'no-console': 'warn',
+  },
+
+  languageOptions: {
+    ecmaVersion: 2022,
+    globals: {
+
+      // cds.ql commands ...
+      SELECT: 'readonly',
+      INSERT: 'readonly',
+      UPSERT: 'readonly',
+      UPDATE: 'readonly',
+      DELETE: 'readonly',
+      CREATE: 'readonly',
+      DROP: 'readonly',
+
+      // tagged template strings ...
+      CDL: 'readonly',
+      CQL: 'readonly',
+      CXL: 'readonly',
+
+      // subset of Node.js globals ...
+      __dirname: 'readonly',
+      __filename: 'readonly',
+      exports: 'writable',
+      require: 'readonly',
+      global: 'readonly',
+      module: 'readonly',
+      console: 'readonly',
+      process: 'readonly',
+      performance: 'readonly',
+      setImmediate: 'readonly',
+      setInterval: 'readonly',
+      setTimeout: 'readonly',
+      clearImmediate: 'readonly',
+      clearInterval: 'readonly',
+      clearTimeout: 'readonly',
+      structuredClone: 'readonly',
+
+      Buffer: 'readonly',
+      fetch: 'readonly',
+      URL: 'readonly',
+      URLSearchParams: 'readonly',
+    }
+  },
+
+  linterOptions: {
+    reportUnusedDisableDirectives: false,
+  }
+}
+
+/**
+ * ESLint config for jest and mocha test.
+ */
+export const tests = {
+  files: [ '**/test/**/*.js', '**/test?/**/*.js', '**/*.test.js', '**/*-test.js' ],
+  languageOptions: {
+    globals: {
+      mocha: 'readonly',
+      jest: 'readonly',
+      expect: 'readonly',
+      describe: 'writable',
+      xdescribe: 'writable',
+      context: 'writable',
+      suite: 'writable',
+      test: 'writable', xtest: 'writable',
+      it: 'writable',
+      fail: 'writable',
+      before: 'readonly',
+      after: 'readonly',
+      beforeAll: 'readonly',
+      afterAll: 'readonly',
+      beforeEach: 'readonly',
+      afterEach: 'readonly',
+    }
+  },
+}
+
+/**
+ * ESLint config for code running in web browsers.
+ */
+export const browser = {
+  files: [ '**/app/**/*.js', '**/webapp/**/*.js' ],
+  languageOptions: {
+    globals: {
+      window: 'readonly',
+      history: 'readonly',
+      document: 'readonly',
+      location: 'writeable',
+      localStorage: 'readonly',
+      sessionStorage: 'readonly',
+      parent: 'readonly',
+      event: 'readonly',
+      sap: 'readonly',
+    }
+  },
+}
+
+/**
+ * Global ignores for all configs.
+ */
+export const ignores = [
+  '**/@cds-models/**',
+  '**/node_modules/**',
+  'node_modules/**',
+  // '**/webapp/**',
+]
+
+/**
+ * Recommended all-in-one config for external eslint use, i.e. in cap/dev
+ * monorepo, other cap impl projects, as well as in cap-based projects.
+ * Currently the same as internal, could differ in the future.
+ */
+export const recommended = [ defaults, browser, tests, {ignores} ]
+await import('@eslint/js').then( // add recommended eslint rules if available
+  ({default:eslint}) => recommended.unshift (eslint.configs.recommended)
+).catch(()=>{})
+
+/**
+ * Default export is for internal use in @sap/cds and cap/dev projects.
+ * It adds additional ignores, e.g. for peggy-generated parser code.
+ */
+export default Object.assign ([ ...recommended, {ignores:[
+  '**/libx/odata/parse/parser.js',
+  '**/okra/**/*.js',
+]}], { recommended, defaults, browser, tests, ignores })

package/lib/auth/basic-auth.js

@@ -1,37 +1,33 @@
 module.exports = function basic_auth (options) {
 
-  const cds = require ('../index'), LOG = cds.log('auth'), { decodeURIComponent } = cds.utils
+  const cds = require ('../index'), DEBUG = cds.debug('basic|auth')
   const users = require ('./mocked-users') (options)
-  const login_required = options.login === 'required' || process.env.NODE_ENV === 'production' && options.credentials || cds.requires.multitenancy
+  const login_required = options.login_required || cds.requires.multitenancy || process.env.NODE_ENV === 'production' && options.credentials
 
   /** @type { import('express').Handler } express_handler */
   return async function basic_auth (req, res, next) {
-    // REVISIT: passport also adds a login function with different meaning -> we need to be able to recognize ours -> req._login for now
-    // allow subsequent code to request a user login
-    req._login = login
-    // get basic authorization header
-    let auth = req.headers.authorization
+    req._login = login // allow subsequent code to request a user login
+    let auth = req.headers.authorization // get basic authorization header
     // enforce login if requested
-    if (!auth?.match(/^basic/i)) return login_required ? req._login('Logged-in user required!') : next()
+    if (!auth?.match(/^basic/i)) return login_required ? req._login() : next()
     // decode user credentials from autorization header
     let [id,pwd] = Buffer.from(auth.slice(6),'base64').toString().split(':')
     // verify user credentials and set req.user
     let u = req.user = await users.verify (id, pwd)
     // re-request login in case of wrong credentials
-    if (u.failed) return req._login (u)
-    // set req.tenant
-    if (u.tenant) req.tenant = u.tenant
-    // support for feature toggles via req.headers.features
-    if (req.headers.features) u = req.user = { ...u, features: req.headers.features } // NOTE: need to clone u
-    // done...
-    if (LOG._debug) LOG.debug('authenticated user:', u)
+    if (u.failed) return req._login()
+    // user authenticated...
+    const ctx = cds.context; ctx.user = u
+    const features = req.headers.features || u.features // IMPORTANT: only here not as public API
+    if (features) ctx.features = features
+    if (u.tenant) ctx.tenant = u.tenant
+    DEBUG?.('authenticated:', { user: u.id, tenant: u.tenant, features })
+    // done
     next()
   }
 
-  function login (reason='') {
-    const req=this, res=req.res
-    // REVISIT: this json response is needed to be OData compliant. however, we should probably throw an error anyway so that a custom error middleware can get invoked.
-    res.set('www-authenticate', `Basic realm="Users"`).status(401).json({ error: { code: '401', message: 'Unauthorized' } })
-    LOG.info (req.method, decodeURIComponent(req.path), '>', res.statusCode, res.statusMessage, ...(!reason ? [] : ['-', reason]))
+  function login() {
+    DEBUG?.(401, '> login required') // REVISIT: do we really need auth checks on HEAD requests?
+    this.res.set('WWW-Authenticate', `Basic realm="Users"`).sendStatus(401)
   }
 }

package/lib/auth/dummy-auth.js

@@ -1,4 +1,4 @@
-const { User: { privileged } } = require ('../index')
+const cds = require ('../index'), {privileged} = cds.User
 
 module.exports = function dummy_auth() {
   return function dummy_auth (req, res, next) {

package/lib/auth/ias-auth.js

@@ -5,15 +5,8 @@ const LOG = cds.log('auth')
 const _require = require('../../libx/_runtime/common/utils/require')
 
 let xssec = _require('@sap/xssec')
-let xssec4 = false
 // use v3 compat api
-if (xssec.v3) {
-  xssec = xssec.v3
-  xssec4 = true
-}
-
-// getter function extracted to show deprecation warning only once
-const _getTokenInfo = tokenInfo => tokenInfo
+if (xssec.v3) xssec = xssec.v3
 
 module.exports = function ias_auth(config) {
   const { kind, credentials, known_claims } = config
@@ -52,42 +45,17 @@ module.exports = function ias_auth(config) {
   }
 
   return (req, _, next) => {
+    if (!req.headers.authorization) return next()
+
     const token = req.headers.authorization?.split(/^bearer /i)[1]
+    xssec.createSecurityContext(token, credentials, 'IAS', function (err, securityContext, tokenInfo) {
+      if (err) LOG.error('User could not be authenticated due to error:', err)
 
-    if (!token && xssec4) {
-      LOG._debug && LOG.debug('No authorization header provided, continuing with default user.')
-      req.user = new cds.User.default()
-      return next()
-    }
+      if (!securityContext) return next(new cds.error('Unauthorized', { code: 401 }))
 
-    xssec.createSecurityContext(token, credentials, 'IAS', function (err, securityContext, tokenInfo) {
-      // REVISIT: ias impl not as sophisticated as xsuaa impl, so we need to be more tolerant here -> xssec issue 221
-      // if (err && !tokenInfo) {
-      //   // here, there is a general problem, .e.g., bad credentials -> throw the error
-      //   return next(err)
-      // }
-
-      if (err && LOG._debug) LOG.debug('User could not be authenticated due to error:', err)
-
-      // if no general problem, tokenInfo object is always available -> add to req via getter for compat reasons
-      // -> the "always available" part is not true for ias (see REVISIT above)
-      tokenInfo && Object.defineProperty(req, 'tokenInfo', {
-        get() {
-          return cds.utils.deprecated(_getTokenInfo, {kind: 'Property', old: 'req.tokenInfo'})(tokenInfo)
-         }
-      })
-
-      if (!securityContext) {
-        if (!req.headers.authorization) {
-          LOG._debug && LOG.debug('No authorization header provided, continuing with default user.')
-          req.user = new cds.User.default()
-          return next()
-        }
-        return next(new cds.error('Unauthorized', { statusCode: 401 }))
-      }
-
-      req.user = getUser(tokenInfo)
-      req.tenant = tokenInfo.getZoneId()
+      const ctx = cds.context
+      ctx.user = getUser(tokenInfo)
+      ctx.tenant = tokenInfo.getZoneId()
 
       req.authInfo = securityContext //> compat req.authInfo
 

package/lib/auth/index.js

@@ -46,18 +46,5 @@ module.exports = function auth_factory (o) {
   if (typeof auth === 'function' && auth.length < 3) auth = auth(options)
 
   // return the auth middleware followed by a middleware to fill in cds.context
-  return [ auth, ctx_auth ]
+  return auth
 }
-
-/**
- * Propagate user and tenant from req to cds.context
- */
-function ctx_auth (req, res, next) {
-  const ctx = cds.context
-  ctx.user = req.user
-  ctx.tenant = req.tenant || req.user?.tenant
-  next()
-}
-
-// export ctx_auth for legacy protocol adapter -> remove with cds^8
-module.exports._ctx_auth = ctx_auth

package/lib/auth/jwt-auth.js

@@ -5,15 +5,8 @@ const LOG = cds.log('auth')
 const _require = require('../../libx/_runtime/common/utils/require')
 
 let xssec = _require('@sap/xssec')
-let xssec4 = false
 // use v3 compat api
-if (xssec.v3) {
-  xssec = xssec.v3
-  xssec4 = true
-}
-
-// getter function extracted to show deprecation warning only once
-const _getTokenInfo = tokenInfo => tokenInfo
+if (xssec.v3) xssec = xssec.v3
 
 module.exports = function jwt_auth(config) {
   const { kind, credentials } = config
@@ -54,40 +47,17 @@ module.exports = function jwt_auth(config) {
   }
 
   return (req, _, next) => {
-    const token = req.headers.authorization?.split(/^bearer /i)[1]
-
-    if (!token && xssec4) {
-      LOG._debug && LOG.debug('No authorization header provided, continuing with default user.')
-      req.user = new cds.User.default()
-      return next()
-    }
+    if (!req.headers.authorization) return next()
 
+    const token = req.headers.authorization.split(/^bearer /i)[1]
     xssec.createSecurityContext(token, credentials, function (err, securityContext, tokenInfo) {
-      if (err && !tokenInfo) {
-        // here, there is a general problem, .e.g., bad credentials -> throw the error
-        return next(err)
-      }
-
-      if (err && LOG._debug) LOG.debug('User could not be authenticated due to error:', err)
-
-      // if no general problem, tokenInfo object is always available -> add to req via getter for compat reasons
-      Object.defineProperty(req, 'tokenInfo', {
-        get() {
-          return cds.utils.deprecated(_getTokenInfo, {kind: 'Property', old: 'req.tokenInfo'})(tokenInfo)
-        }
-      })
-
-      if (!securityContext) {
-        if (!req.headers.authorization) {
-          LOG._debug && LOG.debug('No authorization header provided, continuing with default user.')
-          req.user = new cds.User.default()
-          return next()
-        }
-        return next(new cds.error('Unauthorized', { statusCode: 401 }))
-      }
-
-      req.user = getUser(tokenInfo)
-      req.tenant = tokenInfo.getZoneId()
+      if (err) LOG.error('User could not be authenticated due to error:', err)
+
+      if (!securityContext) return next(new cds.error('Unauthorized', { code: 401, statusCode: 401 }))
+
+      const ctx = cds.context
+      ctx.user = getUser(tokenInfo)
+      ctx.tenant = tokenInfo.getZoneId()
 
       req.authInfo = securityContext //> compat req.authInfo
 

package/lib/compile/cds-compile.js

@@ -22,10 +22,9 @@ const compile = module.exports = Object.assign (cds_compile, {
     get sql() { return super.sql = require('./to/sql') }
     get hdbcds() { return super.hdbcds = compile.to.sql.hdbcds }
     get hdbtable() { return super.hdbtable = compile.to.sql.hdbtable }
+    get hana() { return super.hana = compile.to.sql.hana }
     get hdbtabledata() { return super.hdbtabledata = require('./to/hdbtabledata') }
     get serviceinfo() { return super.serviceinfo = require('./to/srvinfo') } //> REVISIT: move to CLI
-    get gql() { return super.gql = require('./to/gql') } //> REVISIT: moved to @cap-js/graphql, remove with cds^8
-    get graphql() { return super.graphql = require('./to/gql') } //> REVISIT: moved to @cap-js/graphql, remove with cds^8
   },
 
 })

package/lib/compile/cdsc.js

@@ -71,33 +71,28 @@ const _options = {for: Object.assign (_options4, {
       dialect      : 'sqlDialect',
       names        : (o,v) => v !== 'plain' ? o.sqlMapping = v : undefined,
     })
-    if (_conf?.impl === '@cap-js/sqlite') {
-      o.fewerLocalizedViews = !cds.env.sql.transitive_localized_views
-      o.betterSqliteSessionVariables = true
-      // REVISIT: compiler only considers o.betterSqliteSessionVariables if o.sqlDialect == 'sqlite'.
-      // Yet, dialect: 'plain' is configured in cap/sflight -> below is a dirty hack which overrides that.
-      // We should rather have a proper way to configure the dialect in the cap/sflight project, and/or
-      // have a better way to handle o.betterSqliteSessionVariables in compiler, independent of dialect.
-      if (!_o?.dialect && (!cds.env.sql.dialect || cds.env.sql.dialect === 'plain')) o.sqlDialect = 'sqlite'
-    }
-    else if (_conf?.impl === '@cap-js/hana') {
-      o.fewerLocalizedViews = !cds.env.sql.transitive_localized_views
-      o.withHanaAssociations = cds.env.sql.native_hana_associations
+
+    if (!o.sqlDialect) {
+      let dialect = _conf.dialect || _conf.kind
+      if (dialect) o.sqlDialect = dialect
     }
-    else if (!cds.db && !cds.requires.db)  { // e.g. for Java
-      o.fewerLocalizedViews = !cds.env.sql.transitive_localized_views
-      o.withHanaAssociations = cds.env.sql.native_hana_associations
-      if (_conf?.impl === '@cap-js/sqlite') {
-        o.betterSqliteSessionVariables = true
-        // REVISIT: compiler only considers o.betterSqliteSessionVariables if o.sqlDialect == 'sqlite'.
-        // Yet, dialect: 'plain' is configured in cap/sflight -> below is a dirty hack which overrides that.
-        // We should rather have a proper way to configure the dialect in the cap/sflight project, and/or
-        // have a better way to handle o.betterSqliteSessionVariables in compiler, independent of dialect.
-        if (!_o?.dialect && (!cds.env.sql.dialect || cds.env.sql.dialect === 'plain')) o.sqlDialect = 'sqlite'
-      }
+
+    const legacy_sqlite = '@sap/cds/libx/_runtime/sqlite/Service.js'
+    if (_conf.impl === legacy_sqlite) {
+      o.betterSqliteSessionVariables = false
+      o.fewerLocalizedViews = false
     }
-    // console.trace(o)
-    if (cds.env.features.assert_integrity) o.assertIntegrityType = cds.env.features.assert_integrity.toUpperCase()
+
+    const { native_hana_associations, transitive_localized_views } = cds.env.sql
+    if (native_hana_associations !== undefined)
+      o.withHanaAssociations = native_hana_associations
+    if (transitive_localized_views !== undefined)
+      o.fewerLocalizedViews = !transitive_localized_views
+
+    const { assert_integrity } = cds.env.features
+    if (assert_integrity)
+      o.assertIntegrityType = assert_integrity.toUpperCase()
+
     return o
   },
 
@@ -165,4 +160,4 @@ module.exports = exports = {__proto__:compile, _options,
       compile.to.cdl // smart* functions
     ),
   },
-}
+}

package/lib/compile/etc/_localized.js

@@ -5,7 +5,7 @@ const _locales_4sql = {
 	plain  : env.i18n.for_sql || [],
 }
 
-const { _texts_entries, _localized_entries } = env.cdsc.cv2 || {}
+const { _localized_entries } = env.cdsc.cv2 || {}
 const _been_here = Symbol('is _localized')
 
 
@@ -42,7 +42,6 @@ function unfold_csn (m) { // NOSONAR
 
 	// only do that once per model
 	if (!m || m[_been_here]) return m
-	// eslint-disable-next-line no-console
 	DEBUG && DEBUG ('unfolding csn...')
 	const pass2 = []
 
@@ -60,10 +59,6 @@ function unfold_csn (m) { // NOSONAR
 	// Pass 1 - add localized.<locale> entities and views
 	for (const each in cds.linked(m).definitions) {
 		const d = m.definitions [each]
-		// Add <entry>_texts proxies for all <entry>.texts entities
-		if (_texts_entries !== false && each.endsWith('.texts')) {
-			_add_proxy4 (d, each.slice(0,-6)+'_texts')
-		}
 		// Add localized.<entry> for all entities having localized views in db
 		if (_localized_entries !== false && _is_localized(d)) {
 			_add_proxy4 (d,`localized.${each}`, x => pass2.push([x]))

package/lib/compile/etc/csv.js

@@ -6,7 +6,7 @@ const CSV = module.exports = { read, parse }
 function read (res) {
   try{
     return CSV.parse (readFileSync (res, 'utf-8'))
-  } catch(e){/* ignore */}
+  } catch {/* ignore */}
 }
 
 function parse (csv) {

package/lib/compile/etc/properties.js

@@ -35,6 +35,6 @@ function value4(raw) {
   if (raw === 'false') return false
   if (raw === '0') return 0
   else return Number(raw) || raw
-  .replace(/^"(.*)"$/,"$1") .replace(/^'(.*)'$/,"$1")
+  .replace(/''/g,"'") .replace(/^"(.*)"$/,"$1") .replace(/^'(.*)'$/,"$1")
   .replace(/\\u[\dA-F]{4}/gi, (match) => String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16)))
 }

package/lib/compile/for/java.js

@@ -29,7 +29,7 @@ module.exports = function cds_compile_for_java (csn,o) {
     const rr = d['@restrict']
     if (rr) for (let r of rr) if (r.grant && r.where) try {
       r._where = JSON.stringify (cds.parse.xpr(r.where))
-    } catch(e){/* ignored */}
+    } catch {/* ignored */}
   }
   Object.defineProperty (csn, '_4java', {value:dsn})
   Object.defineProperty (dsn, '_4java', {value:dsn})

package/lib/compile/for/lean_drafts.js

@@ -130,13 +130,11 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
 
       for (const key in newEl) {
         if (
-          key.startsWith('@assert') ||
-          key.startsWith('@PersonalData') ||
-          key === '@Common.FieldControl' && newEl[key]?.['#'] === 'Mandatory' ||
-          key === '@Common.FieldControl.Mandatory' ||
-          key === '@FieldControl.Mandatory' ||
           key === '@mandatory' ||
-          key === '@Core.Immutable'
+          key === '@Common.FieldControl' && newEl[key]?.['#'] === 'Mandatory' ||
+          key === '@Core.Immutable' ||
+          key.startsWith('@assert') ||
+          key.startsWith('@PersonalData')
         )
           newEl[key] = undefined
       }

package/lib/compile/for/nodejs.js

@@ -9,7 +9,7 @@ module.exports = function cds_compile_for_nodejs (csn,o) {
   dsn = cds.compile.for.odata (csn,o) //> creates a partial copy -> avoid any cds.linked() before
   dsn = unfold_csn (dsn)
   dsn = cds.linked (dsn)
-  if (cds.env.fiori.lean_draft) cds.compile.for.lean_drafts(dsn, o)
+  cds.compile.for.lean_drafts(dsn, o)
   Object.defineProperty (csn, '_4nodejs', {value:dsn})
   Object.defineProperty (dsn, '_4nodejs', {value:dsn})
   TRACE?.timeEnd('cds.compile 4nodejs'.padEnd(22))

package/lib/compile/parse.js

@@ -11,6 +11,8 @@ const parse = module.exports = Object.assign (cds_parse, {
 
   cdl: cds_parse,
   cql: (x,o) => { try { return cdsc.parse.cql(x,undefined,{ messages:[],  ...o }) } catch(e) {
+    // cds-compiler v5 does not put messages into `e.message` anymore; render them explicitly
+    e.message = !e.messages ? e.message : e.toString();
     e.message = e.message.replace('<query>.cds:',`In '${e.cql = x}' at `)
     throw e // with improved error message
   }},
@@ -33,6 +35,8 @@ const parse = module.exports = Object.assign (cds_parse, {
     if (typeof x !== 'string') throw cds.error.expected `${{x}} to be an expression string`
     if (x in keywords) return {ref:[x]}
     try { return cdsc.parse.expr(x,undefined,{ messages:[], ...o }) } catch(e) {
+      // cds-compiler v5 does not put messages into `e.message` anymore; render them explicitly
+      e.message = !e.messages ? e.message : e.toString();
       e.message = e.message.replace('<expr>.cds:1:',`In '${e.expr = x}' at `)
       throw e // with improved error message
     }

package/lib/compile/resolve.js

@@ -34,12 +34,12 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {
     return cached[id] = _resolved ([ _resolve (id,context) ])
-  } catch(e) {/* ignored */}
+  } catch {/* ignored */}
 
   // try to resolve file with one of the suffixes
   for (let tail of o.suffixes || suffixes) try {
     return cached[id] = _resolved ([ _resolve (id+tail,context) ])
-  } catch(e) {/* ignored */}
+  } catch {/* ignored */}
 
   // fetch all in a directory
   if (o.all !== false) try {
@@ -51,12 +51,12 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
       unique[f.slice(0,-4)] || all.push (join(local,f))
     }
     return cached[id] = _resolved (all)
-  } catch(e) {/* ignored */}
+  } catch {/* ignored */}
 
   // fetch file without suffix
   if (o.any !== false && !id.endsWith('/')) try { // NOTE: this also finds .js files!
     return cached[id] = _resolved ([ _resolve (id,context) ])
-  } catch(e) {/* ignored */}
+  } catch {/* ignored */}
 
 }
 

package/lib/compile/to/edm-files.js

@@ -23,7 +23,6 @@ if (isMainThread) {
   const GENERATE = _generate_using_workers // for running in worker threads
   // const GENERATE = _generate_edmxs      // for running in main thread
 
-  // eslint-disable-next-line no-inner-declarations
   async function _generate_using_workers (workerData) {
     await new Promise((resolve, reject) => new Worker (__filename, { workerData })
     .on('error', reject)
@@ -35,7 +34,6 @@ if (isMainThread) {
     exports.get = _read_generated_edmx4
   }
 
-  // eslint-disable-next-line no-inner-declarations
   function _read_generated_edmx4 (srv, kind='edmx', { tenant, features }={}) {
     let dir = path.join (OUT, tenant||'', features||'')
     let file = path.join (dir, srv.definition.name+'.'+kind)
@@ -64,32 +62,27 @@ async function _generate_edmxs ({ csn, dir, services }) {
   const { mkdir, writeFile } = cds.utils.fs.promises
   await mkdir (dir, { recursive: true })
   const cdsc = cds.compiler
-  const promises = []
+  const todos = []
 
   TRACE?.time(`cdsc.generate edmxs`.padEnd(22))
 
-  // call cdsc.to.odata to generate edm/xs
-  let odataVersion = cds.env.odata.version
-  let suffixes = { edmx: '.edmx' }
-  let compile = cdsc.to.edmx // default is edmx only
-  if (!cds.env.features.odata_new_adapter) {
-    compile = cdsc.to.odata // edmx and edm.json
-    suffixes.edm = '.edm.json'
-  }
-
-  let result = compile.all (csn, { serviceNames: services, messages:[] })
-
-  // write edmx files to disk
-  for (let [name,x] of Object.entries(result[odataVersion])) {
-    for (let suffix in suffixes) {
-      let content = suffix === 'edmx'? x[suffix] : JSON.stringify (x[suffix], minify);
-      let file = path.join (dir, name + suffixes[suffix])
-      let p = writeFile (file, content)
-        .then (() => parentPort?.postMessage ({ generated: local(file) }))
-      promises.push(p)
+  if (cds.env.features.odata_new_adapter) { // generate .edmx files only
+    let result = cdsc.to.edmx.all (csn, { serviceNames: services, messages:[] })
+    for (let [name,edmx] of Object.entries(result)) {
+      todos.push ({ file: name + '.edmx', content: edmx })
+    }
+  } else { // generate .edmx files + .edm.json files in addition
+    let result = cdsc.to.odata.all (csn, { serviceNames: services, messages:[] })
+    if (cds.env.odata.version in result) result = result[cds.env.odata.version]
+    for (let [name,x] of Object.entries(result)) {
+      todos.push ({ file: name + '.edmx', content: x.edmx })
+      todos.push ({ file: name + '.edm.json', content: JSON.stringify (x.edm, minify) })
     }
   }
-  await Promise.all (promises)
+
+  await Promise.all (todos.map (({file,content}) => writeFile (path.join(dir,file), content)
+    .then (() => parentPort?.postMessage ({ generated: local(file) }))
+  ))
   TRACE?.timeEnd(`cdsc.generate edmxs`.padEnd(22))
   return true
 }

package/lib/compile/to/hana.js

@@ -0,0 +1,27 @@
+const cds = require('../..')
+const cdsc = require('../cdsc')
+
+module.exports = (csn, o, beforeCsn) => {
+  if (typeof beforeCsn === 'string') beforeCsn = JSON.parse(beforeCsn)
+
+  const { definitions, deletions, migrations, afterImage } = cdsc.to.hdi.migration(cds.minify(csn), o, beforeCsn)
+  let migrationResult = false
+  if (beforeCsn || Object.values(afterImage.definitions).some(def => def['@cds.persistence.journal'])) {
+    migrationResult = true
+  }
+
+  return (function* () {
+    for (const { name, suffix, sql } of definitions) {
+      yield [sql, { file: name + suffix }]
+    }
+    if (deletions.length > 0) {
+      yield [deletions, { file: 'deletions.json' }]
+    }
+    if (migrations.length > 0) {
+      yield [migrations, { file: 'migrations.json' }]
+    }
+    if (migrationResult) {
+      yield [afterImage, { file: 'afterImage.json' }]
+    }
+  })()
+}