@sap/cds-dk 8.7.2 → 8.8.0

package/lib/bind/KubernetesApiAccessor.js

@@ -1,81 +0,0 @@
-const { yaml } = require('../cds').utils
-const { execSync } = require('child_process');
-const { bold } = require('../util/term');
-
-class KubernetesApiAccessor {
-
-    constructor() {
-
-        this.config = once( async() => {
-            const configString = execSync('kubectl config view --raw').toString();
-            const config = yaml.parse(configString);
-
-            const currentContextName = config['current-context'];
-            if (!currentContextName) throw new Error(`No current context in kubectl config.`);
-            const currentContextEntry = config.contexts && config.contexts.find( entry => entry.name === currentContextName && entry.context && entry.context.cluster && entry.context.user );
-            if (!currentContextEntry) throw new Error(`Current context not found in kubectl config.`);
-            const currentContext = currentContextEntry.context;
-            const clusterEntry = config.clusters && config.clusters.find( entry => entry.name === currentContext.cluster && entry.cluster && entry.cluster.server );
-            if (!currentContextEntry) throw new Error(`Cluster ${bold(currentContext.cluster)} not found in kubectl config.`);
-            const { cluster } = clusterEntry;
-
-            const serverToContext = {};
-            for (const clusterEntry of config.clusters) {
-                const contextEntries = config.contexts.filter( contextEntry => contextEntry.context.cluster === clusterEntry.name );
-                // Collect only cluster servers that are used in exactly one context, to clearly identify the context to be used
-                if (contextEntries.length === 1) {
-                    serverToContext[clusterEntry.cluster.server] = contextEntries[0];
-                }
-            }
-
-            return {
-                namespace: currentContext.namespace || 'default',
-                context: currentContextEntry,
-                cluster,
-                serverToContext
-            }
-        });
-    }
-
-    async context({cluster, namespace}) {
-        const config = await this.config();
-        let contextEntry;
-
-        if (cluster && cluster !== config.cluster.server) {
-            contextEntry = config.serverToContext[cluster] || throwError(`Cluster ${bold(cluster)} not found in kubectl configuration`);
-        } else {
-            contextEntry = config.context;
-        }
-
-        return {
-            context: contextEntry.name,
-            cluster: cluster || config.cluster.server,
-            namespace: namespace || contextEntry.context.namespace || 'default'
-        };
-    }
-
-    async get(options) {
-        const {context, namespace, kind, name} = options;
-        try {
-            return JSON.parse(execSync(`kubectl --output json --context ${context} --namespace ${namespace} get ${kind} ${name}`).toString());
-          }
-          catch (error) {
-            if (error.status === 1) return null
-            else throw error
-        }
-    }
-}
-
-function once(func) {
-    let result;
-    return function(...args) {
-        if (!result) result = func(...args);
-        return result;
-    }
-}
-
-function throwError(msg = 'Internal Error') {
-    throw new Error(msg);
-}
-
-module.exports = KubernetesApiAccessor;

package/lib/bind/bindingManager.js

