@sap/cds-dk 6.5.2 → 6.6.1

package/lib/compile/asyncapi/channels.js

@@ -0,0 +1,22 @@
+const { getEventName } = require('./utils');
+
+function getChannel(eventName) {
+    return {
+        subscribe: {
+            message: {
+                $ref: "#/components/messages/" + eventName
+            }
+        }
+    }
+}
+
+module.exports = function getChannels(definitions, events) {
+    let channels = {};
+
+    events.forEach(event => {
+        let eventName = getEventName(event, definitions[event]);
+        channels[eventName] = getChannel(eventName);
+    });
+
+    return channels;
+}

package/lib/compile/asyncapi/components/messageTraits/index.js

@@ -0,0 +1,89 @@
+/**
+ * Get a map of message traits.
+ */
+module.exports = function getMessageTraits() {
+
+    return {
+        "CloudEventsContext.v1": {
+            "headers": {
+                "type": "object",
+                "properties": {
+                    "id": {
+                        "description": "Identifies the event.",
+                        "type": "string",
+                        "examples": [
+                            "6925d08e-bc19-4ad7-902e-bd29721cc69b"
+                        ]
+                    },
+                    "specversion": {
+                        "description": "The version of the CloudEvents specification which the event uses.",
+                        "type": "string",
+                        "const": "1.0"
+                    },
+                    "source": {
+                        "description": "Identifies the instance the event originated in.",
+                        "type": "string",
+                        "format": "uri-reference",
+                        "examples": [
+                            "/default/sap.s4.beh/ER9CLNT001",
+                            "/eu/sap.billing.sb/91dec60d-9757-4e2c-b9e5-21da10016fe9"
+                        ]
+                    },
+                    "type": {
+                        "description": "Describes the type of the event related to the source the event originated in.",
+                        "type": "string",
+                        "examples": [
+                            "sap.dsc.FreightOrder.Arrived.v1",
+                            "sap.billing.sb.Subscription.Canceled.v1"
+                        ]
+                    },
+                    "subject": {
+                        "description": "Describes the subject of the event in the context of the source the event originated in (e.g., the id of the business object the event is about).",
+                        "type": "string",
+                        "examples": [
+                            "ce307052-75a0-4a8f-a961-ebf21669bb80",
+                            "urn:epc:tag:sgtin-96:1.7332402.026591.1234567890"
+                        ]
+                    },
+                    "datacontenttype": {
+                        "description": "Content type of the event data.",
+                        "type": "string",
+                        "const": "application/json"
+                    },
+                    "dataschema": {
+                        "description": "Identifies the schema that the event data adheres to.",
+                        "type": "string",
+                        "format": "uri",
+                        "examples": [
+                            "http://example.com/event/sap.billing.sb.Subscription.Canceled/v1.2.0"
+                        ]
+                    },
+                    "time": {
+                        "description": "Timestamp of when the occurrence happened.",
+                        "format": "date-time",
+                        "type": "string",
+                        "examples": [
+                            "2018-04-05T17:31:00Z"
+                        ]
+                    }
+                },
+                "required": [
+                    "id",
+                    "source",
+                    "specversion",
+                    "type"
+                ],
+                "patternProperties": {
+                    "^xsap[a-z0-9]+$": {
+                        "description": "Application defined custom extension context attributes.",
+                        "type": [
+                            "boolean",
+                            "integer",
+                            "string"
+                        ]
+                    }
+                }
+            }
+        }
+    };
+}

package/lib/compile/asyncapi/components/messages/index.js

