@sap/cds-dk 4.9.5 → 6.0.1

package/lib/import/openapi/importOpenAPI.js

@@ -0,0 +1,521 @@
+const {
+    cdsName,
+    nameFromPath,
+    pathAndMethod,
+    serviceName,
+} = require("./utilities");
+
+module.exports = { importOpenAPI };
+
+// we are not interested (yet) in HEAD, OPTIONS, TRACE
+const IS_METHOD = {
+    delete: true,
+    get: true,
+    patch: true,
+    post: true,
+    put: true,
+};
+
+const STANDARD_HEADERS = [
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "authorization",
+    "content-type",
+    "if-match",
+];
+
+function importOpenAPI(input) {
+    const csn = {
+        definitions: {},
+        meta: { creator: "cds-import-openapi" },
+    };
+
+    const context = {
+        serviceName: serviceName(input.info?.title || "TODO.service"),
+        oasVersion: input.openapi || input.swagger,
+        v3: !!input.openapi,
+        schemas: input.openapi ? input.components?.schemas : input.definitions,
+        anonymous: [],
+        JSON: false,
+    };
+
+    //TODO: complain if neither swagger nor openapi3, i.e. context.oasVersion is undefined
+    const service = {
+        kind: "service",
+        "@Capabilities.BatchSupported": false,
+        "@Capabilities.KeyAsSegmentSupported": true,
+    };
+    if (input.info?.title) service["@Core.Description"] = input.info.title;
+    if (input.info?.version) service["@Core.SchemaVersion"] = input.info.version;
+    if (input.info?.description)
+        service["@Core.LongDescription"] = input.info.description;
+    csn.definitions[context.serviceName] = service;
+
+    operations(context, csn, input);
+
+    reuseTypes(context, csn);
+
+    anonymousTypes(context, csn);
+
+    return csn;
+}
+
+function reuseTypes(context, csn) {
+    for (const [name, schema] of Object.entries(context.schemas || {})) {
+        const typeName = `${context.serviceName}_types.${cdsName(name)}`;
+        csn.definitions[typeName] = cdsType(context, schema, false, true);
+        csn.definitions[typeName].kind = "type";
+        delete csn.definitions[typeName].notNull;
+    }
+}
+
+function anonymousTypes(context, csn) {
+    for (const a of context.anonymous) {
+        csn.definitions[a.name] = a.type;
+        csn.definitions[a.name].kind = "type";
+    }
+    if (context.JSON) {
+        csn.definitions["common.JSON"] = { kind: "type", type: "cds.LargeString" };
+    }
+}
+
+function operations(context, csn, input) {
+    const reuseParameters = context.v3
+        ? input.components?.parameters
+        : input.parameters;
+    const reuseResponses = context.v3
+        ? input.components?.responses
+        : input.responses;
+    for (const [path, item] of Object.entries(input.paths || {})) {
+        const globalParameters = item.parameters || [];
+        for (const [method, operation] of Object.entries(item)) {
+            if (!IS_METHOD[method]) continue;
+            const cdsOperation = {
+                kind: method === "get" ? "function" : "action",
+                params: {},
+            };
+            if (operation.tags) cdsOperation["@Common.Label"] = operation.tags[0];
+            if (operation.summary)
+                cdsOperation["@Core.Description"] = operation.summary;
+            if (operation.description)
+                cdsOperation["@Core.LongDescription"] = operation.description;
+            if (cdsOperation.kind === "action" && method !== "post")
+                cdsOperation["@openapi.method"] = method.toUpperCase();
+            cdsOperation["@openapi.path"] = path;
+
+            for (let param of globalParameters.concat(operation.parameters || [])) {
+                if (param.$ref) {
+                    // resolve reuse parameter
+                    const expectedPrefix = context.v3
+                        ? "#/components/parameters/"
+                        : "#/parameters/";
+                    if (!param.$ref.startsWith(expectedPrefix)) {
+                        throw new Error(`TODO: unexpected reference ${param.$ref} in parameter for ${method} of ${path}`);
+                    }
+                    param = reuseParameters[param.$ref.substring(expectedPrefix.length)];
+                }
+
+                if (param.in === "body") continue;
+                if (STANDARD_HEADERS.includes(param.name.toLowerCase())) continue;
+
+                const cdsParam = cdsType(
+                    context,
+                    context.v3 ? param?.schema : param,
+                    false,
+                    false,
+                    true
+                );
+                if (param.description) cdsParam["@description"] = param.description;
+                cdsParam["@openapi.in"] = param.in;
+
+                if ((param.in === "path" && param.style && param.style !== "simple") ||
+                    (param.in === "query" && param.style && param.style !== "form")
+                )
+                    cdsParam["@openapi.style"] = param.style;
+
+                if (param.explode && param.style !== "form")
+                    cdsParam["@openapi.explode"] = true;
+                
+                if (param.explode === false &&
+                    (param.style === "form" || (!param.style && param.in === "query"))
+                )
+                    cdsParam["@openapi.explode"] = false;
+
+                if (param.in === "query" && param.collectionFormat === "csv")
+                    cdsParam["@openapi.explode"] = false;
+                if (param.in === "query" && param.collectionFormat === "ssv")
+                    cdsParam["@openapi.style"] = "spaceDelimited";
+                if (param.in === "query" && param.collectionFormat === "pipes")
+                    cdsParam["@openapi.style"] = "pipeDelimited";
+                if (param.in === "query" && param.allowReserved === true)
+                    cdsParam["@openapi.allowReserved"] = true;
+                if (param.required && param.in !== "path")
+                    cdsParam["@openapi.required"] = true;
+                if (!param.required)
+                    delete cdsParam.notNull;
+
+                const name = cdsName(param.name);
+                if (name !== param.name) cdsParam["@openapi.name"] = param.name;
+                cdsOperation.params[name] = cdsParam;
+            }
+
+            const schema = requestBodySchema(context, operation);
+            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}`);
+
+            const successCode = Object.keys(operation.responses || {}).find((r) =>
+                r.startsWith("2")
+            );
+            if (successCode) {
+                let response = operation.responses[successCode];
+                if (response.$ref) {
+                    // resolve reuse response
+                    const expectedPrefix = context.v3
+                        ? "#/components/responses/"
+                        : "#/responses/";
+                    if (!response.$ref.startsWith(expectedPrefix))
+                        throw new Error(`TODO: unexpected reference ${response.$ref} in ${successCode} response for method ${method} of path ${path}`);
+                    else
+                        response =
+                            reuseResponses[response.$ref.substring(expectedPrefix.length)];
+                }
+                const responseSchema = context.v3
+                    ? response.content?.["application/json"]?.schema
+                    : response.schema;
+                if (responseSchema)
+                    cdsOperation.returns = cdsType(context, responseSchema);
+                else if (method === "get")
+                    cdsOperation.returns = { type: "cds.Boolean" };
+            } else if (method === "get")
+                cdsOperation.returns = { type: "cds.Boolean" };
+
+            const operationName = `${context.serviceName}.${nameFromPath(
+                path,
+                method
+            )}`;
+
+            if (csn.definitions[operationName]) {
+                const existing = pathAndMethod(csn.definitions[operationName]);
+                throw new Error(`Name collision: same name ${operationName} for method ${method} of path ${path} and method ${existing.method.toLowerCase()} of path ${existing.path}`);
+            }
+            csn.definitions[operationName] = cdsOperation;
+        }
+    }
+}
+
+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 cdsType(
+    context,
+    schema,
+    arrayItem = false,
+    namedType = false,
+    forParameter = false
+) {
+    let type = {};
+    let hasIncludes = false;
+
+    if (!arrayItem) if (schema.title) type["@title"] = schema.title;
+    if (schema.description) type["@description"] = schema.description;
+
+    if (schema.$ref) {
+        type.type = referencedType(context, schema.$ref).name;
+        return type;
+    }
+
+    let schemaType = normalizeSchemaType(schema);
+
+    switch (schemaType) {
+        case "array":
+            //TODO: complain if "xml"
+            {
+                const itemsType = cdsType(
+                    context,
+                    schema.items,
+                    true,
+                    false,
+                    forParameter
+                );
+                const annotations = Object.keys(itemsType).filter((k) =>
+                    k.startsWith("@")
+                );
+                // make anonymous type for item if item has annotations
+                if (annotations.length > 0) {
+                    type.items = anonymousType(context, itemsType);
+                } else {
+                    type.items = itemsType;
+                }
+            }
+            break;
+
+        case "boolean":
+            type.type = "cds.Boolean";
+            addDefault(type, schema, forParameter);
+            break;
+
+        case "file":
+            type.type = "cds.String";
+            break;
+
+        case "integer":
+            type.type = "cds.Integer";
+            if (schema.format === "int64") type.type = "cds.Integer64";
+            addDefault(type, schema, forParameter);
+            addPrimitiveExample(type, schema);
+            break;
+
+        case "number":
+            type.type = "cds.Decimal";
+            if (schema.format === "double" || schema.format === "float")
+                type.type = "cds.Double";
+            addDefault(type, schema, forParameter);
+            addPrimitiveExample(type, schema);
+            break;
+
+        case "object":
+            type.elements = {};
+            //TODO: discriminator(context, type, schema);
+            if (schema.allOf || schema.anyOf || schema.oneOf) {
+                const xOf = (schema.allOf || []).concat(
+                    schema.anyOf || [],
+                    schema.oneOf || []
+                );
+                for (const subSchema of xOf) {
+                    if (subSchema.$ref) {
+                        hasIncludes = true;
+                        const refType = referencedType(context, subSchema.$ref);
+                        if (!type.includes) type.includes = [];
+                        type.includes.push(refType.name);
+                    } else if (subSchema.type === "object" || subSchema.properties) {
+                        //TODO: what if subSchema has allOf/...? Better recurse here and "merge" the types?
+                        structElements(context, type, subSchema);
+                    } else {
+                        // should not get here
+                        throw new Error(`Error: object with non-object sub-schema`);
+                    }
+                }
+            }
+
+            structElements(context, type, schema);
+
+            if (!namedType && hasIncludes) {
+                type = anonymousType(context, type);
+            }
+
+            break;
+
+        case "string":
+            switch (schema.format) {
+                case "binary":
+                    type.type = "cds.LargeBinary";
+                    if (schema.maxLength) type.length = schema.maxLength;
+                    break;
+                case "date":
+                    type.type = "cds.Date";
+                    break;
+                case "date-time":
+                    type.type = "cds.Timestamp";
+                    break;
+                case "time":
+                    type.type = "cds.Time";
+                    break;
+                case "uuid":
+                    type.type = "cds.UUID";
+                    break;
+                default:
+                    type.type = "cds.String";
+                    if (schema.maxLength) type.length = schema.maxLength;
+            }
+            if (Array.isArray(schema.enum)) {
+                type["@assert.range"] = true;
+                type.enum = Object.fromEntries(
+                    schema.enum.map((val) => {
+                        const key = cdsName(val);
+                        return key === val ? [val, {}] : [key, { val }];
+                    })
+                );
+            }
+            addDefault(type, schema, forParameter);
+            addPrimitiveExample(type, schema);
+            break;
+
+        case undefined:
+            schemaType = bestMatchingType(context, schema);
+            if (schemaType) {
+                schema.type = schemaType;
+                type = cdsType(context, schema, arrayItem, namedType);
+                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",
+                        "@openapi.schema": jsonSchema,
+                    });
+                } else {
+                    type.type = "common.JSON";
+                    if (jsonSchema !== "{}") type["@openapi.schema"] = jsonSchema;
+                }
+            }
+            break;
+    }
+    return type;
+}
+
+function addDefault(type, schema, forParameter) {
+    if (forParameter) return;
+    if (schema.default) type.default = { val: schema.default };
+}
+
+function addPrimitiveExample(type, schema) {
+    const example = schema.examples?.[0] || schema.example;
+    if (!example || example.$ref) return;
+    type["@Core.Example.$Type"] = "Core.PrimitiveExampleValue";
+    type["@Core.Example.Value"] = example;
+}
+
+function minimalSchema(schema) {
+    const s = { ...schema };
+    delete s.title;
+    delete s.description;
+    return JSON.stringify(s);
+}
+
+function anonymousType(context, type) {
+    //TODO: construct newName from path leading here instead of using a counter
+    // pro: makes imported models more stable
+    // con: may cause name clashes
+    const newName = `${context.serviceName}.anonymous.type${context.anonymous.length}`;
+    context.anonymous.push({ name: newName, type: type });
+    return { type: newName };
+}
+
+function bestMatchingType(context, schema) {
+    if (schema.type) return schema.type;
+    let type;
+    if (schema.allOf || schema.anyOf || schema.oneOf) {
+        const xOf = (schema.allOf || []).concat(
+            schema.anyOf || [],
+            schema.oneOf || []
+        );
+        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 subType = bestMatchingType(context, refType.schema);
+                    type = betterType(type, { type: subType });
+                } else type = betterType(type, refType.schema);
+            } else {
+                //TODO: nested xOf - not yet encountered
+                type = betterType(type, subSchema);
+            }
+        }
+    }
+    return type;
+}
+
+function referencedType(context, ref) {
+    const expectedPrefix = context.v3
+        ? "#/components/schemas/"
+        : "#/definitions/";
+    if (!ref.startsWith(expectedPrefix)) {
+        throw new Error(`TODO: unexpected reference ${ref} in schema.`);
+    }
+    const schemaName = ref.substring(expectedPrefix.length);
+    const schema = context.schemas[schemaName];
+    return {
+        name: `${context.serviceName}_types.${cdsName(schemaName)}`,
+        schema,
+    };
+}
+
+function normalizeSchemaType(schema) {
+    if (!schema.type && schema.items) return "array";
+
+    if (
+        !schema.type &&
+        (schema.properties ||
+            schema.patternProperties ||
+            schema.additionalProperties ||
+            schema.discriminator)
+    )
+        return "object";
+
+    let schemaType = schema.type;
+    if (Array.isArray(schemaType)) {
+        schemaType = schemaType.sort();
+        if (schemaType.includes("null")) {
+            const index = schemaType.indexOf("null");
+            schemaType.splice(index, 1);
+        }
+        if (schemaType.length === 1) schemaType = schemaType[0];
+    }
+    return schemaType;
+}
+
+//TODO: better name :-)
+function betterType(currentType, schema) {
+    const schemaType = normalizeSchemaType(schema);
+    if (currentType === undefined) return schemaType;
+    if (currentType === schemaType) return currentType;
+    if (currentType === "string" && ["integer", "number"].includes(schemaType))
+        return "string";
+    if (["integer", "number"].includes(currentType) && schemaType === "string")
+        return "string";
+    //TODO: more cases here?
+    return null;
+}
+
+// function discriminator(context, type, schema) {
+//   if (!schema.discriminator) return;
+//   console.log("hi");
+//   const propertyName =
+//     schema.discriminator.propertyName || schema.discriminator;
+//   type["@openapi.discriminator"] = { propertyName };
+//   if (schema.discriminator.mapping) {
+//     const mapping = {};
+//     for (const [value, reference] of Object.entries(
+//       schema.discriminator.mapping
+//     )) {
+//       mapping[value] = referencedType(context, reference).name;
+//     }
+//     type["@openapi.discriminator"].mapping = mapping;
+//   }
+// }
+
+function structElements(context, type, schema) {
+    //TODO: interpret "required"
+    for (const [prop, propSchema] of Object.entries(schema.properties || {})) {
+        const name = cdsName(prop);
+        //TODO: check if property "name" already exists and has identical cdsType, warn otherwise
+        type.elements[name] = cdsType(context, propSchema);
+        if (name !== prop) type.elements[name]["@openapi.name"] = prop;
+    }
+}

package/lib/import/openapi/index.js

@@ -0,0 +1,19 @@
+"use strict"
+
+const { importOpenAPI } = require("./importOpenAPI");
+let messages = require("../message").getMessages();
+
+function openAPI2csn(source) {
+    let csn = {};
+    try {
+        const fileContentToJSON = JSON.parse(source);
+        csn = importOpenAPI(fileContentToJSON);
+    } catch (e) {
+        throw new Error(messages.INVALID_OPENAPI_FILE);
+    }
+    return csn;
+}
+
+module.exports = {
+    openAPI2csn
+}

package/lib/import/openapi/utilities.js

@@ -0,0 +1,38 @@
+module.exports = { cdsName, nameFromPath, pathAndMethod, serviceName };
+
+function cdsName(oasName) {
+  if (oasName === "") return "_";
+  let name = oasName;
+  if (name.match(/^(\p{Nd}|\p{Mn}|\p{Mc}|\p{Pc}|\p{Cf})/u)) name = "_" + name;
+  return name.replace(/[^_\p{L}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]/gu, "_");
+  //TODO: shorten if longer than 128 characters
+}
+
+function nameFromPath(path, method) {
+  let cleanPath = path
+    .substring(1)
+    .replace(/\/$/, "")
+    .replace(/{[^}]+}/g, ".")
+    .replace(/\/\./g, "_")
+    .replace(/[^_\p{L}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]/gu, "_");
+  if (cleanPath === "") cleanPath = "_";
+  //TODO: shorten if longer than 128 characters
+  return method === "get" ? cleanPath : `${cleanPath}_${method}`;
+}
+
+function pathAndMethod(operation) {
+  const path = operation["@openapi.path"];
+  const method =
+    operation.kind === "function"
+      ? "GET"
+      : operation["@openapi.method"] || "POST";
+  return { path, method };
+}
+
+function serviceName(title) {
+  return title
+    .trim()
+    .replace(/(\s|-)+/g, ".")
+    .replace(/[^._\p{L}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]/gu, "_");
+  //TODO: shorten if longer than 511-129=382 characters
+}

package/lib/index.js

@@ -1,4 +1,4 @@
-const cds = require ('@sap/cds')
+const cds = require('./cds')
 const compile_desc = Reflect.getOwnPropertyDescriptor(cds,'compile')
 
 // extending cds to lazy-load additional submodules provided by cds-dk

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.24.0';
+const MAVEN_ARCHETYPE_VERSION = '1.25.0';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -22,12 +22,15 @@ const constants = {
     OPTION_CF_MANIFEST: 'cf-manifest',
     OPTION_PIPELINE: 'pipeline',
     OPTION_SAMPLES: 'samples',
+    OPTION_DATA: 'data',
     OPTION_NOTEBOOK: 'notebook',
     OPTION_LINT: 'lint',
     OPTION_LINT_GLOBAL: 'lint:global',
     OPTION_LINT_DEV: 'lint:dev',
     OPTION_JAVA_PACKAGE: 'java:package',
     OPTION_JAVA_MVN: 'java:mvn',
+    OPTION_HELM: 'helm',
+    OPTION_HELM_UPDATE: 'helm/update',
 
     // node enum
     PROJECT_TYPE: Object.freeze({ nodejs: 1, java: 2, unknown: 3 }),
@@ -71,11 +74,13 @@ constants.OPTIONS_PRIORITY = [
     constants.OPTION_AUDITLOG,
     constants.OPTION_APPROUTER,
     constants.OPTION_SAMPLES,
+    constants.OPTION_DATA,
     constants.OPTION_KIBANA_LOGGING,
     constants.OPTION_NOTEBOOK,
     constants.OPTION_LINT,
     constants.OPTION_LINT_CUSTOM,
-    constants.OPTION_LINT_EXAMPLE
+    constants.OPTION_LINT_EXAMPLE,
+    constants.OPTION_HELM
 ];
 
 module.exports = constants;

package/lib/init/index.js

@@ -8,7 +8,7 @@ const Spinner = require('./util/spinner');
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
     // eslint-disable-next-line no-unused-vars
     OPTION_XSUAA, OPTION_AUDITLOG, OPTION_HANA, OPTION_MTA, OPTION_MTX, OPTION_APPROUTER, OPTION_KIBANA_LOGGING,
-    OPTION_NODEJS, OPTION_JAVA,
+    OPTION_NODEJS, OPTION_JAVA, OPTION_HELM,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');
 
 module.exports = class CDSGenerator {
@@ -86,6 +86,9 @@ module.exports = class CDSGenerator {
                 guiOptions: {
                     hint: 'Speed up your ramp-up phase with some sample files in your project.'
                 }
+            },
+            {
+                // OPTION_HELM this.config
             }
         ]
 
@@ -106,7 +109,9 @@ module.exports = class CDSGenerator {
                     OPTION_CF_MANIFEST,
                     OPTION_MTA,
                     OPTION_SAMPLES,
-                    OPTION_KIBANA_LOGGING
+                    OPTION_KIBANA_LOGGING,
+                    OPTION_HELM,
+                    OPTION_SAMPLES
                 ],
                 multiple: true,
                 promptOrder: 10 // used to identify ui prompts
@@ -209,7 +214,9 @@ module.exports = class CDSGenerator {
 
         for (const template of this.templateList) {
             const msg = `Adding feature '${template.name}'...`;
-            if (this.logger.isDebug) {
+            if (template.dontAnnounce) {
+                await template.run();
+            } else if (this.logger.isDebug) {
                 this.logger.log(msg);
                 await template.run();
             } else {