@@ -1,89 +0,0 @@
-const bindingResolver = require('./bindingResolver')
-const { logger } = require('./bindingUtil')
-const cds = require('../cds')
-const DEBUG = cds.log('cli')._debug // REVISIT: This loads cds.env too early!
-
-class BindingManager {
-    constructor(options = {}) {
-        this.cache = {}
-        this.bindingsStr = ''
-        this.options = options
-        logger.log = DEBUG || !options.silent ? console.log : () => { }
-    }
-
-    getBindings() {
-        const bindings = bindingResolver.getUnresolvedBindings(this.options)
-        return bindings
-    }
-
-    async resolve(bindings) {
-        if (!bindings) {
-            bindings = this.getBindings()
-            this.bindingsStr = JSON.stringify(bindings)
-        }
-
-        return await bindingResolver.resolveBindings({ ...this.options, bindings, cache: this.cache })
-    }
-
-    async bindingEnv(bindings) {
-        if (!bindings) bindings = await this.resolve()
-        if (bindings) {
-            const VCAP_SERVICES = JSON.stringify(BindingManager.toVcapServices(bindings))
-            return { VCAP_SERVICES }
-        } else {
-            return undefined
-        }
-    }
-
-    async update({ onBeforeUpdate, onAfterUpdate } = {}) {
-        const oldBindingsStr = this.bindingsStr
-        const bindings = this.getBindings()
-        const bindingsStr = JSON.stringify(bindings)
-        this.bindingsStr = bindingsStr
-
-        if (this.bindingsStr === oldBindingsStr) return // No change
-        if (onBeforeUpdate) await onBeforeUpdate()
-
-        try {
-            if (this.pendingUpdate) await this.pendingUpdate
-        } catch (error) {
-            // ignore
-        }
-        this.pendingUpdate = undefined
-
-        if (this.bindingsStr !== bindingsStr) return // Next update in progress
-
-        let resolvedBindings
-        try {
-            this.pendingUpdate = this.resolve(bindings)
-            resolvedBindings = await this.pendingUpdate
-        } catch (error) {
-            console.error(error.message)
-            return
-        }
-
-        if (this.bindingsStr !== bindingsStr) return // Next update in progress
-
-        const env = Object.assign({ VCAP_SERVICES: '{}' }, await this.bindingEnv(resolvedBindings));
-        if (onAfterUpdate) onAfterUpdate({ bindings: resolvedBindings, env })
-    }
-
-    static toVcapServices(bindings) {
-        const services = {}
-
-        for (const name in bindings) {
-            const binding = bindings[name]
-            const vcap = binding.binding.vcap || {}
-            const type = vcap.type || vcap.label
-            const serviceEntries = services[type] = services[type] || []
-
-            // setting the 'name' property is important to make CAP match the CDS service to the VCAP service
-            // it is also added to the 'vcap' property by 'cds bind'
-            serviceEntries.push({ ...vcap, name, credentials: binding.credentials })
-        }
-
-        return services
-    }
-}
-
-module.exports = BindingManager

package/lib/bind/bindingResolver.js

@@ -1,54 +0,0 @@
-const cds = require('../cds');
-const path = require('path');
-const { platformText, bindingText, logger } = require('./bindingUtil');
-const { bold } = require('../util/term');
-
-class BindingResolver {
-    getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
-        if (!env) {
-            env = cds.env.for('cds', path.resolve(cwd)) // REVISIT: This might load cds.env too early!
-        }
-        const bindings = {}
-        const requires = env.requires || {}
-        for (const name in requires) {
-            const service = requires[name]
-            if (service && service.binding && !service.binding.resolved) {
-                bindings[name] = { ...service.binding, kind: service.kind }
-            }
-        }
-        return bindings
-    }
-
-    async resolveBindings({ bindings, cwd = process.cwd(), env, cache = {} }) {
-        bindings = bindings || this.getUnresolvedBindings({ cwd, env })
-        if (Object.keys(bindings).length === 0) return undefined
-        logger.log(`resolving cloud service bindings...`)
-
-        const resolvedBindings = {}
-
-        // run in parallel
-        await Promise.all(Object.keys(bindings).map(async name => {
-            const binding = bindings[name]
-            const cacheKey = JSON.stringify(binding)
-            let resolvedBinding
-            if (!cache[cacheKey]) {
-                resolvedBinding = cache[cacheKey] = await this.resolveBinding(name, binding)
-                logger.log(`bound ${bold(name)} to ${platformText(binding)} ${bindingText(binding)}`)
-            } else {
-                resolvedBinding = cache[cacheKey]
-            }
-            resolvedBindings[name] = resolvedBinding
-        }));
-        return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
-    }
-
-    resolveBinding(name, binding) {
-        switch (binding.type) {
-            case 'cf': return require('./cfKeyProvider').resolve(name, binding)
-            case 'k8s': return require('./kubernetesCredentialsProvider').resolve(name, binding)
-            default: throw new Error(`Unsupported binding type ${bold(binding.type)} for service ${bold(name)}.`)
-        }
-    }
-}
-
-module.exports = new BindingResolver()