@@ -0,0 +1,150 @@
+const { getEventName } = require('../../utils');
+
+const annotationMapping = {
+    'EventSpecVersion': 'x-sap-event-spec-version',
+    'EventSource': 'x-sap-event-source',
+    'EventSourceParams': 'x-sap-event-source-parameters',
+    'EventCharacteristics': 'x-sap-event-characteristics',
+    'EventStateInfo': 'x-sap-stateInfo',
+    'EventSchemaVersion': 'x-sap-event-version'
+};
+
+/**
+ * Get header properties from definition.
+ */
+function getHeaderProperties(name) {
+    return { type: { const: name } };
+}
+
+function readAnnotations(definition, presets) {
+    let resObj = {};
+
+    for (const [key, value] of Object.entries(definition)) {
+        if (key.startsWith('@AsyncAPI')) {
+            // get annotation value after @AsyncAPI
+            const annotationProperties = key.split('@AsyncAPI.')[1];
+            const keys = annotationProperties.split('.');
+
+            // convert annotation property (ex: EventSource) to asyncapi property (ex: x-sap-event-source)
+            // if annotation property isn't present in map then ignore the property
+            if (annotationMapping[keys[0]] === undefined) continue;
+
+            const asyncapiProperty = annotationMapping[keys[0]];
+
+            // if there's no nesting then just set the value
+            if (keys.length === 1) {
+                resObj[asyncapiProperty] = value;
+            } else {
+                if (resObj[asyncapiProperty] === undefined) {
+                    resObj[asyncapiProperty] = {};
+                }
+
+                let node = resObj[asyncapiProperty];
+
+                // traverse the annotation property and define the objects if they're not defined
+                for (let nestedIndex = 1; nestedIndex < keys.length-1; nestedIndex++) {
+                    const nestedElement = keys[nestedIndex];
+                    if (node[nestedElement] === undefined) {
+                        node[nestedElement] = {};
+                    }
+                    node = node[nestedElement];
+                }
+
+                // set value annotation property
+                node[keys[keys.length-1]] = value;
+            }
+        }
+    }
+
+    for (const [key, value] of Object.entries(presets)) {
+        if (resObj[key] === undefined) {
+            resObj[key] = value;
+        }
+    }
+
+    addDefaults(resObj);
+    return resObj;
+}
+
+function addDefaults(obj) {
+    const defaults = {
+        'x-sap-event-source': '/{region}/{applicationNamespace}/{instanceId}',
+        'x-sap-event-source-parameters': {
+            "region": {
+                "description": "The regional context of the application.",
+                "schema": {
+                    "type": "string"
+                }
+            },
+            "applicationNamespace": {
+                "description": "The registered namespace of the application.",
+                "schema": {
+                    "type": "string"
+                }
+            },
+            "instanceId": {
+                "description": "The instance id (tenant, installation, ...) of the application.",
+                "schema": {
+                    "type": "string"
+                }
+            }
+        }
+    }
+
+    for (const [key, value] of Object.entries(defaults)) {
+        if (!obj[key]) {
+            obj[key] = value;
+        }
+    }
+}
+
+/**
+ * Get message for the event definition.
+ */
+function eventToMessage(definition, name, presets) {
+    let obj = readAnnotations(definition, presets);
+
+    let messageObj = {
+        name,
+        headers: {
+            type: 'object',
+            properties: getHeaderProperties(name)
+        },
+        payload: {
+            $ref: `#/components/schemas/${name}`
+        },
+        traits: [
+            {
+                $ref: '#/components/messageTraits/CloudEventsContext.v1'
+            }
+        ]
+    }
+
+    const message = { ...obj, ...messageObj};
+
+    return message;
+}
+
+/**
+ * Event definitions of one CSN to messages.
+ */
+function entriesToMessages(definitions, events, presets) {
+    const messages = {};
+
+    events.forEach(event => {
+        let name = getEventName(event, definitions[event]);
+        messages[name] = eventToMessage(definitions[event], name, presets);
+    });
+
+    return messages;
+}
+
+/**
+ * Combining the definition objects from CSN into one schema
+ */
+module.exports = function definitionsToMessages(definitions, events, presets) {
+    const messages = {};
+
+    Object.assign(messages, entriesToMessages(definitions, events, presets));
+    return messages;
+}

package/lib/compile/asyncapi/components/schemas/annotations.js

@@ -0,0 +1,13 @@
+module.exports = function addAnnotations(definition, object) {
+    if (typeof (definition['@title']) === 'string') {
+        object.title = definition['@title'];
+    }
+
+    if (typeof (definition['@description']) === 'string') {
+        object.description = definition['@description'];
+    } else if (typeof definition.doc === 'string') {
+        object.description = definition.doc.replace(/\n/g, ' ');
+    }
+
+    return object;
+}

package/lib/compile/asyncapi/components/schemas/array.js

@@ -0,0 +1,8 @@
+const { getBaseTypeStructure } = require('./utils');
+
+module.exports = function getArrayOfType(type) {
+    const array = getBaseTypeStructure('array');
+    array.items = type;
+
+    return array;
+}

