@sap/cds-dk 6.8.3 → 7.0.0

package/lib/build/provider/buildTaskHandlerFeatureToggles.js

@@ -0,0 +1,132 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../cds')
+const { DEFAULT_CSN_FILE_NAME, OUTPUT_MODE, OUTPUT_MODE_RESULT } = require('../constants')
+const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
+
+class FeatureToggleBuilder extends BuildTaskHandlerInternal {
+    init() {
+        if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+            this._result = {
+                dest: this.task.dest,
+                edmx: new Map(),
+                languages: new Set(),
+                services: new Set()
+            }
+        }
+    }
+
+    get ftsName() {
+        return path.dirname(cds.env.features.folders || 'fts/*')
+    }
+
+    async compileAll(csn, destBase, destFts) {
+        const sources = await this._resolveSourcePaths(csn)
+        const dictionary = { base: null, features: null }
+
+        if (sources.features) {
+            // create base model as the given CSN is containing all features
+            dictionary.base = await cds.load(sources.base, this.options())
+        } else {
+            // CSN already represents the base model as no features exist
+            dictionary.base = csn
+        }
+        // preserve @location as @source properties
+        const csnStr = await this.compileToJson(dictionary.base, path.join(destBase, DEFAULT_CSN_FILE_NAME))
+        const csnModel = JSON.parse(csnStr)
+        csnModel.meta = csn.meta
+        if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+            this._result.csn = csnModel
+        }
+
+        if (sources.features) {
+            dictionary.features = await this._compileFeatures(sources.features, destBase, destFts, dictionary.base)
+        }
+        return { dictionary, sources }
+    }
+
+    async collectAllLanguageBundles(dictionary, paths, destBase, destFts) {
+        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
+        // create language bundle for base model
+        const i18n = await this.collectLanguageBundles(dictionary.base, path.join(destBase, i18nFolder))
+        if (i18n && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+            this._result.languageBundles = i18n.bundles
+        }
+
+        if (dictionary.features) {
+            // create language bundles for all features
+            for (const ftName in dictionary.features) {
+                // attach the sources information for i18n location reference
+                dictionary.features[ftName]['$sources'] = paths.features[ftName]
+                await this.collectLanguageBundles(dictionary.features[ftName], path.join(destFts, this.ftsName, ftName, i18nFolder))
+            }
+        }
+    }
+
+    async _resolveSourcePaths(csn) {
+        const regex = new RegExp(path.resolve(cds.root, this.ftsName).replace(/\\/g, '\\\\') + '[/|\\\\](?<ftName>[^/|\\\\]*)')
+        let paths = { base: [] }
+
+        // add ROOT source file paths for the base model
+        paths.base = this._resolveModel().reduce((acc, file) => {
+            const match = file.match(regex)
+            if (!match) {
+                acc.push(file)
+            }
+            return acc
+        }, [])
+
+        // keep existing behavior and return paths returned by cds.resolve if features are not supported by this project
+        if (!fs.existsSync(path.join(cds.root, this.ftsName))) {
+            return paths
+        }
+
+        // add source file paths for the features
+        paths.features = csn['$sources'].reduce((acc, file) => {
+            const match = file.match(regex)
+            if (match) {
+                const { ftName } = match.groups
+                //feature
+                if (!acc[ftName]) {
+                    acc[ftName] = []
+                }
+                acc[ftName].push(file)
+            }
+            return acc
+        }, {})
+
+        return paths
+    }
+
+    async _compileFeatures(ftsPaths, destBase, destFts, baseCsn) {
+        if (!ftsPaths) {
+            return
+        }
+        const features = {}
+        const options = { ...this.options(), flavor: 'parsed' }
+
+        // create feature models
+        for (const ftName in ftsPaths) {
+            const ftCsn = await cds.load(ftsPaths[ftName], options)
+            const ftPath = path.join(destFts, this.ftsName, ftName)
+
+            // replace require paths by base model path to ensure precedence of feature annotations
+            // see https://pages.github.tools.sap/cap/docs/cds/compiler-messages#anno-duplicate-unrelated-layer
+            ftCsn.requires = [path.join(path.relative(ftPath, destBase), DEFAULT_CSN_FILE_NAME).replace(/\\/g, '/')]
+
+            await this.compileToJson(ftCsn, path.join(ftPath, DEFAULT_CSN_FILE_NAME))
+            this._validateFeature(ftCsn, baseCsn)
+            features[ftName] = ftCsn
+        }
+        return features
+    }
+
+    _validateFeature(ftCsn, baseCsn) {
+        // features must not have other dependencies than base model dependencies - cross feature dependencies are not supported
+        // do not pass options.messages in order to avoid duplicate compiler messages
+        // version 2.13.9 of compileSources does not read the requires definition of parsed CSNs
+        cds.compiler.compileSources({ '../..csn.json': baseCsn, 'feature.csn': ftCsn }, this.options())
+    }
+}
+
+module.exports = FeatureToggleBuilder