package/lib/bind/bindingUtil.js

@@ -1,129 +0,0 @@
-const { bold } = require('../util/term');
-
-const KindToRequiresNameMap = {
-    xsuaa: 'auth', // REVISIT: remove with ^8
-    'xsuaa-auth': 'auth',
-    'ias-auth': 'auth',
-    'hana-cloud': 'db',
-    hana: 'db',
-    'hana-mt': 'db', // For compatibility only
-    'sql-mt': 'db', // For compatibility only
-    destinations: 'destinations',
-    connectivity: 'connectivity',
-    'audit-log': 'auditlog',
-    'audit-log-to-restv2': 'auditlog',
-    'enterprise-messaging': 'messaging',
-    'enterprise-messaging-amqp': 'messaging',
-    'enterprise-messaging-http': 'messaging',
-    'enterprise-messaging-shared': 'messaging',
-    'redis-messaging': 'messaging',
-    'multitenancy': 'multitenancy'
-}
-
-const PreferredKinds = {
-    multitenancy: 1, 'hana-cloud': 1, xsuaa: 1, 'xsuaa-auth': 1, 'ias-auth': 1, 'saas-registry': 1
-};
-
-const PLATFORM_TYPES = {
-    'cf': 'Cloud Foundry',
-    'k8s': 'Kubernetes'
-}
-
-class BindingUtil {
-    static getRequiresNameFromKind(service, kind) {
-        const requiresName = KindToRequiresNameMap[kind];
-        if (!requiresName) throw new Error(`Unknown CDS service name for service ${bold(service)}. Please specify as argument for ${bold('cds bind')}.`)
-        return requiresName;
-    }
-
-    /**
-     * Determine kind value for services based on VCAP binding
-     * information in the configuration.
-     */
-    static determineKinds(services) {
-        const vcapServices = {}
-
-        // Build VCAP_SERVICES
-        for (const service of services) {
-            service.kindCandidates = []
-
-            const { vcap = {} } = service.binding || {};
-            let { label, type } = vcap;
-            type = type || label;
-            if (!type) continue;
-
-            if (!vcapServices[type]) vcapServices[type] = [];
-            vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service });
-        }
-
-        // Auto configure services based on VCAP_SERVICES
-
-        const cds = require('../cds');
-        const env = cds.env.for('cds', process.cwd()); // REVISIT: This might load cds.env too early!
-
-        if (!env._find_credentials_for_required_service) {
-            throw new Error(`Please provide a service kind or update @sap/cds version to use the kind detection.`);
-        }
-
-        const requires = env.requires.kinds || {};
-        for (const [kind, service] of Object.entries(requires)) {
-            const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices);
-            if (!vcapService) continue;
-            const isUniqueKind = !Object.values(requires).some(otherService =>
-                otherService !== service && otherService.kind === kind
-            )
-            if (isUniqueKind) vcapService.service.kindCandidates.push(kind);
-        }
-
-        // Check if one "kind" per service was found
-        for (const service of services) {
-            const preferredKind = service.kindCandidates.find(kind => kind in PreferredKinds);
-            if (preferredKind) {
-                service.kind = preferredKind;
-            } else if (service.kindCandidates.length === 1) {
-                service.kind = service.kindCandidates[0];
-            }
-            delete service.kindCandidates;
-        }
-    }
-
-    static async checkIsJavaProject(projectPath) {
-        const { constants, promises: fsp } = require('fs');
-        const path = require('path');
-        const pomXmlPath = path.join(projectPath, 'pom.xml');
-        try {
-            await fsp.access(pomXmlPath, constants.F_OK);
-            return true;
-        } catch (err) {
-            return false;
-        }
-    }
-
-    static platformText(binding) {
-        if (!PLATFORM_TYPES[binding.type]) throw new Error(`Unexpected binding type ${bold(binding.type)}.`);
-        return PLATFORM_TYPES[binding.type]
-    }
-
-    static bindingText(binding) {
-        switch (binding.type) {
-            case 'cf':
-                if (binding.key) {
-                    return `managed service ${bold(binding.instance + ':' + binding.key)}`
-                } else {
-                    return `user provided service ${bold(binding.instance)}`
-                }
-            case 'k8s':
-                if (binding.name) {
-                    return `service binding ${bold(binding.name)}`
-                } else {
-                    return `secret ${bold(binding.secret)}`
-                }
-            default:
-                throw new Error('Internal Error');
-        }
-    }
-
-    static logger = { log: console.log }
-}
-
-module.exports = BindingUtil