package/lib/compile/asyncapi/components/schemas/cache.js

@@ -0,0 +1,14 @@
+function cacheAndReturn(schemaCache, type, schema) {
+    schemaCache[type] = schema;
+
+    return schema;
+}
+
+function getCache(schemaCache, type) {
+    return schemaCache[type];
+}
+
+module.exports = {
+    cacheAndReturn,
+    getCache
+}

package/lib/compile/asyncapi/components/schemas/definition.js

@@ -0,0 +1,187 @@
+const { addEnum } = require('./enum');
+const schemaUtils = require('./utils');
+const { cacheAndReturn, getCache } = require('./cache');
+const { getOwnValue } = require('../../utils');
+const { toLocalizedArray } = require('./localized');
+const addAnnotations = require('./annotations');
+const primitiveElementToSchema = require('./primitiveElement');
+const getArrayOfType= require('./array');
+const { followRefRecursive } = require('./ref');
+
+function definitionToSchema(eventDefinition, definitions, schemaCache) {
+  const definition = definitions[eventDefinition];
+
+  if (schemaUtils.isStructured(definition)) {
+    return addAnnotations(definition, elementsToSchema(schemaCache, definitions, definition));
+  }
+
+  return addAnnotations(definition, elementToSchema(schemaCache, definitions, definition));
+}
+
+function elementsToSchema(schemaCache, definitions, entry, nullable) {
+  if (!schemaUtils.isStructured(entry)) {
+    return elementToSchema(schemaCache, definitions, entry, nullable);
+  }
+
+  const required = [];
+  const object = schemaUtils.getBaseTypeStructure("object");
+  for (const [name, element] of Object.entries(entry.elements)) {
+    if (getOwnValue(element, "key")
+        || getOwnValue(element, "@mandatory")
+        || (getOwnValue(element, "@Common.FieldControl") && getOwnValue(element["@Common.FieldControl"], "#") === 'Mandatory')
+    ) {
+      required.push(name);
+    }
+
+    if (!schemaUtils.elementIsRelevant(name, element)) {
+      continue;
+    }
+
+    if (!object.properties) {
+      object.properties = {};
+    }
+
+    object.properties[name] = addAnnotations(element, elementToSchema(schemaCache, definitions, element));
+  }
+
+  if (required.length) {
+    object.required = required;
+  }
+
+  return object;
+}
+
+function elementToSchema(schemaCache, definitions, entry) {
+  /*
+   * Process reuse types as first step.
+   * A structured type will be preprocessed and 'elements' will exists as inherited prototype.
+   * If type is processed first, the reuse will be cached.
+   * If the inherited elements would be processed instead, each reuse would process them again.
+   */
+  if (typeof entry.type === "string" && definitions[entry.type]) {
+    //  has been processed before
+    if (schemaCache[entry.type]) {
+      return getCache(schemaCache, entry.type);
+    }
+
+    return cacheAndReturn(schemaCache, entry.type,
+      elementToSchema(schemaCache, definitions, definitions[entry.type])
+    );
+  }
+
+  // Process anonymous attribute object structures like "deep: {deeper: {attr: String;};};"
+  if (schemaUtils.isStructured(entry)) {
+    return elementsToSchema(schemaCache, definitions, entry);
+  }
+
+  // Arrayed primitives and structured objects without keyed property
+  if (schemaUtils.isManyEntry(entry)) {
+    return manyToSchema(schemaCache, definitions, entry);
+  }
+
+  // Definition > element references
+  if (schemaUtils.isRefEntry(entry)) {
+    return refToSchema(schemaCache, definitions, entry);
+  }
+
+  // Associations to (root) entities and code lists
+  if (schemaUtils.isAssociation(entry)) {
+    return associationToSchema(schemaCache, definitions, entry);
+  }
+
+  // Compositions of aspect or entity
+  if (schemaUtils.isComposition(entry)) {
+    return compositionToSchema(schemaCache, definitions, entry);
+  }
+
+  //A localized element is a primitive at CSN and an array of objects at JSON schema (all translations)
+  if (entry.localized === true) {
+    return toLocalizedArray(entry);
+  }
+
+  const schema = addAnnotations(entry, primitiveElementToSchema(entry));
+
+  if (schemaUtils.isDefault(entry)) {
+    schemaUtils.addDefaultValue(entry, schema);
+  }
+
+  if (schemaUtils.isEnum(entry)) {
+    addEnum(entry, schema);
+  }
+
+  return schema;
+}
+
+function associationToSchema(schemaCache, definitions, entry) {
+  let associationTargetDefinition = JSON.parse(JSON.stringify(definitions[entry.target]));
+  Object.keys(associationTargetDefinition.elements).forEach(element => {
+    if (associationTargetDefinition.elements[element].key === undefined) {
+      delete associationTargetDefinition.elements[element];
+    }
+  });
+
+  if (schemaUtils.isToManyAssociation(entry)) {
+    return getArrayOfType(elementsToSchema(schemaCache, definitions, associationTargetDefinition));
+  } else {
+    return elementsToSchema(schemaCache, definitions, associationTargetDefinition);
+  }
+}
+
+function manyToSchema(schemaCache, definitions, entry) {
+  return getArrayOfType(
+    schemaUtils.isStructured(entry.items)
+      ? elementsToSchema(schemaCache, definitions, entry.items)
+      : elementToSchema(schemaCache, definitions,
+          // if entry.items.type can be found at definitions, it is a reuse type
+          definitions[entry.items.type] ? definitions[entry.items.type] : (entry.items)
+        )
+  );
+}
+
+function compositionToSchema(schemaCache, definitions, entry) {
+  if (schemaUtils.isStructured(entry.targetAspect)) {
+    const objectType = elementsToSchema(schemaCache, definitions, entry.targetAspect);
+    return schemaUtils.isToMany(entry) ? getArrayOfType(objectType) : objectType;
+  }
+  // Composition of aspects might have a target towards a generated entity
+  const target = entry.targetAspect || entry.target;
+  // An aspect is a reuse element, which might be used at more than one place with different cardinality
+  const cacheKey = `${target}${schemaUtils.isToMany(entry) ? 'Many' : 'One'}`;
+
+  /*
+   * Check if the target entity has been processed as association target before.
+   */
+  if (schemaCache[cacheKey]) {
+    return getCache(schemaCache, cacheKey);
+  }
+
+  let objectType;
+  if (schemaUtils.isStructured(definitions[target])) {
+    objectType = elementsToSchema(schemaCache, definitions, definitions[target]);
+  } else {
+    objectType = elementToSchema(schemaCache, definitions, target);
+  }
+
+  return cacheAndReturn(schemaCache, cacheKey,
+    schemaUtils.isToMany(entry) ? getArrayOfType(objectType) : objectType
+  );
+}
+
+function refToSchema(schemaCache, definitions, entry) {
+  const refKey = entry.type.ref.join('.');
+
+  if (schemaCache[refKey]) {
+    return getCache(schemaCache, refKey);
+  }
+
+  return cacheAndReturn(
+    schemaCache,
+    refKey,
+    elementToSchema(schemaCache, definitions, followRefRecursive(definitions, entry.type))
+  );
+}
+
+module.exports = {
+  definitionToSchema,
+  elementToSchema
+}

