@sap/cds 6.8.4 → 7.0.1

package/bin/build/provider/fiori/index.js

@@ -1,171 +0,0 @@
-const path = require('path')
-const cds = require('../../cds')
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const URL = require('url')
-const { getProperty, isOldJavaStack, relativePaths } = require('../../util')
-
-const { ODATA_VERSION_V2, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, BUILD_TASK_FIORI, BUILD_TASK_JAVA_CF, CDS_CONFIG_PATH_SEP, BUILD_TASK_JAVA } = require('../../constants')
-
-/**
- * With cds 4 service metadata for the UI service binding is no longer created by default.
- * For SAP Web IDE Full-Stack compatibility a corresponding metadata.xml is still generated.
- * Though, 'fiori' build tasks can still be configured for UI5 mockserver usage - see https://github.wdf.sap.corp/cap/issues/issues/8673
- */
-class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
-    async prepare() {
-        this.buildOptions.for[BUILD_TASK_FIORI] = this.buildOptions.for[BUILD_TASK_FIORI] || {}
-
-        // cache for later use across multiple FioriAppModuleBuilder instances
-        const fioriBuildOptions = getProperty(this.buildOptions.for, BUILD_TASK_FIORI)
-        fioriBuildOptions.appModel = new Map()
-        fioriBuildOptions.appEdmx = new Map()
-
-        // group tasks that have a common application root folder
-        const appTaskGroups = new Map()
-        this.buildOptions.tasks.forEach(task => {
-            if (task.for === BUILD_TASK_FIORI) {
-                const appFolder = path.relative(this.buildOptions.root, task.src).split(CDS_CONFIG_PATH_SEP)[0]
-                appTaskGroups.has(appFolder) ? appTaskGroups.get(appFolder).push(task) : appTaskGroups.set(appFolder, [task])
-            }
-        })
-
-        // merge all model references to resolve the model later on
-        const appModelGroups = new Map()
-        for (let [appFolder, appTaskGroup] of appTaskGroups.entries()) {
-            const appModels = new Set()
-            appTaskGroup.forEach(task => {
-                if (Array.isArray(task.options.model)) {
-                    task.options.model.forEach(model => appModels.add(model))
-                }
-            })
-            appModelGroups.set(appFolder, appModels)
-        }
-
-        const originFioriBuildOption = fioriBuildOptions[BUILD_OPTION_OUTPUT_MODE]
-        fioriBuildOptions[BUILD_OPTION_OUTPUT_MODE] = OUTPUT_MODE_RESULT_ONLY
-
-        try {
-            const edmxOptions = { version: cds.env.odata?.version }
-
-            if (edmxOptions.version !== ODATA_VERSION_V2) {
-                const javaTask = this.buildOptions.tasks.find(task => task.for === BUILD_TASK_JAVA_CF || task.for === BUILD_TASK_JAVA)
-
-                if (javaTask
-                    && await isOldJavaStack([javaTask.src, this.buildOptions.root])
-                    && !cds.env.for("cds", this.buildOptions.root, false).odata?.version) {
-
-                    // old java stack
-                    // default is now v4 and not v2 anymore, so overwrite with v2 if using default
-                    this.logger.debug("Fiori task is forcing OData v2 for building though the default is v4.")
-                    edmxOptions.version = ODATA_VERSION_V2
-                }
-            }
-
-            for (let [appFolder, appModelGroup] of appModelGroups.entries()) {
-                this.logger.debug(`building module [${appFolder}] using [${this.constructor.name}]`)
-                const modelPaths = cds.resolve(Array.from(appModelGroup.values()), this.buildOptions)
-                if (!modelPaths || modelPaths.length === 0) {
-                    continue
-                }
-                this.logger._debug && this.logger.debug(`model: ${relativePaths(this.buildOptions.root, modelPaths).join(", ")}`)
-
-                //cache model per fiori app root folder
-                const options = this.options()
-                const model = await cds.load(modelPaths, options)
-                fioriBuildOptions.appModel.set(appFolder, model)
-
-                await this.compileToEdmx(model, null, edmxOptions)
-
-                // cache edmx per fiori app root folder
-                fioriBuildOptions.appEdmx.set(appFolder, this._result.edmx)
-            }
-        } finally {
-            fioriBuildOptions[BUILD_OPTION_OUTPUT_MODE] = originFioriBuildOption
-        }
-        return false
-    }
-
-    /**
-     * This version only creates a odata representation for the 'mainService' data source
-     * as defined by the fiori wizard - everything else is currently not supported.
-     * Therefore errors are only logged, the build does not fail in case a service
-     * cannot be resolved based on the defined service URI
-     */
-    async build() {
-        const model = await this.model()
-        if (!model) {
-            return
-        }
-        await this._writeEdmxToWebapp(this.task.src, this.task.dest)
-    }
-
-    async _writeEdmxToWebapp(src, dest) {
-        const manifestPath = path.join(src, 'webapp', 'manifest.json')
-        let manifest
-
-        try {
-            manifest = require(manifestPath)
-        } catch (error) {
-            this.logger.log(`UI module does not contain a manifest.json [${relativePaths(this.buildOptions.root, manifestPath)}], skipping build`)
-            return
-        }
-
-        const mainService = getProperty(manifest, ['sap.app', 'dataSources', 'mainService'])
-        if (!mainService) {
-            // no mainService defined - not supported
-            this.logger._debug && this.logger.debug(`UI module does not have a datasource [mainService], [${relativePaths(this.buildOptions.root, manifestPath)}], skipping build`)
-            return
-        }
-
-        const localUri = getProperty(mainService, ['settings', 'localUri'])
-        const uri = mainService.uri
-
-        if (!localUri || !uri) {
-            this.logger._debug && this.logger.warn(`local uri setting missing for data source [mainService], [${relativePaths(this.buildOptions.root, manifestPath)}]`)
-            return
-        }
-
-        const appFolder = path.relative(this.buildOptions.root, src).split(CDS_CONFIG_PATH_SEP)[0]
-        const model = this.getBuildOption("appModel").get(appFolder)
-        if (!model) {
-            this.logger.error(`failed to load model for service uri ${uri}, data source [mainService]`)
-            return
-        }
-
-        const edmx = this._getEdmxForUri(model, appFolder, uri)
-        if (!edmx) {
-            this.logger.error(`failed to resolve service definition for service uri ${uri}, data source [mainService]`)
-            return
-        }
-
-        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            const edmxPath = path.resolve(path.join(dest, 'webapp'), this._strippedUrlPath(localUri))
-            return this.write(edmx).to(edmxPath)
-        }
-    }
-
-    _getEdmxForUri(model, appFolder, uri) {
-        const uriSegments = this._strippedUrlPath(uri).split('/')
-
-        // one segment of the URI has to match a service name
-        // NOTE: assumption is that the service definition can be resolved - either by
-        // - defining corresponding using statement in annotations model or
-        // - adding the service module folder to the model option
-        let service = cds.reflect(model).find(service => uriSegments.find(segment => service.name === segment))
-
-        if (service) {
-            const allServices = this.getBuildOption("appEdmx").get(appFolder)
-            if (allServices) {
-                return allServices.get(service.name + ".xml")
-            }
-        }
-        return null
-    }
-
-    _strippedUrlPath(urlString) {
-        const url = URL.parse(urlString)
-        return url.pathname.replace(/^(\/|\\)/, '').replace(/(\/|\\)$/, '') // strip leading and trailing slash or backslash)
-    }
-}
-
-module.exports = FioriAppModuleBuilder

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

