@sap/cds-dk 6.3.2 → 6.4.1

package/lib/client/helper/errors.js

@@ -2,11 +2,17 @@ const { getMessage } = require('./logging');
 
 class CliError extends Error {
     // noinspection JSAnnotator
-    constructor(message, error) {
-        throw getMessage(message, error);
+    constructor(message, { error, command } = {}) {
+        const help = command && getCommandHelp(command);
+        throw getMessage(message, { error, help });
     }
 }
 
+function getCommandHelp(command) {
+    const cli = require('../../../bin/cds');
+    return cli?.load(command, () => ({ help: '' }))?.help ?? '';
+}
+
 module.exports = {
     CliError
 };

package/lib/client/helper/logging.js

@@ -2,22 +2,24 @@
 
 function debug(debugText, error) {
     if (process.env.DEBUG) {
-        console.log(getMessage(debugText, error));
+        console.log(getMessage(debugText, { error }));
     }
 }
 
-function getMessage(errorText, error) {
+function getMessage(errorText, { error, help } = {}) {
     let message = errorText ? errorText : '';
-    if (!error) {
-        return message;
+    if (error) {
+        message += '\n' + (
+            error.response?.data?.message           // response body == error
+            || error.response?.data?.error?.message // response body == { error }
+            || error.message                        // no response attached
+        );
+        if (process.env.DEBUG && error.stack) {
+            message += '\n' + error.stack;
+        }
     }
-    message += '\n' + (
-           error.response?.data?.message        // response body == error
-        || error.response?.data?.error?.message // response body == { error }
-        || error.message                        // no response attached
-    );
-    if (process.env.DEBUG && error.stack) {
-        message += '\n' + error.stack;
+    if (typeof help === 'string') {
+        message += require('../../../bin/help').formatHelp(help);
     }
     return message;
 }

package/lib/client/params.js

@@ -210,6 +210,9 @@ class AllParams extends BasicParams {
         this.wsdl                   = new Param('wsdl',                   false);
         this.sync                   = new Param('sync',                   false);
 
+        // `login` PARAMS
+        this.skipToken              = new Param('skipToken',              false);
+
         // `logout` PARAMS
         this.deleteSettings         = new Param('deleteSettings',         false);
         this["delete-settings"]     = this.deleteSettings.newAlias('delete-settings');

package/lib/client/pull.js

@@ -41,6 +41,6 @@ module.exports = class Pull extends BaseCommand {
 
         return axios.post(pullUrl, {}, options)
             .then(response => Buffer.from(response.data))
-            .catch(error => this.handleHttpError(error, params, pullUrl));
+            .catch(error => this.handleHttpError(error, params, { url: pullUrl }));
     }
 }

package/lib/client/push.js

@@ -33,12 +33,12 @@ module.exports = class Push extends BaseCommand {
             src = local(src);
         } else {
             if (!schemaRegex.test(src)) {
-                throw new CliError(`Nonexistent path: ${src}`);
+                throw new CliError(`Nonexistent path: ${src}`, { command: 'push' });
             }
             try {
                 content = (await axios.get(src, { responseEncoding: 'base64' })).data;
             } catch (error) {
-                this.handleHttpError(error, params, src);
+                this.handleHttpError(error, params, { url: src });
             }
         }
         return { src, content };
@@ -48,7 +48,7 @@ module.exports = class Push extends BaseCommand {
         try {
             return require(join(projectFolder, 'package.json')).name;
         } catch (error) {
-            throw new CliError(`Extension project at ${projectFolder} is missing package.json file`, error);
+            throw new CliError(`Extension project at ${projectFolder} is missing package.json file`, { error, command: 'push' });
         }
     }
 
@@ -60,6 +60,6 @@ module.exports = class Push extends BaseCommand {
             extension: tgz,
             tag: extensionName
         }, options)
-            .catch(error => this.handleHttpError(error, params, pushUrl));
+            .catch(error => this.handleHttpError(error, params, { url: pushUrl }));
     }
 }

package/lib/client/settings_manager.js

@@ -171,7 +171,7 @@ class SettingsManager {
         }
         await this._saveToFile(params.get('projectFolder'), paramsMap);
 
-        if (!params.has('token')) {
+        if (params.get('skipToken') || !params.has('token')) {
             return;
         }
 
@@ -206,6 +206,9 @@ class SettingsManager {
 
         params.mergeLower(loadedSettings);
 
+        if (params.has('username')) {
+            params.set('skipToken', true);
+        }
         await this.updateUrls(params, logout, loadedAppUrl);
         await this.checkKeytar(params, logout);
         await this.addAuth(params, logout);
@@ -216,7 +219,7 @@ class SettingsManager {
         async function addAppUrlAndSubdomain() {
             function needsSubdomain() {
                 // Subdomain needed for token retrieval.
-                return params.has('appUrl') && !localhostRegex.test(params.get('appUrl')) && !params.has('username');
+                return params.has('appUrl') && !localhostRegex.test(params.get('appUrl')) && !params.get('skipToken');
             }
 
             // Prefix URL schema
@@ -273,12 +276,15 @@ class SettingsManager {
 
         await addAppUrlAndSubdomain();
 
-        if (!logout) {
+        if (!logout && !params.get('skipToken')) {
             await renewTokenUrl();
         }
     }
 
     static async checkKeytar(params, logout) {
+        if (params.get('skipToken')) {
+            return;
+        }
         if (isBas()) {
             if (params.get('tokenStorage') === 'keyring') {
                 console.log('NOTE:', capitalize(TOKEN_STORAGE_DESC.keyring), 'not supported on SAP Business Application Studio. Switching to', TOKEN_STORAGE_DESC.plain, '.');
@@ -286,9 +292,6 @@ class SettingsManager {
             }
             return;
         }
-        if (params.get('username')) {
-            return;
-        }
         keytar = requireGlobal('keytar');
         if (keytar) {
             return;
@@ -378,6 +381,10 @@ class SettingsManager {
             params.delete('isEmptyPassword');
         }
 
+        if (params.get('skipToken')) {
+            return;
+        }
+
         if (params.get('clientid') && !params.get('clientsecret') && !logout) {
             await addClientSecret();
         }

package/lib/client/subscription.js

@@ -0,0 +1,81 @@
+let cds;
+const BaseCommand = require('./base_command');
+const { CliError } = require('./helper/errors');
+const { ParamCollection } = require('./params');
+const AuthManager = require('./auth_manager');
+const { capitalize } = require('./helper/string_helper');
+
+module.exports = class ToggleSubscription extends BaseCommand {
+
+    /**
+     * @param on {boolean} whether to switch subscription on
+     */
+    constructor(on) {
+        super();
+        const prefix = on ? '' : 'un';
+        this.command = prefix + 'subscribe';
+        this.gerund = prefix + 'subscribing';
+        this.noun = prefix + 'subscription';
+    }
+
+    async run(paramValues, { tenant, local } = {}) {
+        cds = require('../cds');
+        let params = new ParamCollection(paramValues);
+        params.set('skipToken', true); // Token would have insufficient scopes for this command.
+        if (local) {
+            // Connect to locally-served MTXS
+            await this.runWithServer(params, tenant);
+        } else {
+            // Connect to running MTXS server
+            params = await AuthManager.login(params.toValueMap());
+            if (!params.has('username')) {
+                throw new CliError('Username is required if app URL is given.', { command: this.command });
+            }
+            await this.runClientOnly(params, tenant);
+        }
+        console.log(`${capitalize(this.noun)} successful.`);
+    }
+
+    async runClientOnly(params, tenant) {
+        console.log(capitalize(this.gerund), { tenant }, 'from', { url: params.get('appUrl') });
+        const url = `${params.get('appUrl')}/-/cds/deployment/${this.command}`;
+        try {
+            await require('axios').post(url, { tenant }, params.get('reqAuth'));
+        } catch (error) {
+            BaseCommand.handleHttpError(error, params, { url });
+        }
+    }
+
+    async runWithServer(params, tenant) {
+        if (!this.hasMtEnv()) {
+            throw new CliError('Local multitenant application environment with @sap/cds-mtxs module not found.', { command: this.command });
+        }
+
+        console.log(capitalize(this.gerund), { tenant });
+        const { 'cds.xt.DeploymentService': deploymentService } = await cds.serve([
+            '@sap/cds-mtxs/srv/deployment-service',
+            '@sap/cds-mtxs/srv/model-provider'
+        ]);
+        cds.emit('served');
+        if (this.command === 'unsubscribe') {
+            // MTXS doesn't connect automatically because unsubscribe requires no schema changes
+            await cds.connect.to('db');
+        }
+
+        await deploymentService[this.command](tenant);
+
+        if (cds.db) {
+            await cds.disconnect(cds.env.requires.multitenancy?.t0 ?? 't0'); // REVISIT: Ideally not necessary
+        }
+    }
+
+    /**
+     * Check for application environment.
+     * Fails for edge cases (ignored for now):
+     * - @sap/cds-mtx application with missing modules (no npm install)
+     * - dev scenario with both @sap/cds-mtx and @sap/cds-mtxs installed
+     */
+    hasMtEnv() {
+        return cds.requires.multitenancy && !cds.mtx;
+    }
+}

package/lib/compile/to-xsuaa.js

@@ -14,31 +14,37 @@ module.exports = function compile_to_xsuaa (model, options) {
   const scopes = {}
   const attributes = {}
 
-  const findUserAttrInExpression = (expr, attributes = []) => {
-    if (Array.isArray(expr)) { // descend arrays
-      expr.forEach(e => findUserAttrInExpression(e, attributes))
-    }
-    else if (typeof expr === 'object' && expr.ref) {
-      const userIdx = expr.ref.indexOf('$user')
-      if (userIdx >= 0 && userIdx < expr.ref.length - 1) {
-        const attr = expr.ref[userIdx + 1]
-        if (!hardcoded.Attributes.includes(attr)) attributes.push(attr)
-      }
-    }
-    return attributes
-  }
-
   const parseAttributes = (condition) => { // e.g. 'foo = $user.bar or baz = $user.boo'
     if (!condition) return []
 
+    // first validate basic syntax of expression by parsing it
+    let expr
     try {
-      // {"xpr":[{"ref":["foo"]},"=",{"ref":["$user","bar"]},"or",{"ref":["baz"]},"=",{"ref":["$user","boo"]}]}
-      const expr = cds.parse.expr(condition)
-      // find paths value following $user, i.e. 'bar' and 'boo'
-      return findUserAttrInExpression(expr.xpr)
+      expr = cds.parse.expr(condition).xpr
     } catch (err) {
-      throw new Error(`${err.message} in '${condition}'`)
+      throw new Error(`Invalid expression': ${err.message}`)
     }
+
+    // Reject expressions like `$user.foo.bar`, as xsuaa attributes are primitive, not structured
+    expr.forEach(expr => {
+      const userIdx = expr.ref?.indexOf('$user')
+      if (userIdx >= 0 && expr.ref.length > userIdx+2) {
+        throw new Error (`Structured attributes like '${expr.ref.join('.')}' are not supported`)
+      }
+    })
+
+    // Reject expressions like `$user.foo-bar`
+    // Impl. note: use the expression string rather than the parsed expression as the above example would be
+    // `[ { ref: [ '$user', 'foo' ] }, '-', { ref: [ 'bar' ] } ]`
+    // making it ambiguous to tell if it was `$user.foo-bar` or `$user.foo - bar`
+    return Array.from(condition.matchAll(/\$user\s*\.\s*(\S*)/g))
+      .map(m => m[1])
+      .filter(m => !hardcoded.Attributes.includes(m))
+      .map(m => {
+        // see https://help.sap.com/docs/CP_AUTHORIZ_TRUST_MNG/ae8e8427ecdf407790d96dad93b5f723/517895a9612241259d6941dbf9ad81cb.html#attributes
+        if (!/^[a-zA-Z0-9_]*$/.test(m))  throw new Error(`Illegal attribute name '${m}' in '${condition}'. Only characters a-z, A-Z, 0-9, _ are allowed.`)
+        return m
+      })
   }
 
   cds.reflect(model).foreach(def => {

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -446,7 +446,7 @@ class Expression {
         if (args.includes('$IsFlags') && attribs.IsFlags === 'true') target.$IsFlags = true;
         if (args.includes('$Alias') && attribs.Alias) target.$Alias = attribs.Alias;
         if (args.includes('$Namespace') && attribs.Namespace) target.$Namespace = attribs.Namespace;
-
+        if (args.includes('$OpenType') && attribs.OpenType) target.$OpenType = attribs.OpenType;
         if (args.includes('$BaseType') && attribs.BaseType) target.$BaseType = attribs.BaseType;
         if (args.includes('$MaxLength') && attribs.MaxLength != null && attribs.MaxLength.toLowerCase() !== 'max') {
             target.$MaxLength = parseInt(attribs.MaxLength, 10);
@@ -2003,7 +2003,7 @@ class EntityTypeExpression extends AbstractTypeExpression {
     constructor(element, expression, context) { super(element, expression, context, 'EntityType'); }
     interpret() {
         const result = super.interpret();
-        this.buildTypeCollectionAndFacets('$Type', '$BaseType', '$HasStream');
+        this.buildTypeCollectionAndFacets('$Type', '$BaseType', '$HasStream', '$OpenType');
         return result;
     }
 }
@@ -2012,7 +2012,7 @@ class ComplexTypeExpression extends AbstractTypeExpression {
     constructor(element, expression, context) { super(element, expression, context, 'ComplexType'); }
     interpret() {
         const result = super.interpret();
-        this.buildTypeCollectionAndFacets('$Type', '$BaseType', '$HasStream');
+        this.buildTypeCollectionAndFacets('$Type', '$BaseType', '$HasStream', '$OpenType');
         return result;
     }
 }

package/lib/import/odata/v2parser.js

@@ -54,6 +54,7 @@ function _initialize(parserContext) {
 	parserContext.allComplexTypeDocs = {};
 	parserContext.allComplexTypeNamespaces = {};
 	parserContext.allInheritedComplexTypes = {};
+	parserContext.allInheritedEntityTypes = {};
 	parserContext.allowedNamespaces = [];
 	parserContext.allowAllNamespaces = false;
 }
@@ -339,13 +340,16 @@ function _extractComplexType(complexType, parserContext) {
 			complexTypeKey = parserContext.serviceNamespace + "." + complexType[key].Name;
 			namespaceAttributes = namespaceAttributeFilter(complexType[key], parserContext);
 			baseType = complexType[key].BaseType;
+			if (complexType[key].Abstract || complexType[key].OpenType) {
+				complexType.open = true;
+			}
 		} else if (key === "Property") {
 			properties = complexType.Property;
 		} else if (key === "Documentation") {
 			parserContext.allComplexTypeDocs[complexTypeKey] = _parseDocumentationTag(complexType.Documentation);
 		}
 	});
-	parserContext.allComplexTypes[complexTypeKey] = properties;
+	parserContext.allComplexTypes[complexTypeKey] = complexType;
 	if (complexTypeKey && baseType) {
 		parserContext.allInheritedComplexTypes[complexTypeKey] = baseType;
 	}
@@ -381,7 +385,7 @@ function _getServiceEntityProperty(
 ) {
 	let isCollection = -1;
 	//preprocessing of datatype in case it is a collection
-	if (dataType.substring(0, 10) === 'Collection') {
+	if (dataType && dataType.substring(0, 10) === 'Collection') {
 		dataType = dataType.substring(11, dataType.length - 1);
 		isCollection = 1;
 	}
@@ -483,15 +487,11 @@ function _getServiceEntityProperty(
 				propertyJson = propertyJson + ',\n"scale":' + 0;
 			}
 		}
-		if (nullable == "false") {
+		if (nullable === "false")
 			propertyJson = propertyJson + ',\n"notNull": true';
-		}
-		else if(nullable=="true" || !nullable){
-			propertyJson = propertyJson + ',\n"notNull": false';
-		}
 		propertyJson = propertyJson + '\n}'
 	}
-	else{
+	else {
 		propertyJson = propertyJson + '"type":"' + cdsDataType + '"';
 			//if annotations to be added
 		if (edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date") {
@@ -528,13 +528,8 @@ function _getServiceEntityProperty(
 		propertyJson += _generateNamespaceAttributes(allowedNamespaceAttributes, true);
 	}
 
-	if(isCollection == -1) {
-		if (nullable === "false") {
-			propertyJson = propertyJson + ',\n"notNull": true';
-		}
-		else if(nullable=="true" || !nullable){
-			propertyJson = propertyJson + ',\n"notNull": false';
-		}
+	if (isCollection === -1 && nullable === "false") {
+		propertyJson = propertyJson + ',\n"notNull": true';
 	}
 
 	if (propertyName)
@@ -542,11 +537,14 @@ function _getServiceEntityProperty(
 	return propertyJson;
 }
 
-function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
+function _getServiceComplexType(complexTypeKey, complexType, parserContext, isOpenType) {
 	let complexTypeCSN = '"' + complexTypeKey + '": {\n';
 	let complexTypeProperty;
-	let i;
 	complexTypeCSN = complexTypeCSN + '"kind": "type",\n';
+	// checking if the ComplexType is marked open or acts as a BaseType
+	if (isOpenType === true || Object.values(parserContext.allInheritedComplexTypes).indexOf(complexTypeKey) > -1) {
+		complexTypeCSN = complexTypeCSN + '"@open": true,\n';
+	}
 	complexTypeCSN = complexTypeCSN + '"@cds.external": true,\n';
 	if (parserContext.allComplexTypeNamespaces[complexTypeKey]) {
 		complexTypeCSN += _generateNamespaceAttributes(parserContext.allComplexTypeNamespaces[complexTypeKey], false);
@@ -557,14 +555,14 @@ function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 	if (complexType) {
 		if (complexType.length) {
 			// More than one complex types
-			for (i = 0; i < complexType.length; i++) {
+			for (let i = 0; i < complexType.length; i++) {
 				complexTypeProperty = complexType[i]._attributes;
 				if (complexType[i].Documentation)
 					complexTypeProperty.doc = _parseDocumentationTag(complexType[i].Documentation);
 				let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty, parserContext);
 				const complexTypePropertyNamespace = namespaceAttributes.length ? namespaceAttributes : -1
 
-				let complexProperty = 
+				let complexProperty =
 					_getServiceEntityProperty(
 						complexTypeProperty.Name,
 						complexTypeProperty.Type,
@@ -617,7 +615,7 @@ function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 	complexTypeCSN = complexTypeCSN + "}\n";
 	if (parserContext.allInheritedComplexTypes[complexTypeKey]) {
 		complexTypeCSN = complexTypeCSN + ",\n";
-		complexTypeCSN = complexTypeCSN + 
+		complexTypeCSN = complexTypeCSN +
 			'"includes": ["' + parserContext.allInheritedComplexTypes[complexTypeKey] + '"]\n';
 	}
 	complexTypeCSN = complexTypeCSN + "}\n";
@@ -629,10 +627,12 @@ function _getServiceComplexTypes(parserContext) {
 	let complexTypesKeys = Object.keys(parserContext.allComplexTypes);
 	let complexTypeKey;
 	let complexType;
+	let isOpenType;
 	for (let i = 0; i < complexTypesKeys.length; i++) {
 		complexTypeKey = complexTypesKeys[i];
-		complexType = parserContext.allComplexTypes[complexTypesKeys[i]];
-		complexTypeCSN = complexTypeCSN + _getServiceComplexType(complexTypeKey, complexType, parserContext);
+		complexType = parserContext.allComplexTypes[complexTypeKey].Property;
+		isOpenType = parserContext.allComplexTypes[complexTypeKey].open;
+		complexTypeCSN = complexTypeCSN + _getServiceComplexType(complexTypeKey, complexType, parserContext, isOpenType);
 		if (i !== complexTypesKeys.length - 1) {
 			complexTypeCSN = complexTypeCSN + ",\n";
 		} else {
@@ -787,6 +787,7 @@ function _parseEntityAttributes(attributes, parserContext) {
 	entityAttributes.Name = attributes.Name;
 	entityAttributes.BaseType = attributes.BaseType;
 	entityAttributes.Abstract = attributes.Abstract;
+	entityAttributes.OpenType = attributes.OpenType;
 	entityAttributes.allowedNamespaceAttributes = namespaceAttributeFilter(attributes, parserContext);
 
 	return entityAttributes;
@@ -1304,6 +1305,11 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc, pa
 	}
 	// annotation for on conditions
 	csn = csn + `"@cds.ambiguous": "missing on condition?",\n`;
+
+	//Code for notNull working but change is not reflecting when we use: cds compile {file-path} -2 edmx > {newFileName} 
+	/*if (navPropAttributes.Nullable === "false")
+		csn = csn + '"notNull": true,\n';*/
+
 	// if documentation exists for navigation property
 	if (navPropDoc)
 		csn = csn + '"doc":' + ` "${navPropDoc}",\n`;
@@ -1396,8 +1402,8 @@ function _constructServiceEntity(
 		csnEntity = csnEntity + '"@cds.persistence.skip": true,\n';
 	}
 
-	if (entityAttributes.Abstract && entityAttributes.Abstract.toUpperCase() === "TRUE") {
-		csnEntity = csnEntity + '"abstract": true,\n';
+	if ((entityAttributes.Abstract && entityAttributes.Abstract.toUpperCase() === "TRUE") || (entityAttributes.OpenType && entityAttributes.OpenType.toUpperCase() === "TRUE")) {
+		csnEntity = csnEntity + '"@open": true,\n'
 	}
 
 	/* Merging the namespace list from entity set and entity type
@@ -1525,6 +1531,7 @@ function _parseServiceEntity(entityName, entity, ignorePersistenceSkip, mockServ
 	// If inherited entity found
 	if (entityAttributes.BaseType) {
 		parserContext.allEntities.push(_extractEntityFromNamespace(entityAttributes.BaseType));
+		parserContext.allInheritedEntityTypes[_extractEntityFromNamespace(entityAttributes.BaseType)] = entity["_attributes"].Name;
 	}
 	// adding blob element if entity has m:HasStream as true
 	const checkProperty = entityAttributes["allowedNamespaceAttributes"].filter(e => e["m.HasStream"] === 'true');
@@ -1614,6 +1621,12 @@ function _getServiceEntitites(entityJson = [], ignorePersistenceSkip, mockServer
 		if (entitiesWithNames[i].length) {
 			parsedEntities[i] = _parsingServiceEntities(entitiesWithNames[i],
 				ignorePersistenceSkip, mockServerUc, parserContext);
+			// adding @open annotation to BaseTypes
+			for (let j = 0; j < parsedEntities[i].length; j++) {
+				if (parserContext.allInheritedEntityTypes[_extractEntityFromNamespace(parserContext.allEntitySetMap[entitiesWithNames[i][j].name])] != undefined || parserContext.allInheritedEntityTypes[entitiesWithNames[i][j].name]) {
+					parsedEntities[i][j] = parsedEntities[i][j].replace(/}$/, ',"@open": true' + '}');
+				}
+			}
 		}
 	}
 	// if entities from entity set and entity type both are parsed