package/lib/compile/asyncapi/components/schemas/enum.js

@@ -0,0 +1,16 @@
+const schemaUtils = require('./utils');
+
+function addEnum(entry, schema) {
+    if (entry.kind === 'type') {
+        // eslint-disable-next-line no-unused-vars
+        schema.enum = Object.entries(entry.enum).map(([key, value]) => {
+            return (schemaUtils.isVal(entry) ? entry.val : key)
+        });
+    } else {
+        schema.enum = Object.keys(entry.enum);
+    }
+}
+
+module.exports = {
+    addEnum
+}

package/lib/compile/asyncapi/components/schemas/examples.js

@@ -0,0 +1,10 @@
+const Examples = {
+    UUID_EXAMPLE: 'e78f1eb8-ada8-49b0-8c8f-a5d316e82952',
+    PARTIAL_TIME_EXAMPLE:'20:54:21',
+    DATE_EXAMPLE: '2017-02-14',
+    DATE_TIME_EXAMPLE: '2017-02-14T20:54:21+00:00',
+    INT_64_EXAMPLE: '3155378975999999999',
+    DECIMAL_EXAMPLE: '3.141592653589793238462643383279',
+}
+
+module.exports = Examples

package/lib/compile/asyncapi/components/schemas/index.js

@@ -0,0 +1,14 @@
+const { definitionToSchema } = require('./definition');
+const { getEventName } = require('../../utils');
+
+module.exports = function csnToJSONSchema(definitions, events) {
+    let schemaCache = {};
+    let schema = {};
+
+    events.forEach(event => {
+        const eventName = getEventName(event, definitions[event]);
+        schema[eventName] = definitionToSchema(event, definitions, schemaCache);
+    });
+
+    return schema;
+}