@@ -1,179 +0,0 @@
-const path = require('path')
-const parser = require('./migrationtable')
-const { BuildError, hasOptionValue } = require('../../util')
-const { LOG_MODULE_NAMES } = require('../../constants')
-const cds = require('../../cds'), { compiler: cdsc } = cds
-const cdscVersion = `-- generated by cds-compiler version ${cdsc.version()}`
-const { getArtifactCdsPersistenceName } = cdsc
-let logger = cds.log(LOG_MODULE_NAMES)
-const ANNO_PERSISTENCE_JOURNAL = '@cds.persistence.journal'
-
-module.exports = async (model, lastDevVersion, srcPath, options = {}) => {
-  if (options.logger) {
-    logger = options.logger
-  }
-
-  const journalFileNames = _getJournalFileNames(model)
-  const { definitions, deletions, migrations, afterImage } = _toHdiMigration(model, lastDevVersion, journalFileNames, options)
-  const definitionResult = []
-
-  for (const { name, suffix, sql } of definitions) {
-    let definitionEntry = { name, suffix, content: sql }
-
-    if (suffix === '.hdbtable') {
-      if (journalFileNames.has(name)) {
-        const migration = migrations.find(migration => migration.name === name)
-        definitionEntry = await _2migrationtable(srcPath, migration || _emptyMigration(name), sql)
-      }
-    }
-    if (definitionEntry) {
-      definitionResult.push(definitionEntry)
-    }
-  }
-  return { definitions: definitionResult, deletions, afterImage: _filterJournalArtifacts(afterImage) }
-}
-
-function _toHdiMigration(model, lastDevVersion, journalFileNames, options) {
-  const result = cdsc.to.hdi.migration(cds.minify(model), options, lastDevVersion);
-  if (logger._debug) {
-    logger.debug('cdsc.to.hdi.migration returned')
-    for (const { name, suffix, sql } of result.definitions) {
-      if (suffix === '.hdbtable' || suffix === '.hdbmigrationtable') {
-        if (journalFileNames.has(name)) {
-          const migration = result.migrations.find(migration => migration.name === name)
-          logger.debug(`
-File ${name + '.hdbmigrationtable'} - ${migration ? migration.changeset.length : 0} new changes
-${sql}
-${migration ? migration.changeset.map(change => change.sql).join('\n') : 'Empty changeset'}
-`)
-        }
-      }
-    }
-  }
-  return result
-}
-
-/**
- * Returns an object providing access to the .hdbmigrationtable file content and its corresponding filename.
- *
- * @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'.
- */
-async function _2migrationtable(srcPath, migration, tableSql) {
-  let migrationTableModel = null
-  const file = path.join(srcPath, migration.name + migration.suffix)
-  try {
-    migrationTableModel = await parser.read(file)
-  } catch (e) {
-    // abort build in order to ensure consistent afterImage model state / hdbmigrationtable file state
-    throw new BuildError(`${path.relative(process.cwd(), file)}: ${e.message}`)
-  }
-
-  if (migrationTableModel) {
-    // adding new changeset if change exist, ignore otherwise
-    const migrationEntry = _getNewMigrationEntry(migration.changeset, migrationTableModel.versionNumber)
-    if (migrationEntry) {
-      const versionNumber = migrationTableModel.versionNumber + 1
-      const migrationCount = migrationTableModel.migrations.entries.length
-      const migrations = `${migrationEntry.content}${migrationCount > 0 ? '\n' : ''}${migrationTableModel.migrations.toString()}${migrationCount > 0 ? '\n' : ''}`
-      return {
-        name: migration.name,
-        suffix: migration.suffix,
-        content: `== version=${versionNumber}\n${tableSql}\n\n${migrations}`,
-        changed: true,
-        dropColumns: migrationEntry.dropColumns
-      }
-    } else {
-      // existing migration file version
-      return { name: migration.name, suffix: migration.suffix, content: migrationTableModel.toString(), changed: false }
-    }
-  }
-  // initial migration file version
-  return { name: migration.name, suffix: migration.suffix, content: `== version=1\n${tableSql}\n`, changed: true }
-}
-
-function _getNewMigrationEntry(changeset, currentVersion) {
-  if (changeset && changeset.length > 0) {
-    const dropColumns = changeset.some(e => e.drop)
-    const manualChange = changeset.some(e => !e.sql)
-    const enableDrop = cds.env.hana?.journal?.['enable-drop']
-    const content = changeset.reduce((acc, e) => {
-      if (!acc) {
-        acc = `== migration=${currentVersion + 1}\n`
-        acc += `${cdscVersion}\n`
-
-        if (dropColumns && enableDrop !== true) {
-          acc += `>>>>> Manual resolution required - DROP statements causing data loss are disabled by default.
->>>>> You may either:
->>>>>   uncomment statements to allow incompatible changes, or
->>>>>   refactor statements, e.g. replace DROP/ADD by single RENAME statement
->>>>> After manual resolution delete all lines starting with >>>>>\n`
-        } else if (manualChange) {
-          acc += `>>>>> Manual resolution required - insert ALTER statement(s) as described below.
->>>>> After manual resolution delete all lines starting with >>>>>\n`
-        }
-      }
-      if (e.sql) {
-        if (e.drop && enableDrop !== true) {
-          acc += `${e.sql.replace(/^/gm, '-- ')}\n`;
-        } else {
-          acc += `${e.sql}\n`
-        }
-      } else {
-        acc +=
-          `>>>>> Insert ALTER statement for: ${e.description}\n`
-      }
-      return acc
-    }, null)
-    return { dropColumns, content }
-  }
-  return null
-}
-
-function _emptyMigration(name) {
-  return { name, suffix: ".hdbmigrationtable", changeset: [] }
-}
-
-function _getJournalFileNames(model) {
-  const journalNames = new Set(cds.reflect(model).all(item => {
-    if (item.kind === 'entity' && item[ANNO_PERSISTENCE_JOURNAL] === true) {
-      if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
-        logger.warn(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`)
-      }
-      return true
-    }
-    return false
-  }).map(entity => getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')))
-
-  logger._debug && logger.debug(`\n[hdbmigrationtable] found ${journalNames.size} model entities annotated with '@cds.persistence.journal`)
-  logger._debug && logger.debug(`[hdbmigrationtable] ${[...journalNames].join(', ')}\n`)
-
-  return journalNames
-}
-
-// delete all entities that are not relevant
-function _filterJournalArtifacts(csn) {
-  if (!csn) {
-    return
-  }
-  const dict = csn.definitions
-  for (const name in dict) {
-    if (!_isPersistedAsJournalTable(dict[name])) {
-      delete dict[name]
-    }
-  }
-  // mark CSN as modified by cds build
-  csn.meta.build = `CDS Build v${cds.version}`
-  return csn;
-}
-
-// see cds-compiler/lib/model/csnUtils.js#isPersistedAsTable
-function _isPersistedAsJournalTable(artifact) {
-  return artifact.kind === 'entity' && hasOptionValue(artifact['@cds.persistence.journal'], true) &&
-    !artifact.abstract &&
-    !hasOptionValue(artifact['@cds.persistence.skip'], true) &&
-    !hasOptionValue(artifact['@cds.persistence.exists'], true) &&
-    (!artifact.query && !artifact.projection || hasOptionValue(artifact['@cds.persistence.table'], true))
-}