@sap/cds 6.8.4 → 7.0.1

package/bin/build/provider/buildTaskHandlerInternal.js

@@ -1,254 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const cds = require('../cds')
-const BuildTaskHandler = require('../buildTaskHandler')
-const { hasOptionValue } = require('../util')
-const { FOLDER_GEN, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = 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;
-    }
-    /**
-     * Returns the build options used for this CDS build execution
-     * @returns {object}
-     */
-    get buildOptions() {
-        return this._buildOptions
-    }
-    /**
-     * 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() {
-        // the build results have already been deleted by the BuildTaskEngine if the build.target !== '.'
-        // make sure that src is not a subfolder of dest
-        if (this._buildOptions.root === this._buildOptions.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 })
-        }
-    }
-
-    /**
-     * Used by the framework to initialize the logger implementation.
-     * @param {object} logger
-     */
-    set logger(logger) {
-        super.logger = logger;
-    }
-    /**
-     * Sets the build options used for this CDS build execution
-     * @param {object} options
-     */
-    set buildOptions(options) {
-        super.buildOptions = options
-    }
-    /**
-     * 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:
-            // - are contained in the 'buildOptions.target' folder
-            // - are contained in this modules 'dest' folder
-            // - are contained in some generation folder
-            // - do NOT fulfill additional specific filter criteria
-            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: this.buildOptions.root,
-            src: this.task.src === this.task.dest ? this.task.src : this.buildOptions.root
-        }
-        const csnStr = cds.compile.to.json(model, jsonOptions)
-        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            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) {
-            if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                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 === this.buildOptions.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

package/bin/build/provider/buildTaskProviderInternal.js

@@ -1,383 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const cds = require('../cds')
-const { hasJavaNature, getProperty, isStreamlinedMtx, getDefaultModelOptions, BuildError, hasOptionValue } = require('../util')
-const BuildTaskProvider = require('../buildTaskProvider')
-
-const { FILE_EXT_CDS, BUILD_TASK_HANA, BUILD_TASK_FIORI, BUILD_TASK_JAVA, BUILD_TASK_JAVA_CF, BUILD_TASK_NODEJS, BUILD_TASK_NODE_CF, BUILD_TASK_MTX,
-    BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION, NODEJS_MODEL_EXCLUDE_LIST,
-    DEFAULT_BUILT_IN_MODELS } = require("../constants")
-
-class BuildTaskProviderInternal extends BuildTaskProvider {
-    constructor(logger) {
-        super()
-        this._logger = logger
-    }
-    get logger() {
-        return this._logger
-    }
-
-    canHandleTask(task) {
-        return BUILD_TASKS.includes(task.for)
-            || task.use && task.use.startsWith(BUILD_TASK_PREFIX)
-        // support different build task implementations of the same build task ID defined by 'for'
-        //return (BUILD_TASKS.includes(task.for) && !task.use) || (task.use && task.use.startsWith(BUILD_TASK_PREFIX))
-    }
-
-    loadHandler(task) {
-        return require(`./${BuildTaskProviderInternal._getForValueFromTask(task)}`)
-    }
-
-    async lookupTasks(tasks, buildOptions) {
-        return this._createTasks(tasks, buildOptions, tasks.length > 0)
-    }
-
-    async applyTaskDefaults(task, buildOptions) {
-        const taskFor = BuildTaskProviderInternal._getForValueFromTask(task)
-        const { root: projectPath } = buildOptions
-        task.for = task.for || taskFor
-        task.use = task.use || `${BUILD_TASK_PREFIX}/${taskFor}`
-
-        BuildTaskProviderInternal._setDefaultSrcFolder(task)
-
-        // src folder needs to be initialized first
-        BuildTaskProviderInternal._setDefaultModel(task, projectPath)
-    }
-
-    async _createTasks(tasks, buildOptions, addRequiredTasks) {
-        const { root: projectPath } = buildOptions
-        let db = typeof cds.env.folders.db === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.db)] : cds.env.folders.db
-        let srv = typeof cds.env.folders.srv === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.srv)] : cds.env.folders.srv
-
-        const dbOptions = {
-            model: []
-        }
-        const srvOptions = {
-            model: []
-        }
-        if (Array.isArray(db) && db.length > 0) {
-            db = BuildTaskProviderInternal._getModuleFolder(projectPath, db) || null
-            if (!db && !addRequiredTasks) { // log once
-                this.logger.debug("No database module found")
-            }
-        }
-        if (Array.isArray(srv) && srv.length > 0) {
-            srv = BuildTaskProviderInternal._getModuleFolder(projectPath, srv) || null
-            if (!srv && !addRequiredTasks) { // log once
-                this.logger.debug("No service module found")
-            }
-        }
-        // create required build tasks
-        if (addRequiredTasks) {
-            const mtxTask = tasks.find(task => task.for === BUILD_TASK_MTX || task.for === BUILD_TASK_MTX_SIDECAR)
-            if (mtxTask) {
-                //restore used tasks as they might have been filtered by 'cds build --for mtx'
-                if (mtxTask._uses) {
-                    mtxTask._uses.map(use => use.task).forEach(task => {
-                        if (!tasks.includes(task)) {
-                            tasks.push(task)
-                        }
-                    })
-                }
-                let dbTask = tasks.find(task => task.for === BUILD_TASK_HANA)
-                if (!dbTask) {
-                    //  db task might be missing if mtx task is enforced by 'cds build --for mtx'
-                    dbTask = this._createDbTask(projectPath, db, dbOptions)
-                    if (dbTask) {
-                        tasks.push(dbTask)
-                    }
-                }
-                if (dbTask && (!mtxTask._uses || !mtxTask._uses.map(use => use.task).includes(dbTask))) {
-                    const use = { task: dbTask }
-                    mtxTask._uses ? mtxTask._uses.push(use) : mtxTask._uses = [use]
-                }
-            }
-        } else {
-            !db && this.logger._debug && this.logger.debug(`project doesn't have a database module '${cds.env.folders.db}'`)
-            !srv && this.logger._debug && this.logger.debug(`project doesn't have a service module '${cds.env.folders.srv}'`)
-
-            // create hana build task
-            const dbTask = this._createDbTask(projectPath, db, dbOptions, buildOptions)
-            if (dbTask) {
-                tasks.push(dbTask)
-            }
-            // create java or node build task
-            const srvTask = this._createSrvTask(projectPath, srv, srvOptions)
-            if (srvTask) {
-                tasks.push(srvTask)
-            }
-
-            // REVISIT: disable for cds-dk projectReader - causing error due to inconsistent state during project creation
-            if (buildOptions.resolve !== false) {
-                // create mtx build task
-                const mtxTask = this._createMtxTask(projectPath, srv, srv, tasks)
-                if (mtxTask) {
-                    tasks.push(mtxTask)
-                }
-            }
-        }
-    }
-
-    _createDbTask(projectPath, src, taskOptions, buildOptions) {
-        this.logger.debug("determining database kind.")
-        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
-            return null
-        }
-        let task = null
-        if (this._useHana(projectPath, buildOptions)) {
-            this.logger.debug("found HANA database.")
-            // legacy build supports dest property
-            const compileDest = cds.env.data?.dest
-            if (compileDest) {
-                //../db/src/gen
-                // compileDest is relative to src folder in modular build - resolve correctly
-                taskOptions.compileDest = path.relative(path.resolve(projectPath, src), path.resolve(projectPath, compileDest))
-            }
-            task = {
-                src: src,
-                for: BUILD_TASK_HANA,
-                options: taskOptions
-            }
-        } else {
-            this.logger.debug("found sqlite database - skipping HANA build task")
-        }
-        return task
-    }
-
-    _useHana(projectPath, buildOptions) {
-        if (getProperty(buildOptions, "for.hana.skipManifestGeneration") // deprecated fallback for webide fullstack and mtx
-            || getProperty(buildOptions, "for.hana.contentManifest") === false // fallback for webide fullstack and mtx
-            || cds.env.requires.db?.kind === "hana"
-            || cds.env.requires.db?.dialect === "hana") {
-
-            return true
-        }
-        // false if other db has been defined
-        if (cds.env.requires.db?.kind) {
-            return false
-        }
-        // check whether cds config represents a legacy build system config for which requires.db was not configured
-        // Note: compat layer sets requires.db: {}
-        const userEnv = cds.env.for("cds", projectPath, false)
-        return userEnv && (userEnv.data?.model || userEnv.service?.model)
-    }
-
-    _createMtxTask(projectPath, src, dest, tasks) {
-        this.logger.debug("determining mtx version of nodejs project")
-
-        // preserve order of creation
-        if (BuildTaskProviderInternal._isMtxExtension()) {
-            this.logger.debug("MTX extension app")
-            return { for: BUILD_TASK_MTX_EXTENSION }
-        }
-
-        if (isStreamlinedMtx()) {
-            const sidecarPath = path.join(projectPath, MTX_SIDECAR_FOLDER)
-            let sidecarEnv
-            if (fs.existsSync(sidecarPath)) {
-                sidecarEnv = cds.env.for("cds", sidecarPath)
-            }
-            if (
-                cds.env.profiles?.includes('with-mtx-sidecar') || // new presets
-                cds.env.requires["cds.xt.ModelProviderService"]?.external // for compatibility with former mtxs presets
-            ) {
-                this.logger.debug("MTX app with sidecar")
-                if (!sidecarEnv) {
-                    throw new BuildError(`MTX sidecar directory '${sidecarPath}' not existing. Custom build task configuration required if the folder is named differently.`)
-                }
-                if (!sidecarEnv.requires["cds.xt.ModelProviderService"]?._in_sidecar) {
-                    // correct profile might have been set, but couldn't be resolved
-                    if (sidecarEnv.profiles?.includes('mtx-sidecar')) {
-                        throw new BuildError('MTX configuration cannot be resolved. Make sure an up-to-date version of @sap/cds-mtxs is installed.')
-                    }
-                    throw new BuildError(`Invalid MTX sidecar configuration - profile 'mtx-sidecar' not set.`)
-                }
-                return { for: BUILD_TASK_MTX_SIDECAR }
-            }
-            if (sidecarEnv?.requires["cds.xt.ModelProviderService"]?._in_sidecar || sidecarEnv?.profiles?.includes('mtx-sidecar')) {
-                throw new BuildError(`MTX sidecar requires profile 'with-mtx-sidecar' in project root configuration.`)
-            }
-
-            if (cds.env.requires["cds.xt.ModelProviderService"]?._in_sidecar || cds.env.profiles?.includes('mtx-sidecar')) {
-                // cds build is executed in sidecar folder
-                throw new BuildError(`Seems that you are executing 'cds build' in the 'mtx/sidecar' folder. Execute 'cds build' in the project root folder instead.`)
-            }
-
-            // without sidecar
-            if (!tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
-                this.logger.debug("Nodejs MTX app without sidecar")
-                return {
-                    for: BUILD_TASK_MTX,
-                    src
-                }
-            }
-        }
-        if (!tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
-            if (cds.env.requires.multitenancy) {
-                this.logger.debug("Nodejs Classic MTX app without sidecar")
-                return {
-                    src: ".",
-                    for: BUILD_TASK_MTX,
-                    dest
-                }
-            }
-        }
-    }
-
-    _createSrvTask(projectPath, src, taskOptions) {
-        this.logger.debug("determining implementation technology")
-        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
-            return null
-        }
-        let task = null
-        if (BuildTaskProviderInternal._hasJavaNature(projectPath, src)) {
-            task = this._createJavaTask(projectPath, src, taskOptions)
-        } else {
-            task = this._createNodeTask(src, taskOptions)
-        }
-        return task
-    }
-
-    _createJavaTask(projectPath, src, taskOptions) {
-        this.logger.debug("found implementation technology java")
-        // legacy build supports dest property
-        const compileDest = cds.env.service?.dest
-        if (compileDest) {
-            // compileDest is relative to src folder in modular build - resolve correctly
-            taskOptions.compileDest = path.relative(path.resolve(projectPath, src), path.resolve(projectPath, compileDest))
-        }
-        return {
-            src: src,
-            for: BUILD_TASK_JAVA,
-            options: taskOptions
-        }
-    }
-
-    _createNodeTask(src, taskOptions) {
-        this.logger.debug("found implementation technology node")
-        return {
-            src: src,
-            for: BUILD_TASK_NODEJS,
-            options: taskOptions
-        }
-    }
-
-    static _isMtxExtension() {
-        return !!cds.env.extends
-    }
-
-    static _setDefaultSrcFolder(task) {
-        switch (task.for) {
-            case BUILD_TASK_HANA:
-                task.src = task.src || this._normalizePath(cds.env.folders.db)
-                break
-            case BUILD_TASK_JAVA:
-            case BUILD_TASK_JAVA_CF:
-            case BUILD_TASK_NODEJS:
-            case BUILD_TASK_NODE_CF:
-                task.src = task.src || this._normalizePath(cds.env.folders.srv)
-                break
-            case BUILD_TASK_FIORI:
-                task.src = task.src || this._normalizePath(cds.env.folders.app)
-                break
-            case BUILD_TASK_MTX_SIDECAR:
-                task.src = task.src || MTX_SIDECAR_FOLDER
-                break
-            case BUILD_TASK_MTX_EXTENSION:
-                task.src = task.src || "."
-                break
-            case BUILD_TASK_MTX:
-                if (isStreamlinedMtx()) {
-                    task.src = task.src || this._normalizePath(cds.env.folders.srv)
-                } else {
-                    task.src = task.src || "."
-                }
-                break
-            default:
-                throw new Error(`Unknown build task '${task.use || task.for}'`)
-        }
-    }
-
-    static _setDefaultModel(task, projectPath) {
-        let taskModelPaths = task.options?.model
-        if (taskModelPaths && !Array.isArray(taskModelPaths)) {
-            taskModelPaths = [taskModelPaths]
-        }
-        task.options = task.options || {}
-        let defaultModelPaths = []
-        // add default models to custom build tasks if this hasn't been disabled
-        if (taskModelPaths?.length) {
-            if (!hasOptionValue(task.options?.[DEFAULT_BUILT_IN_MODELS], false)) {
-                // get the built-in models
-                defaultModelPaths = getDefaultModelOptions(projectPath).filter(p => p.match('@sap/cds'))
-            }
-        } else {
-            defaultModelPaths = getDefaultModelOptions(projectPath)
-            defaultModelPaths.push(task.src)
-            if (hasOptionValue(task.options?.[DEFAULT_BUILT_IN_MODELS], false)) {
-                // all default models except the built-in models
-                defaultModelPaths = defaultModelPaths.filter(p => !p.match('@sap/cds'))
-            }
-        }
-
-        // REVISIT: filter nodejs bootstrap service models for Java - issues/12770#issuecomment-1805719
-        if (this._hasJavaNature(projectPath, cds.env.folders.srv)) {
-            defaultModelPaths = defaultModelPaths.filter(p => !NODEJS_MODEL_EXCLUDE_LIST.includes(p))
-        }
-        // also add built-in models to custom build tasks already containing model options
-        if (!taskModelPaths || defaultModelPaths.length) {
-            task.options.model = [...new Set(taskModelPaths?.length ? taskModelPaths.concat(defaultModelPaths) : defaultModelPaths)]
-        }
-    }
-
-    /**
-     * Returns whether this project is a java project or not.
-     * @param {string} projectPath - the absolute project path
-     * @param {string} srv - the folder name of the service module
-     */
-    static _hasJavaNature(projectPath, srv) {
-        srv = this._getModuleFolder(projectPath, Array.isArray(srv) ? srv : [srv])
-        return hasJavaNature([projectPath, srv && path.join(projectPath, srv)])
-    }
-
-    static _getForValueFromTask(task) {
-        return task.for ? task.for : task.use && task.use.substring(BUILD_TASK_PREFIX.length + 1)
-    }
-
-    /**
-     * For valid paths remove trailing '/'. Otherwise return as is - important!!
-     * @param {*} dir
-     */
-    static _normalizePath(dir) {
-        return typeof dir === "string" ? dir.replace(/\/$/, '') : dir
-    }
-
-    /**
-     * Determines the module folder from the past list that may represent files or folders w or w/o .cds file extension.
-     * @param {string} projectPath
-     * @param {Array} filesOrFolders
-     */
-    static _getModuleFolder(projectPath, filesOrFolders) {
-        const resources = [...filesOrFolders]
-        filesOrFolders.forEach(fileOrFolder => {
-            if (path.extname(fileOrFolder) !== FILE_EXT_CDS) {
-                resources.push(fileOrFolder + FILE_EXT_CDS)
-            }
-        })
-        return resources.reduce((acc, resource) => {
-            if (!acc) {
-                let resourcePath = path.resolve(projectPath, resource)
-                if (fs.existsSync(resourcePath)) {
-                    if (fs.lstatSync(resourcePath).isDirectory()) {
-                        acc = resource
-                    } else {
-                        // represents file
-                        acc = path.dirname(resource)
-                    }
-                }
-            }
-            return acc
-        }, null)
-    }
-}
-module.exports = BuildTaskProviderInternal