package/lib/compile/asyncapi/components/schemas/localized.js

@@ -0,0 +1,29 @@
+const primitiveElementToSchema = require('./primitiveElement');
+const { getBaseTypeStructure } = require('./utils');
+
+function getPatternStructure(pattern, example) {
+    var schema = getBaseTypeStructure('string');
+    schema.pattern = pattern;
+    if (example) {
+        schema.examples = [example];
+    }
+    return schema;
+}
+
+function toLocalizedArray(localizedElement) {
+    return {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                lang: getPatternStructure('^[a-z]{2}(?:-[A-z]{2})?$'),
+                content: primitiveElementToSchema(localizedElement)
+            },
+            required: ['lang', 'content']
+        }
+    }
+}
+
+module.exports = {
+    toLocalizedArray
+}

package/lib/compile/asyncapi/components/schemas/primitiveElement.js

@@ -0,0 +1,41 @@
+const Examples = require('./examples');
+const { getBaseTypeStructure, getFormatStructure, toString } = require('./utils');
+
+module.exports = function primitiveElementToSchema(entry) {
+    switch(entry.type) {
+        case 'cds.Boolean':
+            return getBaseTypeStructure("boolean");
+        case 'cds.Integer':
+            return getBaseTypeStructure("integer");
+        case 'cds.Double':
+            return getBaseTypeStructure("number");
+        case 'cds.UUID':
+            return getFormatStructure("uuid", Examples.UUID_EXAMPLE);
+        case 'cds.Integer64':
+            return getFormatStructure("int64", Examples.INT_64_EXAMPLE);
+        case 'cds.Decimal': {
+            let schema = getFormatStructure("decimal", Examples.DECIMAL_EXAMPLE);
+            if (entry.precision) {
+                schema['x-sap-precision'] = entry.precision;
+            }
+            if (entry.scale) {
+                schema['x-sap-scale'] = entry.scale;
+            }
+            return schema;
+        }
+        case 'cds.Date':
+            return getFormatStructure("date", Examples.DATE_EXAMPLE);
+        case 'cds.Time':
+            return getFormatStructure("partial-time", Examples.PARTIAL_TIME_EXAMPLE);
+        case 'cds.DateTime':
+        case 'cds.Timestamp':
+            return getFormatStructure("date-time", Examples.DATE_TIME_EXAMPLE);
+        case 'cds.String':
+        case 'cds.LargeString':
+        case 'cds.Binary':
+        case 'cds.LargeBinary':
+            return toString(entry);
+        default:
+            throw new Error(`Unsupported type ${entry.type}`);
+    }
+}

package/lib/compile/asyncapi/components/schemas/ref.js

@@ -0,0 +1,45 @@
+const { isElements, isRefEntry } = require('./utils');
+
+function followRefRecursive(definitions, ref) {
+  const element = followRef(definitions, ref);
+
+  if (isRefEntry(element)) {
+    return followRefRecursive(definitions, element.type);
+  }
+
+  return element;
+}
+
+function followRef(definitions, { ref }) {
+  const definition = definitions[ref[0]];
+
+  if (!definition) {
+    throw new Error(`Cannot find definition '${ref[0]}'`);
+  }
+
+  if (!isElements(definition.elements)) {
+    throw new Error(`'${ref[0]}' is not a structured type`);
+  }
+
+  let pointer = definition.elements;
+  let element;
+
+  // Navigate down to the last elements section
+  for (let elementIndex = 1; elementIndex < ref.length; elementIndex++) {
+    element = pointer[ref[elementIndex]];
+
+    if (element && isElements(element.elements)) {
+      pointer = element.elements;
+    }
+  }
+
+  if (!element) {
+    throw new Error(`Cannot resolve reference '${ref.join(':')}'`);
+  }
+
+  return element;
+}
+
+module.exports = {
+  followRefRecursive
+}