@sap/cds 6.8.3 → 7.0.0

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

@@ -1,306 +0,0 @@
-const cp = require('child_process');
-const os = require('os');
-const path = require('path');
-const util = require('util');
-
-const fs = require('fs').promises;
-
-const { BuildTaskEngine, BuildTaskFactory } = require('../../build');
-const buildConstants = require('../../build/constants');
-
-const cfUtil = require('./cfUtil');
-const hdiDeployUtil = require('./hdiDeployUtil');
-const gitUtil = require('./gitUtil');
-const mtaUtil = require('./mtaUtil');
-
-const { bold, info } = require('../../utils/term');
-
-const IS_WIN = (os.platform() === 'win32');
-const UTF_8 = 'utf-8';
-
-
-class HanaDeployer {
-
-  constructor() {
-    this.execAsync = util.promisify(cp.exec);
-    this.spawnSync = cp.spawnSync;
-  }
-
-  getFromEnv(...varNames) {
-    const result = {}
-    for (const varName of varNames) {
-      if (process.env[varName]) {
-        try {
-          result[varName] = JSON.parse(process.env[varName]);
-        } catch (err) {
-          throw new Error(`Error parsing environment variable ${varName}`);
-        }
-      }
-    }
-    return result;
-  }
-
-  async deploy(model, serviceName, noSave, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions, bindCallback) { // NOSONAR
-    hdiOptions = hdiOptions || {}
-
-    console.log(`${bold('Starting deploy to SAP HANA ...')}`);
-    if (vcapFile) {
-      console.log(`Using VCAP_SERVICES from file ${vcapFile} (beta feature).`);
-      bindCallback = null // credentials are given - no cds bind then
-    } else if (bindCallback) {
-      console.log('Using cds bind');
-    }
-
-    const projectPath = path.resolve(process.env._TEST_CWD || process.cwd());
-
-    const { buildResults } = await this._build(model, buildTaskOptions);
-
-    let globalVcapEnv = vcapFile ? await this._loadEnvFile(vcapFile) : {};
-    globalVcapEnv = { ...globalVcapEnv, ...this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS') };
-    if (process.env.TARGET_CONTAINER) {
-      globalVcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
-    }
-
-    for (const buildResult of buildResults) {
-      let vcapEnv = globalVcapEnv;
-      let serviceKeyName;
-      const currentModelFolder = buildResult.result.dest;
-
-      if (undeployWhitelist) {
-        console.log('Writing undeploy.json');
-        await fs.write(path.join(currentModelFolder, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
-      }
-
-      const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
-      if (!serviceName && hasVCAPEnv) {
-        await fs.mkdir(currentModelFolder, { recursive: true });
-      } else {
-        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
-          await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress);
-        serviceKeyName = cfServiceInstanceKeyName;
-        serviceName = serviceName || cfServiceInstanceName;
-
-        vcapEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
-
-        if (!noSave && !bindCallback) {
-          await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
-        }
-      }
-
-      // Check if deployer is already installed, otherwise only install this one, not the rest of dependencies.
-      if (!await hdiDeployUtil.findHdiDeployLib(currentModelFolder)) {
-        const { deployerName, deployerVersionSpec } = hdiDeployUtil;
-        console.log(`Installing ${deployerName}`);
-
-        // spawn has not callback and cannot be promisified, using sync instead
-        this.spawnSync(`npm`, [`install`, `${deployerName}@${deployerVersionSpec}`, (noSave ? '--no-save' : '--save-dev')], {
-          cwd: currentModelFolder,
-          shell: IS_WIN,
-          stdio: 'inherit',
-          env: {
-            ...process.env,
-            NODE_ENV: 'development' // for 'install --save-dev' to work, there must be no 'production' set
-          }
-        });
-      }
-
-      await hdiDeployUtil.deploy(currentModelFolder, vcapEnv, hdiOptions);
-
-      // let isLoggedInToCF;
-      // try {
-      //   isLoggedInToCF = !!(await cfUtil.getCfTarget());
-      // } catch (err) {
-      //   // valid state: not logged in
-      // }
-      // if (bindCallback && isLoggedInToCF) {
-      if (!hasVCAPEnv && bindCallback) {
-        const args = [path.relative(projectPath, buildResult.task.src)];
-        const options = { to: `${serviceName}:${serviceKeyName}`, kind: buildResult.task.for }
-        await bindCallback(args, options);
-      }
-    }
-
-    if (!bindCallback) {
-      await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
-    }
-
-    console.log(`If not already done, use ${info('cds add hana')} to configure the project for SAP HANA.\n`);
-    console.log(`Done.`);
-
-    return { buildResults };
-  }
-
-
-  async _getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress) {
-    const modelName = path.basename(currentModelFolder);
-
-    // get from param
-    let cfServiceInstanceMta;
-    let cfServiceInstanceName;
-    if (serviceName) {
-      cfServiceInstanceName = serviceName;
-    } else {
-      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(projectPath, modelName);
-      cfServiceInstanceName = cfServiceDescriptor.hdiServiceName;
-      cfServiceInstanceMta = cfServiceDescriptor.hdiService
-    }
-
-    console.log();
-    this._validateServiceInstanceName(cfServiceInstanceName);
-    console.log(`Using container ${bold(cfServiceInstanceName)}`);
-
-    let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
-    const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
-
-    const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
-    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName);
-    this._validateServiceKey(serviceKey, cfServiceInstanceKeyName);
-
-    if (tunnelAddress) {
-      console.log(`Using tunnel address ${bold(tunnelAddress)} (beta feature)`);
-      serviceKey = this._injectTunnelAddress(serviceKey, tunnelAddress)
-    }
-
-    return { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey, serviceInstance }
-  }
-
-
-  async createHanaService(instanceName, cfConfig) {
-    // hana or hanatrial, error if neither found
-    try {
-      return await cfUtil.getOrCreateService('hana', 'hdi-shared', instanceName, cfConfig);
-    } catch (error) {
-      if (error.command && /offering .* not found/i.test(error.command.stderr)) {
-        console.log(`Falling back to 'hanatrial'`);
-        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
-      }
-      else if (error.command && /no database/i.test(error.command.stderr)) {
-        console.log(`No database connected to 'hana' service. Falling back to 'hanatrial'`);
-        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
-      }
-      throw error;
-    }
-  }
-
-
-  _validateServiceKey(serviceKey, cfServiceInstanceKey) {
-    if (!serviceKey) {
-      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
-    }
-
-    const fields = ['schema', 'user', 'password', 'url'];
-    for (const field of fields) {
-      if (!serviceKey[field]) {
-        throw new Error(`Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
-      }
-    }
-  }
-
-
-  async _build(model, buildTaskOptions) {
-    buildTaskOptions = buildTaskOptions || {
-      root: process.env._TEST_CWD || process.cwd(),
-      cli: true,
-      cmdOptions: {
-        for: buildConstants.BUILD_TASK_HANA
-      }
-    };
-
-    if (typeof model === 'string') {
-      model = [model];
-    }
-    console.log(`Creating build tasks`);
-    const buildTaskFactory = new BuildTaskFactory();
-    const hanaTasks = await buildTaskFactory.getTasks(buildTaskOptions);
-    console.log(`Running build`);
-
-    const buildResults = await new BuildTaskEngine().processTasks(hanaTasks, buildTaskOptions);
-    return { buildResults, hanaTasks }
-  }
-
-  async _loadEnvFile(defaultEnvFile) {
-    try {
-      const content = await fs.readFile(defaultEnvFile);
-      return JSON.parse(content);
-    } catch (err) {
-      throw new Error(`Error reading default env file: ${err.message}`);
-    }
-  }
-
-
-  async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
-    for (const currentFolder of currentFolders) {
-      let defaultEnvJson = {};
-      const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
-
-      try {
-        defaultEnvJson = JSON.parse(await fs.readFile(defaultEnvJsonPath, UTF_8));
-      } catch (err) {
-        // ignore any errors
-      }
-
-      defaultEnvJson.VCAP_SERVICES = defaultEnvJson.VCAP_SERVICES || {};
-      for (const serviceKey of Object.keys(defaultEnvJson.VCAP_SERVICES)) {
-        defaultEnvJson.VCAP_SERVICES[serviceKey] = defaultEnvJson.VCAP_SERVICES[serviceKey].filter((service) => {
-          return (service.name !== serviceInstanceName);
-        });
-      }
-
-      const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
-      Object.assign(defaultEnvJson, hanaEntry);
-
-      console.log(`Writing ${defaultEnvJsonPath}`);
-      await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
-      await fs.writeFile(defaultEnvJsonPath, JSON.stringify(defaultEnvJson, null, 2));
-    }
-  }
-
-
-  _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
-    return {
-      VCAP_SERVICES: {
-        hana: [
-          {
-            name: serviceInstanceName,
-            tags: ['hana'],
-            credentials: serviceKey
-          }
-        ]
-      }
-    };
-  }
-
-
-  _validateServiceInstanceName(serviceInstanceName) {
-    // valid service name chars: alpha-numeric, hyphens, and underscores
-    if (/[^\w-_]+/g.exec(serviceInstanceName)) {
-      throw new Error(`Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`);
-    }
-  }
-
-
-  _injectTunnelAddress(serviceKey, tunnelAddress) {
-    if (!/\w+:\d+/.test(tunnelAddress)) {
-      throw new Error(`Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`)
-    }
-    const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
-    const { host, port } = serviceKey
-    serviceKey.host = tunnelHost
-    serviceKey.port = tunnelPort
-    serviceKey.url = serviceKey.url.replace(`${host}:${port}`, tunnelAddress)
-    serviceKey.hostname_in_certificate = host  // make cert. verification happy, see xs2/hdideploy.js#527
-    serviceKey.url = serviceKey.url + (serviceKey.url.includes('?') ? '&' : '?') + 'hostNameInCertificate=' + host
-    return serviceKey
-  }
-
-
-  async readFileSafely(file) {
-    try {
-      return await fs.readFile(file, 'utf8');
-    } catch (err) {
-      return '';
-    }
-  }
-}
-
-module.exports = new HanaDeployer();

package/bin/deploy/to-hana/hdiDeployUtil.js

@@ -1,153 +0,0 @@
-const cp = require('child_process');
-const path = require('path');
-const util = require('util');
-
-const execAsync = util.promisify(cp.exec);
-
-const cds = require('../../../lib');
-const LOG = cds.log ? cds.log('deploy') : console;
-const DEBUG = cds.debug('deploy');
-const { SILENT } = cds.log.levels;
-
-class HdiDeployUtil {
-
-    constructor() {
-        this.hdiDeployLibs = new Map();
-        this.deployerName = '@sap/hdi-deploy'
-        this.deployerVersionSpec = '^4'
-    }
-
-    async deployTenant(dbDir, env) {
-        await this._executeDeploy(dbDir, env, true);
-    }
-
-    async deploy(dbDir, vcapEnv, options) {
-        vcapEnv = vcapEnv || {}; // handles null and undefined
-        options = options || {};
-
-        console.log(`Deploying to HANA from ${dbDir}`);
-
-        const hdiDeployLib = await this._getHdiDeployLib(dbDir);
-
-        let deployerEnv = JSON.parse(JSON.stringify(process.env));
-        const hdiDeployOptions = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
-        delete hdiDeployOptions.root;
-
-        if (typeof hdiDeployLib.clean_env === 'function') {
-            deployerEnv = hdiDeployLib.clean_env(deployerEnv);
-        }
-
-        if (vcapEnv.VCAP_SERVICES) {
-            deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
-        }
-        if (vcapEnv.SERVICE_REPLACEMENTS) {
-            deployerEnv.SERVICE_REPLACEMENTS = JSON.stringify(vcapEnv.SERVICE_REPLACEMENTS);
-        }
-        if (vcapEnv.TARGET_CONTAINER) {
-            deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
-        }
-
-        if (options.autoUndeploy) {
-            console.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
-            hdiDeployOptions.auto_undeploy = true;
-        }
-
-        if (Object.entries(hdiDeployOptions).length > 0) {
-            deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
-        }
-
-        await this._executeDeploy(dbDir, deployerEnv);
-    }
-
-
-    async findHdiDeployLib(cwd) {
-        const searchPaths = await this._npmSearchPaths(cwd)
-        try {
-            return require.resolve(path.join(this.deployerName, 'library'), { paths: searchPaths });
-        } catch (err) {
-            // no luck
-        }
-    }
-
-
-    async _getHdiDeployLib(dbDir) {
-        let hdiDeployLib = this.hdiDeployLibs.get(dbDir)
-        if (!hdiDeployLib) {
-            hdiDeployLib = await this._loadHdiDeployLib(dbDir);
-            this.hdiDeployLibs.set(dbDir, hdiDeployLib);
-        }
-
-        return hdiDeployLib;
-    }
-
-
-    async _loadHdiDeployLib(cwd) {
-        const libPath = await this.findHdiDeployLib(cwd)
-        if (!libPath) {
-            const searchPaths = await this._npmSearchPaths(cwd)
-            throw new Error(`Required library '${this.deployerName}' not found in
-    ${searchPaths.join('\n    ')}
-Add it either as a devDependency using 'npm install -D ${this.deployerName}' or install it globally using 'npm install -g ${this.deployerName}'.`);
-        }
-
-        LOG.info(`Using HDI deployer from ${libPath}`)
-
-        // let any error go through and abort deploy
-        return require(libPath);
-    }
-
-
-    async _npmSearchPaths(cwd) {
-        // REVISIT: we shouldn't have to rely on `npm` on the server
-        try {
-            const npmRootCall = await execAsync('npm root -g');
-            const globalNodeModules = npmRootCall.stdout.toString().trim();
-            return [cwd, globalNodeModules, '@sap/hdi-deploy']
-        } catch (error) {
-            if (/Command failed: npm.*not found/s.test(error.message)) return [cwd, '@sap/hdi-deploy']
-            else throw error
-        }
-    }
-
-
-    async _executeDeploy(dbDir, env, fromMtx) {
-        const hdiDeployLib = await this._getHdiDeployLib(dbDir);
-        let writeStream
-        if (fromMtx) {
-            await cds.utils.mkdirp('logs')
-            writeStream = require('fs').createWriteStream(path.join(cds.root, 'logs', `${cds.context.tenant}.log`))
-        }
-        return new Promise((resolve, reject) => {
-            const callbacks = {
-                stderrCB: buffer => {
-                    LOG.error(buffer.toString())
-                    writeStream?.write(buffer)
-                },
-            }
-            if (fromMtx) {
-                callbacks.stdoutCB = buffer => {
-                    DEBUG?.(buffer.toString())
-                    writeStream.write(buffer)
-                }
-            } else if (LOG.level !== SILENT) {
-                callbacks.stdoutCB = buffer => LOG.info(buffer.toString())
-            }
-            hdiDeployLib.deploy(dbDir, env, (error, response) => {
-                if (error) {
-                    return reject(error);
-                }
-                if (response?.exitCode) {
-                    let message = `HDI deployment failed with exit code ${response.exitCode}`
-                    if (response.signal) message += `. ${response.signal}`
-                    return reject(new Error(message));
-                }
-                return resolve();
-            }, callbacks);
-        }).finally(() => writeStream?.end());
-    }
-}
-
-
-module.exports = new HdiDeployUtil();
-
-/* eslint no-console: off */

package/bin/deploy/to-hana/index.js

@@ -1,16 +0,0 @@
-exports.deploy = (_model, _dbSpecificParameter, {
-  'no-save': no_save,
-  'auto-undeploy': autoUndeploy = false,
-  'tunnel-address': tunnelAddress,
-  'vcap-file': vcapFile,
-}, bindCallback) => {
-  const hanaDeployer = require('./hana');
-
-  return hanaDeployer.deploy(
-    _model, _dbSpecificParameter,
-    no_save, tunnelAddress,
-    null, vcapFile, null,
-    { autoUndeploy },
-    bindCallback
-  )
-}

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

@@ -1,170 +0,0 @@
-const cds = require('../../../lib')
-const fs = require('fs').promises
-const {existsSync} = require('fs')
-const path = require('path')
-
-const HDI_CONTAINER_TYPES = ['com.sap.xs.hdi-container']
-const UTF_8 = 'utf-8'
-const MTA_YAML = 'mta.yaml'
-const LOG = cds.log ? cds.log('deploy') : console;
-
-async function getHanaDbModuleDescriptor(projectPath, moduleName) {
-    // mta might be null if mta.yaml does not exist
-    const mta = await _getMta(projectPath)
-    const projectInfo = await _getProjectInfo(projectPath, mta)
-    const hdiService = _findHdiResource(mta, moduleName)
-    const appName = _getApplicationName(mta, moduleName, 'hdb')
-
-    return {
-        project: projectInfo,
-        appName: appName ? appName : `${projectInfo.name}-${moduleName}-deployer`,
-        hdiServiceName: hdiService ? hdiService.name : `${projectInfo.name}-${moduleName}`,
-        hdiService: hdiService
-    }
-}
-
-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 = {
-    }
-    // 1. use mta data
-    if (mta) {
-        details.id = mta.ID
-        details.description = mta.description
-        details.version = mta.version
-        if (mta.ID) {
-            details.name = mta.ID.replace(/\./g, '-')
-        }
-    }
-    // 2. use package.json data
-    const packageJsonPath = path.join(projectPath, 'package.json')
-    if (existsSync(packageJsonPath)) {
-        try {
-            const packageJson = JSON.parse((await fs.readFile(packageJsonPath, 'utf-8')).toString())
-            if (!details.description && packageJson.description) {
-                details.description = packageJson.description
-            }
-            if (!details.version && packageJson.version) {
-                details.version = packageJson.version
-            }
-            if (packageJson.name) {
-                let segments = packageJson.name.trim().split('/')
-                // scope as namespace
-                if (segments[0].startsWith('@')) {
-                    segments[0] = segments[0].replace('@', '')
-                }
-                segments = segments.map(segment => segment.startsWith('@') ? encodeURIComponent(segment.replace('@', '')) : encodeURIComponent(segment))
-                if (!details.name) {
-                    details.name = segments[segments.length - 1]
-                }
-                if (!details.id) {
-                    details.id = segments.join('.')
-                }
-                if (!details.description) {
-                    details.description = segments[segments.length - 1]
-                }
-            }
-        } catch (e) {
-            console.error(`Failed to load ${packageJsonPath} - skip application data`, e)
-        }
-    }
-    // 3. use project name and static default values
-    const projectName = path.basename(projectPath)
-    if (!details.name) {
-        details.name = projectName
-    }
-    if (!details.description) {
-        details.description = projectName
-    }
-    if (!details.id) {
-        details.id = projectName
-    }
-    if (!details.version) {
-        details.version = '1.0.0'
-    }
-    return details
-}
-
-async function _getMta(projectPath) {
-    // yaml.parse  oesn't like null
-    const mtaFilePath = path.join(projectPath, MTA_YAML)
-
-    const existsMtaYaml = existsSync(mtaFilePath)
-    if (!existsMtaYaml) {
-        LOG.debug('mta.yaml not existing')
-        return null
-    }
-
-    const yamlStr = await fs.readFile(mtaFilePath, UTF_8)
-
-    // yaml returns null if string couldn't be parsed, e.g. empty string
-    return cds.parse.yaml(yamlStr)
-}
-
-function _getApplicationName(mta, moduleName, moduleType) {
-    const module = _findModule(mta, moduleName, moduleType)
-    if (module) {
-        const appName = module.parameters && module.parameters['app-name']
-        return appName ? appName : module.name
-    }
-    return null
-}
-
-function _findModules(mta, moduleType) {
-    let modules = []
-    if (mta && Array.isArray(mta.modules)) {
-        modules = mta.modules.filter(module => module.type === moduleType)
-    }
-    return modules
-}
-
-function _findModule(mta, moduleName, moduleType) {
-    const modules = _findModules(mta, moduleType)
-    if (modules.length === 1) {
-        return modules[0]
-    } else if (modules.length > 1) {
-        return modules.find(module => typeof module.path === 'string' && module.path.includes(moduleName))
-    }
-    return null
-}
-
-function _findHdiResource(mta, moduleName) {
-    if (mta && Array.isArray(mta.resources)) {
-        const hdiResources = mta.resources.filter(resource => HDI_CONTAINER_TYPES.includes(resource.type))
-
-        if (hdiResources.length > 0) {
-            if (Array.isArray(mta.modules)) {
-                const module = _findModule(mta, moduleName, 'hdb')
-                if (module && Array.isArray(module.requires)) {
-                    return hdiResources.find(hdiResource =>
-                        module.requires.find(req =>
-                            hdiResource.name === req.name
-                        )
-                    )
-                }
-            }
-
-            console.warn(`No matching hdi resource found for ${moduleName}. Using ${hdiResources[0].name}.`)
-            return hdiResources[0]
-        }
-    }
-
-    return null
-}
-
-module.exports = {
-    getHanaDbModuleDescriptor,
-    getServiceModuleDescriptor,
-    MTA_YAML
-}

package/bin/mtx/in-cds.js

@@ -1,17 +0,0 @@
-const cds = require('../build/cds')
-
-if (cds.requires.multitenancy && cds.utils._oldMtx()) try {
-  // eslint-disable-next-line cds/no-missing-dependencies
-  const mtx = module.exports = require ('@sap/cds-mtx')()
-  mtx.inject (cds)
-  cds.on('served', () => cds.emit('mtx'))
-} catch(e) {
-  if (e.code === 'MODULE_NOT_FOUND') throw new Error('Error serving MTX APIs: @sap/cds-mtx is not installed')
-  else throw e
-}
-else module.exports = undefined
-
-/*
- cds.requires.multitenancy  --  use this to check whether mt is enabled (old or new)
- cds.mtx                    --  use this to check whether old(!) mtx is enabled
-*/

package/bin/plugins.js

@@ -1,32 +0,0 @@
-const cds = require('../lib')
-const DEBUG = cds.debug('plugins')
-
-module.exports = async function load_plugins (log = console.log) {
-
-  if (DEBUG) console.time('[cds] - loaded plugins in')
-  const plugins = []
-  if (cds.env.plugins) {
-    for (let each of cds.env.plugins) {
-      let impl = typeof each === 'string' ? each : each.impl
-      if (impl.startsWith('.'))
-        impl = require.resolve(cds.root + '/' + impl)
-      plugins.push(_load_plugin(impl, each))
-    }
-  } else
-    try {
-      const pkg = require(cds.root + '/package.json')
-      const dependencies = { ...pkg.dependencies, ...(process.env.NODE_ENV !== 'production' && pkg.devDependencies) }
-      for (let each in dependencies) {
-        plugins.push(_load_plugin(each + '/cds-plugin'))
-      }
-    } catch { /* ignored */ }
-  try { await Promise.all(plugins); } catch { /* ignored */ }
-  if (DEBUG) console.timeEnd('[cds] - loaded plugins in')
-
-  async function _load_plugin (impl, conf) {
-    // TODO support ESM plugins.  But see cap/cds/pull/1838#issuecomment-1177200 !
-    const plugin = require(impl)
-    log('loaded plugin:', { impl })
-    if (plugin.activate) await plugin.activate(conf)
-  }
-}