@sap/cds-dk 7.9.6 → 8.0.3

package/lib/import/openapi/importOpenAPI.js

@@ -104,6 +104,8 @@ function operations(context, csn, input) {
                 cdsOperation["@openapi.method"] = method.toUpperCase();
             cdsOperation["@openapi.path"] = path;
 
+            let bodyParam;
+
             for (let param of globalParameters.concat(operation.parameters || [])) {
                 if (param.$ref) {
                     // resolve reuse parameter
@@ -116,7 +118,10 @@ function operations(context, csn, input) {
                     param = reuseParameters[param.$ref.substring(expectedPrefix.length)];
                 }
 
-                if (param.in === "body") continue;
+                if (param.in === "body") {
+                    bodyParam = param;
+                    continue;
+                }
                 if (STANDARD_HEADERS.includes(param.name.toLowerCase())) continue;
 
                 const cdsParam = cdsType(
@@ -160,11 +165,13 @@ function operations(context, csn, input) {
                 cdsOperation.params[name] = cdsParam;
             }
 
-            const schema = requestBodySchema(context, operation);
-            if (schema) {
-                cdsOperation.params.body = cdsType(context, schema);
-                cdsOperation.params.body["@openapi.in"] = "body";
-            }
+            const schema = context.v3
+          ? requestBodySchema(context, operation.requestBody, input.components)
+          : v2Schema(context, bodyParam?.schema, operation.consumes);
+        if (schema) {
+          cdsOperation.params.body = cdsType(context, schema);
+          cdsOperation.params.body["@openapi.in"] = "body";
+        }
 
             if (!operation.responses)
                 throw new Error(`TODO: no responses for path ${path}, method ${method}`);
@@ -186,8 +193,8 @@ function operations(context, csn, input) {
                             reuseResponses[response.$ref.substring(expectedPrefix.length)];
                 }
                 const responseSchema = context.v3
-                    ? response.content?.["application/json"]?.schema
-                    : response.schema;
+            ? v3Schema(context, response)
+            : v2Schema(context, response.schema, operation.produces);
                 if (responseSchema)
                     cdsOperation.returns = cdsType(context, responseSchema);
                 else if (method === "get")
@@ -209,13 +216,64 @@ function operations(context, csn, input) {
     }
 }
 
-function requestBodySchema(context, operation) {
-    const requestBody = context.v3
-        ? operation.requestBody
-        : operation.parameters?.find((p) => p.in === "body");
-    return context.v3
-        ? requestBody?.content["application/json"]?.schema
-        : requestBody?.schema;
+function requestBodySchema(context, requestBody, components) {
+    while (requestBody?.$ref) {
+        const expectedPrefix = "#/components/requestBodies/";
+        if (!requestBody.$ref.startsWith(expectedPrefix)) {
+            requestBody = undefined;
+            throw new Error(`TODO: unexpected request body reference ${requestBody.$ref}`)
+        } 
+        else {
+            requestBody =
+                components?.requestBodies[
+                requestBody.$ref.substring(expectedPrefix.length)
+                ];
+        }
+    }
+
+    return v3Schema(context, requestBody);
+}
+
+function v3Schema(context, body) {
+    if (!body?.content) return undefined;
+
+    const contentTypes = Object.keys(body.content);
+    if (contentTypes.includes("application/json"))
+        return body.content["application/json"].schema;
+
+    if (contentTypes.length === 0) return undefined;
+
+    if (contentTypes.length > 1)
+        context.messages.push({
+            message: `Multiple requestBody content-types not including application/json`,
+            input: contentTypes,
+        });
+
+    const contentType = contentTypes[0];
+
+    return {
+        $contentType: contentType,
+        ...body.content[contentType]?.schema,
+    };
+}
+
+function v2Schema(context, schema, contentTypes) {
+    if (
+        !schema ||
+        !contentTypes ||
+        contentTypes.includes("application/json") ||
+        contentTypes.includes("application/json;charset=utf-8") ||
+        contentTypes.includes("application/json;charset=UTF-8")
+    )
+        return schema;
+
+    // take the first content type if there are multiple
+    const contentType = contentTypes[0];
+
+    return {
+        $contentType: contentType,
+        ...schema,
+    };
 }
 
 function cdsType(
@@ -230,9 +288,23 @@ function cdsType(
 
     if (!arrayItem) if (schema.title) type["@title"] = schema.title;
     if (schema.description) type["@description"] = schema.description;
+    if (schema.$contentType && schema.$contentType !== '*/*')
+        type['@openapi.contentType'] = schema.$contentType;
+
 
     if (schema.$ref) {
-        type.type = referencedType(context, schema.$ref).name;
+        const refType = referencedType(context, schema.$ref);
+        let nRefType = refType;
+        if (refType.schema?.$ref)
+            nRefType = indirectlyReferencedType(context, refType.schema);
+        if (namedType && normalizeSchemaType(nRefType.schema) === "object") {
+            type.kind = "type";
+            type.includes = [refType.name];
+            type.elements = {};
+        } else {
+            type.type = refType.name;
+            if (schema.maxLength) type.length = schema.maxLength;
+        }
         return type;
     }
 
@@ -241,7 +313,7 @@ function cdsType(
     switch (schemaType) {
         case "array":
             //TODO: complain if "xml"
-            {
+            if (schema.items) {
                 const itemsType = cdsType(
                     context,
                     schema.items,
@@ -258,6 +330,8 @@ function cdsType(
                 } else {
                     type.items = itemsType;
                 }
+            } else {
+                type = someJSON(context, schema, arrayItem, type);
             }
             break;
 
@@ -354,33 +428,62 @@ function cdsType(
 
         case undefined:
             schemaType = bestMatchingType(context, schema);
+            if (
+                (!namedType || schemaType !== "object") && schema.allOf && schema.allOf.length === 1 &&
+                Object.keys(schema).filter(
+                    (k) => !["description", "nullable"].includes(k) && !k.startsWith("x-")
+                ).length === 1) {
+                const normalizedSchema = { ...schema.allOf[0] };
+                if (schema.description) normalizedSchema.description = schema.description;
+                type = cdsType(context, normalizedSchema, arrayItem, namedType, forParameter);
+                break;
+            }
+            if (schema.allOf && schema.allOf.length === 2 && schema.allOf[0].$ref && !schema.allOf[1].$ref && normalizeSchemaType(schema.allOf[1]) !== "object") {
+                const normalizedSchema = Object.assign(
+                    { ...schema.allOf[0] },
+                    schema.allOf[1]
+                );
+                type = cdsType(
+                    context,
+                    normalizedSchema,
+                    arrayItem,
+                    namedType,
+                    forParameter
+                );
+                break;
+            }
+
             if (schemaType) {
                 schema.type = schemaType;
-                type = cdsType(context, schema, arrayItem, namedType);
+                type = cdsType(context, schema, arrayItem, namedType, forParameter);
                 break;
             }
 
         // last resort
         // eslint-disable-next-line no-fallthrough
         default:
-            {
-                context.JSON = true;
-                const jsonSchema = minimalSchema(schema);
-                if (arrayItem && jsonSchema !== "{}") {
-                    type = anonymousType(context, {
-                        type: "common.JSON",
-                        "@JSON.Schema": jsonSchema,
-                    });
-                } else {
-                    type.type = "common.JSON";
-                    if (jsonSchema !== "{}") type["@JSON.Schema"] = jsonSchema;
-                }
-            }
+            type = someJSON(context, schema, arrayItem, type);
             break;
     }
     return type;
 }
 
+function someJSON(context, schema, arrayItem, type) {
+    context.JSON = true;
+    const jsonSchema = minimalSchema(schema);
+    if (arrayItem && jsonSchema !== "{}") {
+        type = anonymousType(context, {
+            type: "common.JSON",
+            "@openapi.schema": jsonSchema,
+        });
+    }
+    else {
+        type.type = "common.JSON";
+        if (jsonSchema !== "{}") type["@openapi.schema"] = jsonSchema;
+    }
+    return type;
+}
+
 function addDefault(type, schema, forParameter) {
     if (schema.default !== undefined) type.default = { val: schema.default };
     if (forParameter) return;
@@ -397,6 +500,7 @@ function minimalSchema(schema) {
     const s = { ...schema };
     delete s.title;
     delete s.description;
+    delete s.$contentType;
     return JSON.stringify(s);
 }
 
@@ -420,19 +524,17 @@ function bestMatchingType(context, schema) {
         for (const subSchema of xOf) {
             // determine overall type of this construct
             if (subSchema.$ref) {
-                let refType = { schema: subSchema };
-                let limit = 10;
-                while (refType.schema.$ref && limit-- > 0)
-                    refType = referencedType(context, refType.schema.$ref);
-                if (
-                    refType.schema.allOf ||
-                    refType.schema.anyOf ||
-                    refType.schema.oneOf
-                ) {
+                const refType = indirectlyReferencedType(context, subSchema);
+                if (!refType.schema) return undefined;
+
+                if (refType.schema.allOf || refType.schema.anyOf || refType.schema.oneOf) {
                     const subType = bestMatchingType(context, refType.schema);
                     type = betterType(type, { type: subType });
-                } else type = betterType(type, refType.schema);
-            } else {
+                }
+
+                else type = betterType(type, refType.schema);
+            }
+            else {
                 //TODO: nested xOf - not yet encountered
                 type = betterType(type, subSchema);
             }
@@ -441,6 +543,14 @@ function bestMatchingType(context, schema) {
     return type;
 }
 
+function indirectlyReferencedType(context, subSchema) {
+    let refType = { schema: subSchema };
+    let limit = 10;
+    while (refType.schema?.$ref && limit-- > 0)
+        refType = referencedType(context, refType.schema.$ref);
+    return refType;
+}
+
 function referencedType(context, ref) {
     const expectedPrefix = context.v3
         ? "#/components/schemas/"
@@ -457,7 +567,13 @@ function referencedType(context, ref) {
 }
 
 function normalizeSchemaType(schema) {
+    if (!schema) return undefined;
     if (!schema.type && schema.items) return "array";
+    if (!schema.type && schema.maxLength) return "string";
+    if (!schema.type && schema.pattern) return "string";
+
+    if (!schema.type && schema.enum?.every((v) => typeof v === "string"))
+        return "string";
 
     if (
         !schema.type &&
@@ -476,6 +592,12 @@ function normalizeSchemaType(schema) {
             schemaType.splice(index, 1);
         }
         if (schemaType.length === 1) schemaType = schemaType[0];
+        if (
+            schemaType.length === 2 &&
+            schemaType[0] === "integer" &&
+            schemaType[1] === "number"
+        )
+            return "number";
     }
     return schemaType;
 }

package/lib/index.js

@@ -7,22 +7,19 @@ class CdsDk {
     return super.import = require('./import/importapi')
   }
 
+  /** @type { import('./cds').compile } */
   get compile() {
     let compile = require(_local('@sap/cds/lib/compile/cds-compile'))
     cds.extend (compile.to.constructor) .with (class {
-      get asyncapi() { return super.asyncapi = require('./compile/asyncapi') }
-      get openapi() { return super.openapi = require('./compile/openapi') }
+      get asyncapi() { return super.asyncapi = require('./compile/to_asyncapi') }
+      get openapi() { return super.openapi = require('./compile/to_openapi') }
       get xsuaa(){ return super.xsuaa = require('./compile/to-xsuaa') }
+      get mermaid(){ return super.mermaid = require('./compile/to-mermaid') }
       'edmx-v2'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'v2'}) }
       'edmx-v4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'v4'}) }
       'edmx-w4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'w4'}) }
       'edmx-x4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'x4'}) }
     })
-    // Compat to cds <=6. Esp. BAS tools need it, see cap/issues#13918
-    // TODO remove compat w/ cds-dk 8
-    if (compile.to.constructor.name === 'Object') { // not a class as in cds 7
-      compile.to.xsuaa = require('./compile/to-xsuaa')
-    }
     return super.compile = compile
   }
 
@@ -52,15 +49,16 @@ if (process.argv[2] in { add:1, init:1, help:1 }) {
   cds.extend (cds.constructor) .with (CdsDkBuild)
 }
 
-const MIN_SUPPORTED_CDS_VERSION = 6
-const [cdsVersion] = cds.version.split('.')
-if (parseInt(cdsVersion) < MIN_SUPPORTED_CDS_VERSION) {
+const REQUIRED_CDS_MAJOR = 7, REQUIRED_CDS_MINOR = 2
+const [major, minor] = cds.version.split('.').map(Number)
+if (major < REQUIRED_CDS_MAJOR || major === REQUIRED_CDS_MAJOR && minor < REQUIRED_CDS_MINOR) {
   const [dkVersion] = require('../package.json').version.split('.')
+   
   console.error(`
-  This application uses '@sap/cds' version ${cdsVersion}, which is not compatible with the installed '@sap/cds-dk' version ${dkVersion}.
+  This application uses '@sap/cds' version ${major}.${minor}, which is not compatible with the installed '@sap/cds-dk' version ${dkVersion}.
   You can either:
   - update '@sap/cds' to the latest version (recommended)
-  - downgrade '@sap/cds-dk' to version ${MIN_SUPPORTED_CDS_VERSION}
+  - downgrade '@sap/cds-dk' to version ${REQUIRED_CDS_MAJOR}
 `)
   process.exit(1)
 }

package/lib/init/bas.js

@@ -0,0 +1,91 @@
+const path = require('node:path')
+const cds = require('../../lib/cds')
+const validate = require('./validate')
+const { bold } = require('../util/term')
+const { OPTIONS } = require('./constants')
+const {
+  NODEJS, JAVA,
+  HANA, APPROUTER, XSUAA, APPLICATION_LOGGING, ENTERPRISE_MESSAGING,
+  MTA, MULTITENANCY, PIPELINE,
+  TINY_SAMPLE, SAMPLE
+} = OPTIONS
+const cwd = process.cwd()
+
+module.exports = [{
+  title: 'Project Name',
+  description: 'Enter your project name.',
+  default: '',
+  target: 'projectName',
+  validate: async projectName => {
+      try {
+          cds.root = path.resolve(cwd, projectName || '.')
+          validate.projectName(projectName)
+          validate.projectFolder(path.join(cwd, projectName), cwd)
+      } catch (e) {
+          return e //  BAS Yeoman generator requires error to be returned
+      }
+      return true
+  },
+  guiOptions: {
+      hint: 'This name is restricted to certain characters. A valid project name is compatible across platforms.',
+      mandatory: true
+  }
+}, {
+  title: 'Type',
+  description: `Select your runtime.`,
+  default: NODEJS,
+  choices: [
+      { name: 'Node.js', value: NODEJS },
+      { name: 'Java', value: JAVA }
+  ],
+  multiple: false,
+  target: 'add',
+  guiOptions: {
+      hint: `The preferred runtime can't be changed afterwards. To use a different runtime, create a new project.`,
+      mandatory: true
+  }
+}, {
+  title: 'Features',
+  description: 'Choose productive runtime capabilities for your application.',
+  default: '',
+  choices: [
+      { name: 'SAP HANA Cloud', value: HANA },
+      { name: 'SAP Application Router', value: APPROUTER },
+      { name: 'User Authentication via XSUAA', value: XSUAA },
+      { name: 'Application Logging', value: APPLICATION_LOGGING },
+      { name: 'SAP BTP Event Mesh', value: ENTERPRISE_MESSAGING }
+  ],
+  multiple: true,
+  target: 'add',
+  guiOptions: {
+      hint: `Choose any combination of features enriching the capabilities of your project. You can also add features later with ${bold('cds add')}`
+  }
+}, {
+  title: 'Deployment',
+  description: 'Choose which way to deploy your project.',
+  default: '',
+  choices: [
+      { name: 'Cloud Foundry: MTA Deployment', value: MTA },
+      // { name: 'Kyma: Helm Deployment', value: HELM },
+      { name: 'Multitenancy', value: MULTITENANCY },
+      { name: 'CI/CD Pipeline Integration', value: PIPELINE },
+  ],
+  multiple: true,
+  target: 'add',
+  guiOptions: {
+      hint: `Choose any combination of features enriching the capabilities of your project. You can also add features later with ${bold('cds add')}`
+  }
+}, {
+  title: 'Samples',
+  description: `Add sample content to your project.`,
+  default: '',
+  choices: [
+      { name: 'Minimal Sample', value: TINY_SAMPLE },
+      { name: 'Extended Sample with UI', value: SAMPLE }
+  ],
+  multiple: true,
+  target: 'add',
+  guiOptions: {
+      hint: 'Speed up your ramp-up phase with sample files in your project.'
+  }
+}]

package/lib/init/constants.js

@@ -5,9 +5,10 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [17, 21],
-    MAVEN_ARCHETYPE_VERSION: '2.10.1',
+    MAVEN_ARCHETYPE_VERSION: '3.0.0',
 
     OPTIONS: Object.freeze({
+        COMPLETION: 'completion',
         JAVA: 'java',
         JAVA_MVN: 'java:mvn',
         JAVA_PACKAGE: 'java:package',
@@ -15,22 +16,24 @@ module.exports = {
         SAMPLES: 'samples', // deprecated
         TINY_SAMPLE: 'tiny-sample',
         SAMPLE: 'sample',
-        PIPELINE: 'pipeline',
-        HELM_UNIFIED_RUNTIME: 'helm-unified-runtime',
-        HELM: 'helm',
         MTA: 'mta',
-        CONNECTIVITY: 'connectivity',
         CF_MANIFEST: 'cf-manifest',
-        MTX: 'mtx',
+        HELM: 'helm',
+        HELM_UNIFIED_RUNTIME: 'helm-unified-runtime',
+        CONTAINERIZE: 'containerize',
         MULTITENANCY: 'multitenancy',
         TOGGLES: 'toggles',
         EXTENSIBILITY: 'extensibility',
+        MTX: 'mtx',
         XSUAA: 'xsuaa',
         HANA: 'hana',
         POSTGRES: 'postgres',
         SQLITE: 'sqlite',
         H2: 'h2',
         LIQUIBASE: 'liquibase',
+        REDIS: 'redis',
+        ATTACHMENTS: 'attachments',
+        MALWARE_SCANNER: 'malware-scanner',
         LOCAL_MESSAGING: 'local-messaging',
         FILE_BASED_MESSAGING: 'file-based-messaging',
         ENTERPRISE_MESSAGING: 'enterprise-messaging',
@@ -38,24 +41,31 @@ module.exports = {
         REDIS_MESSAGING: 'redis-messaging',
         KAFKA: 'kafka',
         APPROUTER: 'approuter',
+        CONNECTIVITY: 'connectivity',
         DESTINATION: 'destination',
-        DATA: 'data',
+        HTML5_REPO: 'html5-repo',
+        PORTAL: 'portal',
         APPLICATION_LOGGING: 'application-logging',
+        AUDIT_LOGGING: 'audit-logging',
+        NOTIFICATIONS: 'notifications',
+        WORKZONE: 'workzone',
+        WORKZONE_STANDARD: 'workzone-standard',
+        DATA: 'data',
+        HTTP: 'http',
         LINT: 'lint',
         LINT_GLOBAL: 'lint:global',
         LINT_DEV: 'lint:dev',
+        PIPELINE: 'pipeline',
         TYPER: 'typer',
-        HTML5_REPO: 'html5-repo',
-        NOTIFICATIONS: 'notifications'
+        TYPESCRIPT: 'typescript'
     }),
 
     REGEX_JAVA_PACKAGE: /^[a-z_][a-z0-9_]*(\.[a-z_][a-z0-9_]*)*$/g,
     // copied from mbt error message
     REGEX_JAVA_VERSION: /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/,
-    REGEX_PROJECT_NAME: /[^0-9a-zA-Z_-]+/g,
 
     URLS: Object.freeze({
-        PIPELINE_HELP: 'https://sap.github.io/jenkins-library/',
+        PIPELINE_HELP: 'https://www.project-piper.io/',
         SAMPLES: 'https://github.com/SAP-samples/cloud-cap-samples',
         CAPIRE: 'https://cap.cloud.sap',
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/developing-applications/building#the-maven-archetype`,