package/lib/build/provider/buildTaskHandlerInternal.js

@@ -0,0 +1,228 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../cds')
+const BuildTaskHandler = require('../buildTaskHandler')
+const { hasOptionValue } = require('../util')
+const { FOLDER_GEN } = require('../constants')
+
+class BuildTaskHandlerInternal extends BuildTaskHandler {
+    /**
+     * Returns the logger that has been passed the build task engine.
+     * @returns {object}
+     */
+    get logger() {
+        //injected by framework
+        return this._logger;
+    }
+    /**
+     * Custom build handlers are executed before internal handlers in order
+     * ensure and content cannot be overwritten by mistake.
+     */
+    get priority() {
+        return BuildTaskHandlerInternal.PRIORITY_MAX_VALUE
+    }
+
+    async clean() {
+        // build results are deleted by the BuildTaskEngine if the build.target !== '.'
+        // make sure that src is not a subfolder of dest
+        if (cds.env.build.target === '.' && this.task.src !== this.task.dest && !this._isSubDirectory(this.task.dest, this.task.src)) {
+            await fs.promises.rm(this.task.dest, { force: true, recursive: true })
+        }
+    }
+    /**
+     * Maximum allowed priority for internal build tasks.
+     */
+    static get PRIORITY_MAX_VALUE() {
+        return 0;
+    }
+    /**
+     * Minimum allowed priority for custom build tasks.
+     */
+    static get PRIORITY_MIN_VALUE() {
+        return Number.MIN_SAFE_INTEGER;
+    }
+
+    /**
+     * Called by the framework after {@link #init()}. Handlers may want to perform more elaborate preparation.
+     * E.g. caching some pre-calculated data that can be used across multiple build tasks. This kind of data
+     * has to be stored in the handler type specific buildOptions section.
+     * @returns {Promise<boolean>} A value 'false' indicates that {@link #prepare()} will not be called for other instances
+     * of this handler type.
+     * True indicates that {@link #prepare()} will be called for other instances of this of this handler type.
+     * @deprecated
+     */
+    async prepare() {
+        // cancel subsequent prepare calls for other handlers of the same type by default
+        return false
+    }
+
+    /**
+     * Returns whether cds env has a property with the specified value.
+     * If the value is omitted the existence of the given property name is checked.
+     * @param {string} qualifiedName
+     * @param {any=} value
+     */
+    hasCdsEnvOption(qualifiedName, value) {
+        return hasOptionValue(cds.env.get(qualifiedName), value)
+    }
+
+    /**
+     * Determines whether the given build option value has been set for this build task.
+     * If the value is omitted, the existence of the given property name is checked.
+     * @param {string} qualifiedName
+     * @param {any=} value
+     */
+    hasBuildOption(qualifiedName, value) {
+        return hasOptionValue(this._getBuildOption(qualifiedName), value)
+    }
+
+    /**
+     * Returns the value of the given build option defined for this build task.
+     * @param {string} qualifiedName
+     */
+    getBuildOption(qualifiedName) {
+        return super._getBuildOption(qualifiedName)
+    }
+
+    /**
+    * Returns a list of CDS model files defining the transitive closure of the CDS model based on the model options
+    * defined for this build task.
+    */
+    resolveModel() {
+        return this._resolveModel()
+    }
+
+    /**
+     * Returns whether the build results of this build plugin are created inplace
+     * or in a separate staging folder which is not part of the build tasks src folder.
+     */
+    isStagingBuild() {
+        return !this.task.src.startsWith(this.task.dest)
+    }
+
+    async copyNativeContent(srcDir, destDir, customFilter) {
+        const files = BuildTaskHandlerInternal._find(srcDir, (src) => {
+            // do not copy files that:
+            // - from 'cds.env.build.target'
+            // - from 'dest'
+            // - from some generation folder
+            // - do not match filter function
+            return this._commonStagingBuildFilter(src, destDir) && (!customFilter || customFilter.call(this, src))
+        })
+        return Promise.all(
+            files.map((srcFile) => {
+                let relFile = path.relative(srcDir, srcFile)
+                let destFile = path.join(destDir, relFile)
+                return this.copy(srcFile).to(destFile)
+            })
+        )
+    }
+
+    async compileToJson(model, csnFile) {
+        // This will als add a @source prop containing the relative path to the origin .cds source file
+        // and a parsed _where clause for @restrict.{grant,where} annotations.
+        // The @source annotation is required for correct custom handler resolution if no @impl annotation has been defined as
+        // custom service handler implementations are relative to the origin .cds source files.
+        // For staging builds (task.src !== task.dest) the csn.json file that is served at runtime is copied into a corresponding srv subfolder.
+        // As a consequence the src folder name has to be included in the @source file name while for inplace builds (task.src === task.dest) this is not the case.
+        // This ensures that the paths are relative to the cwd when executing cds run.
+        const jsonOptions = {
+            cwd: cds.root,
+            src: this.task.src
+        }
+        const csnStr = cds.compile.to.json(model, jsonOptions)
+        await this.write(csnStr).to(csnFile)
+        return csnStr
+    }
+
+    /**
+     * Collect and write language bundles into a single i18n.json file.
+     * @param {Object} model
+     * @param {string} bundleDest
+     */
+    async collectLanguageBundles(model, bundleDest) {
+        // collect effective i18n properties...
+        let bundles = {}
+        const bundleGenerator = cds.localize.bundles4(model)
+        if (bundleGenerator && bundleGenerator[Symbol.iterator]) {
+            for (let [locale, bundle] of bundleGenerator) {
+                // fallback bundle has the name ""
+                if (typeof locale === 'string') {
+                    bundles[locale] = bundle
+                }
+            }
+        }
+
+        // omit bundles in case the fallback bundle is the only existing entry
+        const keys = Object.keys(bundles)
+        if (keys.length === 1 && keys[0] === "" && Object.keys(bundles[keys[0]]).length === 0) {
+            bundles = {}
+        }
+        // copied from ../compile/i18n.js
+        const { file: base = 'i18n' } = cds.env.i18n
+        const file = path.join(bundleDest, base + '.json')
+
+        // bundleDest might be null
+        if (bundleDest && Object.keys(bundles).length > 0) {
+            await this.write(bundles).to(file)
+            return { file, bundles }
+        }
+        return null
+    }
+
+    _isSubDirectory(parent, child) {
+        return !path.relative(parent, child).startsWith('..')
+    }
+
+    _commonStagingBuildFilter(src, destDir) {
+        if (typeof src !== "string" || typeof destDir !== "string") {
+            return false
+        }
+        if (!fs.statSync(src).isDirectory()) {
+            return true //file
+        }
+        if (src === destDir) {
+            return false
+        }
+        const regex = new RegExp(FOLDER_GEN + "\\b")
+        if (src === path.resolve(cds.root, cds.env.build.target)) {
+            return false
+        }
+        return !regex.exec(path.basename(src))
+    }
+
+    static _find(srcDir, filter) {
+        const files = []
+        this._traverseFileSystem(srcDir, files, filter)
+        return files;
+    }
+
+    static _traverseFileSystem(srcDir, files, filter) {
+        let entries = []
+        try {
+            entries = fs.readdirSync(srcDir)
+        } catch (e) {
+            // ignore if not existing
+        }
+        entries.map(subDirEntry => path.join(srcDir, subDirEntry)).forEach((entry) => {
+            this._handleResource(entry, files, filter)
+        })
+    }
+
+    static _handleResource(entry, files, filter) {
+        if (!filter || filter.call(this, entry)) {
+            var stats = this._getResourceStatus(entry)
+            if (stats.isDirectory()) {
+                this._traverseFileSystem(entry, files, filter)
+            } else if (stats.isFile() || stats.isSymbolicLink()) {
+                files.push(entry)
+            }
+        }
+    }
+
+    // for testing purposes
+    static _getResourceStatus(entry) {
+        return fs.lstatSync(entry)
+    }
+}
+module.exports = BuildTaskHandlerInternal