package/lib/bind/index.js

@@ -1,127 +0,0 @@
-const cds = require('../cds');
-
-const BindingResolver = require('./bindingResolver');
-const { determineKinds, getRequiresNameFromKind, checkIsJavaProject, platformText, bindingText, logger } = require('./bindingUtil');
-const { bold } = require('../util/term');
-
-
-module.exports = { bind, storeBindings, parseProfile, mergeCredentials }
-
-/**
- * Executes cds build in the directory defined by cds.root.
- *
- * @param {object} options - command options as defined by build command.
- */
-async function bind(options) {
-    let on;
-    switch (options.on) {
-        case 'k8s':
-        case 'kubernetes':
-            on = 'k8s';
-            break;
-        case undefined:
-        case null:
-        case 'cf':
-        case 'cloudfoundry':
-            on = 'cf';
-            break;
-        default:
-            throw `Invalid value '${options.on}' for option --on.`;
-    }
-
-    const onText = { 'cf': 'Cloud Foundry', 'k8s': 'Kubernetes' }[on];
-    if (!options['to-app-services']) logger.log(`Retrieving data from ${bold(onText)}...`);
-
-    // run in parallel
-    const targets = options.to.split(/,/g);
-    const resolvedServices = await Promise.all(targets.map(async target => {
-        let binding;
-        if (on === 'k8s') {
-            binding = { type: on, name: target };
-        } else if (on === 'cf') {
-            const [instance, key] = target.split(/:/);
-            binding = { type: on, instance, key };
-        } else {
-            throw new Error('Internal Error');
-        }
-        const resolvedService = await BindingResolver.resolveBinding(undefined, binding);
-        resolvedService._target = target;
-        delete resolvedService.credentials;
-        resolvedService.binding.resolved = false;
-        return resolvedService;
-    }));
-
-    if (options.kind) {
-        resolvedServices.forEach(service => service.kind = options.kind);
-    } else {
-        determineKinds(resolvedServices);
-    }
-
-    for (const resolvedService of resolvedServices) {
-        if (options.serviceArg) {
-            resolvedService.name = options.serviceArg;
-        } else if (resolvedService.kind) {
-            resolvedService.name = getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
-        }
-
-        let { kind, name, binding } = resolvedService;
-        name = name ?? `custom-service:${binding.instance || binding.secret}`
-        resolvedService.name = resolvedService.name ?? name
-        const kindText = kind ? ` with kind ${bold(kind)}` : ''
-        const nameText = bold(name)
-
-        logger.log(`Binding ${nameText} to ${platformText(binding)} ${bindingText(binding)}${kindText}`);
-    }
-
-    return resolvedServices;
-}
-
-async function storeBindings(resolvedServices, options) {
-    // prepare for different providers
-    const userCdsrcJsonStorageProvider = require('./userCdsrcJsonStorageProvider');
-
-    await userCdsrcJsonStorageProvider.storeServices(resolvedServices, {
-        ...options
-    });
-
-    const isJavaProject = await checkIsJavaProject(cds.root);
-    if (!cds.cli.options['to-app-services']) {
-        logger.log(`\nTo run with cloud bindings use ${bold(runCmd(options.for, isJavaProject))}`);
-    }
-}
-
-function runCmd(profile, isJavaProject) {
-    profile = parseProfile(profile);
-    if (isJavaProject) {
-        const p = profile === 'hybrid' ? '' : ` --profile ${profile}`;
-        return `cds bind --exec${p} mvn spring-boot:run`;
-    } else {
-        const p = profile === 'development' ? '' : ` --profile ${profile}`;
-        return `cds watch${p}`;
-    }
-}
-
-function parseProfile(profile) {
-    if (!profile) return 'hybrid';
-    else if (profile === '-') return 'development';
-    else return profile;
-}
-
-function mergeCredentials(credentials, customCredentials) {
-    if (!customCredentials) return credentials;
-
-    for (const key in customCredentials) {
-        if (typeof customCredentials[key] === 'object') {
-            if (credentials[key] && typeof credentials[key] !== 'object') {
-                throw `Cannot merge credentials: '${key}' is not an object`;
-            }
-            if (!credentials[key]) {
-                credentials[key] = {};
-            }
-            credentials[key] = mergeCredentials(credentials[key], customCredentials[key]);
-        } else {
-            credentials[key] = customCredentials[key];
-        }
-    }
-    return credentials;
-}

