@sap/cds-dk 7.9.5 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-dk",
-  "version": "7.9.5",
+  "version": "8.0.2",
   "description": "Command line client and development toolkit for the SAP Cloud Application Programming Model",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -16,29 +16,34 @@
   },
   "main": "lib/index.js",
   "dependencies": {
-    "@sap/cds": "^7",
+    "@cap-js/asyncapi": "^1.0.0",
+    "@cap-js/openapi": "^1.0.0",
+    "@sap/cds": ">=7",
     "@sap/cds-foss": "^5.0.0",
-    "@sap/cds-mtxs": "^1.9.0",
+    "@sap/cds-mtxs": ">=1.9.0",
     "@sap/eslint-plugin-cds": "^3.0.1",
-    "@sap/hdi-deploy": "^4.8.0",
+    "@sap/hdi-deploy": "^5",
     "axios": "^1",
-    "eslint": "^8",
+    "eslint": "^9",
     "express": "^4.17.3",
+    "hdb": "^0",
     "livereload-js": "^4.0.1",
     "mustache": "^4.0.1",
     "node-watch": ">=0.7",
-    "pluralize": "^8.0.0",
     "ws": "^8.4.2",
     "xml-js": "^1.6.11"
   },
   "optionalDependencies": {
-    "sqlite3": "^5.0.4"
+    "@cap-js/sqlite": "^1"
   },
   "files": [
     "bin/",
     "lib/",
+    "CHANGELOG.md",
+    "LICENSE",
     "npm-shrinkwrap.json",
-    "LICENSE"
+    "package.json",
+    "readme.md"
   ],
   "_hasShrinkwrap": true
 }

package/bin/activate.js

@@ -1,77 +0,0 @@
-module.exports = Object.assign(activate, {
-    options: ['--subdomain', '--passcode', '--username', '--clientid', '--to', '--sync'],
-    flags: ['--undeploy', '--wsdl'],
-    shortcuts: ['-s', '-p', '-u', '-c', '-2'],
-    help: `
-# SYNOPSIS
-
-    *cds activate* [ <extension-project-directory> ]
-
-    **Deprecated - for use with previous MTX Services (@sap/cds-mtx).**
-
-    Activate an extension project.
-    By default, the current working directory is used as project directory.
-
-    To facilitate running this multiple times against the same app, refer to the
-    *cds login* command.
-
-
-# OPTIONS
-
-    *--to* <url>
-
-        Specify the URL of the extensible SaaS app. By default, it's determined
-        from project settings.
-
-    *-s* | *--subdomain* <tenant-subdomain>
-
-        Specify your tenant's subdomain. By default, it's determined from
-        project settings.
-
-    *-p* | *--passcode* <passcode>
-
-        Tenant-specific passcode for authentication.
-        Also see cds login --help or https://cap.cloud.sap/docs/guides/extensibility/#save-an-authentication-token-for-a-simplified-workflow
-
-    *-u* | *--username* <name>
-
-        Deprecated. Use the passcode parameter.
-
-    *-c* | *--clientid* <clientid>
-
-        Client ID for authentication. This will override the default Client ID
-        from environment.
-
-    *--undeploy*
-
-        Undeploy a previously deployed extension, e.g. to remove a renamed or
-        otherwise obsolete extension.
-
-    *--sync*
-
-        Use the synchronous server API to upload extensions.
-
-# SEE ALSO
-
-    *cds push* to push an extension to a SaaS app based on current MTX Services
-    (@sap/cds-mtxs).
-
-    https://cap.cloud.sap/docs/guides/multitenancy/mtxs for information on
-    @sap/cds-mtxs.
-
-`})
-
-
-async function activate ([projectFolder], options = {}) {
-    const injection = {
-        cds: require('../lib/cds')
-    }
-
-    Object.assign(options, { projectFolder })
-
-    await require('../lib/mtx/activate').run(injection, options);
-}
-
-
-
-/* eslint no-console: off */

package/lib/compile/asyncapi/channels.js

@@ -1,22 +0,0 @@
-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

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1,173 +0,0 @@
-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 nestedAnnotation(resObj, asyncapiProperty, keys, value) {
-    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;
-}
-
-function readAnnotations(definition, presets) {
-    let resObj = {};
-
-    for (const [key, value] of Object.entries(definition)) {
-        if (key.startsWith('@AsyncAPI') && !key.startsWith('@AsyncAPI.Extensions')) {
-            // 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 {
-                nestedAnnotation(resObj, asyncapiProperty, keys, value)
-            }
-        }
-
-        else if (key.startsWith('@AsyncAPI.Extensions')) {
-            const annotationProperties = key.split('@AsyncAPI.Extensions.')[1];
-            const keys = annotationProperties.split('.');
-            keys[0] = "x-" + keys[0];
-
-            if (keys.length === 1) {
-                // if the key is already present, that means, Annotations have already been considered
-                if (resObj[keys[0]]) continue;
-                // else we populate
-                resObj[keys[0]] = value;
-            } else {
-                nestedAnnotation(resObj, keys[0], keys, 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
- */
-function definitionsToMessages(definitions, events, presets) {
-    const messages = {};
-    Object.assign(messages, entriesToMessages(definitions, events, presets));
-    return messages;
-}
-
-module.exports = {
-    definitionsToMessages,
-    nestedAnnotation
-}

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

@@ -1,33 +0,0 @@
-
-const odmAnnotationsMapping = Object.freeze({
-    '@ODM.entityName': 'x-sap-odm-entity-name',
-    '@ODM.oid': 'x-sap-odm-oid'
-});
-
-function addOdmExtensions(definition, object) {
-    for (const [annotation, asyncApiExtension] of Object.entries(odmAnnotationsMapping)) {
-        if (definition[annotation]) {
-            object[asyncApiExtension] = definition[annotation];
-        }
-    }
-}
-
-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, ' ');
-    }
-
-    if (definition['@ODM.root']) {
-        object['x-sap-root-entity'] = definition['@ODM.root']
-    }
-
-    addOdmExtensions(definition, object);
-
-    return object;
-}

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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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