package/lib/bind/kubernetesCredentialsProvider.js

@@ -1,84 +0,0 @@
-const KubernetesApiAccessor = require('./KubernetesApiAccessor');
-const { mergeCredentials } = require('./index');
-
-class KubernetesCredentialsProvider {
-    async init() {
-        this.api = new KubernetesApiAccessor();
-    }
-
-    async resolve(name, binding) {
-        if (!this.initPromise) {
-            this.initPromise = this.init();
-        }
-        await this.initPromise;
-
-
-        const { context, namespace, cluster } = await this.api.context({ cluster: binding.cluster, namespace: binding.namespace });
-        let { name: bindingName, secret, credentials: customCredentials } = binding;
-
-        let instance;
-        let secretOrBindingResource = 'Secret';
-
-        if (bindingName) {
-            const bindingResource = await this.api.get({ context, namespace, kind: 'servicebindings', name: bindingName });
-            if (bindingResource === null) {
-                // Fallback to secret instead of service binding;
-                secret = bindingName;
-                bindingName = undefined;
-                secretOrBindingResource = 'Service Binding or Secret';
-            } else {
-                const { spec } = bindingResource
-                if (!spec.secretName || !spec.serviceInstanceName) {
-                    throw new Error('Internal error')
-                }
-                secret = spec.secretName;
-                instance = spec.serviceInstanceName;
-            }
-        }
-
-        const secretResource = await this.api.get({ context, namespace, kind: 'secrets', name: secret });
-        if (secretResource === null) throw new Error(`${secretOrBindingResource} '${secret}' not found.`);
-
-        const serviceBinding = this._readBinding(name, secretResource);
-        const { credentials } = serviceBinding;
-        const vcap = { ...serviceBinding, credentials: undefined }
-
-        const resolvedBinding = {
-            binding: {
-                type: 'k8s',
-                name: bindingName,
-                cluster,
-                instance,
-                namespace,
-                secret: secret,
-                resolved: true,
-                vcap
-            },
-            credentials: mergeCredentials(credentials, customCredentials)
-        };
-
-        return resolvedBinding;
-    }
-
-    _readBinding(name, secret) {
-        const { data } = secret;
-        const properties = {};
-        for (const name in data) {
-            const value = Buffer.from(data[name], 'base64').toString()
-            properties[name] = value;
-        }
-
-        let parseBinding
-        try {
-            // eslint-disable-next-line
-            parseBinding = require('@sap/cds/lib/env/serviceBindings').parseBinding;
-        } catch (error) {
-            //
-        }
-        if (!parseBinding) throw new Error(`Please update your @sap/cds version for Kubernetes support`)
-
-        return parseBinding('/', name, properties);
-    }
-}
-
-module.exports = new KubernetesCredentialsProvider();

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -1,92 +0,0 @@
-const os = require('os');
-const path = require('path');
-
-const fs = require('fs').promises;
-const { bold } = require('../util/term');
-const { logger } = require('./bindingUtil');
-
-const gitUtil = require('../util/git');
-
-const CDSRC_FILENAME = '.cdsrc-private.json';
-
-class UserCdsrcJsonStorageProvider {
-
-    async storeServices(services, options = {}) {
-        let jsonPath = options.out || CDSRC_FILENAME;
-
-        if (jsonPath === CDSRC_FILENAME) {
-            await gitUtil.ensureFileIsGitignored(CDSRC_FILENAME);
-        }
-
-        jsonPath = jsonPath.replace(/~/g, os.homedir());
-        if (path.extname(jsonPath) !== '.json') {
-            jsonPath = path.join(jsonPath, '.cdsrc.json');
-        }
-
-        const jsonObject = await this.readJsonSafely(jsonPath);
-        let cdsRoot;
-        if (path.basename(jsonPath) === 'package.json') {
-            jsonObject.cds = jsonObject.cds || {};
-            cdsRoot = jsonObject.cds;
-        } else {
-            cdsRoot = jsonObject;
-        }
-
-        const profileKey = `[${options.for}]`;
-        const features = cdsRoot.features && cdsRoot.features[profileKey];
-        if (features) delete features.emulate_vcap_services;
-
-        cdsRoot.requires = cdsRoot.requires || {};
-        let section;
-        section = cdsRoot.requires[profileKey] = cdsRoot.requires[profileKey] || {};
-
-        for (const service of services) {
-            const { name, kind, binding, credentials } = service;
-            const requireService = section[name] = section[name] || {};
-            // store optional custom credentials
-            binding.credentials = this._getServiceCredentials(binding, services, options);
-
-            Object.assign(requireService, { binding: { ...binding, vcap: undefined }, credentials, kind, vcap: { name } });
-        }
-
-        await this.writeJsonFile(jsonPath, jsonObject);
-        logger.log(`Saving bindings to ${bold(jsonPath)} in profile ${bold(options.for)}`);
-    }
-
-    async readJsonSafely(filePath) {
-        try {
-            return JSON.parse(await fs.readFile(filePath));
-        } catch (err) {
-            return {};
-        }
-    }
-
-    async writeJsonFile(filePath, content) {
-        await fs.mkdir(path.dirname(filePath), { recursive: true })
-        await fs.writeFile(filePath, JSON.stringify(content, null, 2));
-        await fs.chmod(filePath, 0o600); // -rw-------
-    }
-
-    _getServiceCredentials(binding, services, options) {
-        const { to, 'to-app-services': app, credentials } = options;
-        if (!credentials) {
-            return
-        }
-        // toService has format <service-name>[:<key>]
-        const toServices = to ? to.split(',') : services.map(s => s.binding.instance);
-        const toService = toServices.find(toService => binding.type === 'cf' ?
-            toService === binding.instance || toService === binding.instance + ':' + binding.key :
-            toService === binding.secret);
-        if (!toService) {
-            // must never happen
-            throw new Error(`Internal error: Service ${binding.instance}:${binding.key} not found`);
-        }
-        // app based binding always requires service name as key in credentials
-        if (!app && toServices.length === 1) {
-            return credentials[toService] || credentials;
-        }
-        return credentials[toService];
-    }
-}
-
-module.exports = new UserCdsrcJsonStorageProvider();

package/lib/init/template/destination/files/package.sidecar.json

@@ -1,7 +0,0 @@
-{
-  "cds": {
-    "requires": {
-      "destinations": true
-    }
-  }
-}

package/lib/init/template/html5-repo/files/package.sidecar.json

@@ -1,7 +0,0 @@
-{
-  "cds": {
-    "requires": {
-      "html5-repo": true
-    }
-  }
-}