@sap/cds-dk 10.0.7 → 10.1.1

package/bin/completion/scripts/cds-zsh.sh

@@ -1,13 +0,0 @@
-#!/bin/zsh
-
-# compinit is required but added to ~/.zshrc so user can remove it if it is already loaded
-# autoload -Uz compinit && compinit
-
-CDS_COMMAND="cds"
-
-_completeCds() {
-    # double quoting needed to avoid word 'h' to be recognized as command shortcut 'help'
-    compadd -S '' -V 'force no sort' -- `${CDS_COMMAND} completion --shell zsh --prev "'${words[CURRENT-1]}'" --curr "'${words[CURRENT]}'" --line "'${words}'"`
-}
-
-compdef _completeCds ${CDS_COMMAND}

package/lib/deploy/index.js

@@ -1,25 +0,0 @@
-module.exports = {
-    options:  /** @type{const} */([
-        '--to',
-        '--for',
-        '--out',
-        '--on',
-        '--tunnel-address',
-        '--vcap-file',
-        '--delta-from'
-    ]),
-    flags:  /** @type{const} */([
-        '--resolve-bindings',
-        '--no-save',
-        '--auto-undeploy',
-        '--dry',
-        '--xdry',
-        '--with-mocks',
-        '--store-credentials',
-        '--no-build',
-        '--model-only',
-        '--script',
-        '--with-auto-schema-evolution'
-    ]),
-    shortcuts: ['-2', '-4', '-o', '-n', '', '', '', '-b']
-}

package/lib/import/asyncapi/importAsyncAPI.js

@@ -1,33 +0,0 @@
-const ParserContext = require("./parserContext");
-const cdsDkVersion = require("../../../package.json").version;
-
-function importAsyncAPI(input) {
-     const context = new ParserContext(input);
-     return convertToCSN(context);
-}
-
-function convertToCSN(context) {
-     const csn = {
-          meta: {
-               creator: `cds-dk ${cdsDkVersion}`
-          },
-          $version: '2.0',
-          definitions: {}
-     };
-
-     Object.entries(context.services).forEach(([key, value]) => {
-          const events = value.events;
-          const types = value.types;
-          delete value.events;
-          delete value.types;
-
-          csn.definitions[key] = value;
-          Object.assign(csn.definitions, events, types);
-     });
-
-     return csn;
-}
-
-module.exports = {
-     importAsyncAPI
-}

package/lib/import/asyncapi/index.js

@@ -1,18 +0,0 @@
-const { importAsyncAPI } = require("./importAsyncAPI");
-const { validateAsyncAPI } = require('./utils');
-
-/**
- * The starting function for conversion of AsyncAPI document to csn
- * @returns AsyncAPI document
- */ 
-function asyncapi2csn(source) {
-    // validate asyncapi document
-    const content = JSON.parse(source);
-    validateAsyncAPI(content);
-
-    return importAsyncAPI(content);
-}
-
-module.exports = {
-    asyncapi2csn
-}

package/lib/import/asyncapi/parserContext.js

@@ -1,454 +0,0 @@
-const { getRegExpGroups } = require('./utils');
-const messages = require("../message").getMessages();
-
-/**
- * @typedef {{ type?: string|string[], format?: string, properties?: Record<string, AsyncApiSchema>, items?: AsyncApiSchema, allOf?: AsyncApiSchema[], '$ref'?: string, required?: string[], additionalProperties?: boolean|AsyncApiSchema, enum?: Array<*>, default?: *, nullable?: boolean, [key: string]: * }} AsyncApiSchema
- * @typedef {{ components: { messages: Record<string, AsyncApiMessage>, schemas: Record<string, AsyncApiSchema> }, info?: object, [key: string]: * }} AsyncApiDocument
- * @typedef {{ name: string, payload?: AsyncApiSchema, [key: string]: * }} AsyncApiMessage
- * @typedef {{ type?: string|{'ref':string[]}, kind?: string, elements?: Record<string, CsnElement>, items?: CsnElement, '@cds.external'?: string, '@mandatory'?: boolean, precision?: number, scale?: number, default?: *, enum?: object, [key: string]: * }} CsnElement
- * @typedef {Record<string, *>} Annotations
- * @typedef {Record<string, CsnElement | null>} CsnTypeMap
- */
-
-module.exports = class ParserContext {
-    /**
-     * @param {AsyncApiDocument} content
-     */
-    constructor(content) {
-        this.services = this.getServicesFromContent(content);
-    }
-
-    /**
-     * @param {string} eventName
-     */
-    getTopicName(eventName) {
-        return eventName.startsWith('ce/') ? eventName.substring(3) : eventName;
-    }
-
-    /**
-     * @param {string} messageRefString
-     */
-    getEventName(messageRefString) {
-        const lastSlashIndex = messageRefString.lastIndexOf('/');
-        return lastSlashIndex == -1 ? '' : messageRefString.substring(lastSlashIndex + 1);
-    }
-
-    /**
-     * Returns services from the asyncapi json object along with the events and annotations.
-     * @param {AsyncApiDocument} content - root AsyncAPI document
-     */
-    getServicesFromContent(content) {
-        /** @type {Record<string, *>} */
-        const services = {};
-        const serviceAnnotations = this.getServiceAnnotations(content);
-
-        Object.entries(content.components.messages).forEach(([, value]) => {
-            let eventName;
-            // Message name should be used to capture the event name
-            if (value.name) {
-                eventName = value.name;
-            } else {
-                throw new Error(messages.INVALID_ASYNCAPI_FILE);
-            }
-            // uses regex to break event name in different components
-            const regExpGroups = getRegExpGroups(eventName);
-            const service = regExpGroups[1] + "." + regExpGroups[2];
-            const event = regExpGroups[0];
-
-            // add service to services entry if not present
-            if (!(service in services)) {
-                services[service] = { 'kind': 'service', '@cds.external': 'true', ...serviceAnnotations, 'events': {}, 'types': {} };
-            }
-
-            // add event entry to service
-            const eventAnnotations = this.getEventAnnotations(value);
-
-            // add topic annotation
-            eventAnnotations['@topic'] = this.getTopicName(eventName);
-            /** @type {Record<string, CsnElement>} */
-            let properties = {};
-            /** @type {CsnTypeMap} */
-            let types = {};
-
-            if (value.payload) {
-                // gets the schema being referred to in the event
-                const eventSchema = this.resolveRef(content, value.payload);
-                [properties, types] = this.getPropertiesAndTypes(event, eventSchema, content);
-            }
-            services[service].types = { ...services[service].types, ...types };
-            services[service].events[event] = { 'kind': 'event', '@cds.external': 'true', ...eventAnnotations, elements: properties };
-        });
-
-        return services;
-    }
-
-    /**
-     * Returns annotations of a particular service.
-     * @param {AsyncApiDocument} content - root AsyncAPI document
-     */
-    getServiceAnnotations(content) {
-        const serviceAnnotationsMapping = {
-            'x-sap-stateInfo': 'StateInfo', // expected: object
-            'x-sap-shortText': 'ShortText' // expected: string
-        };
-
-        const infoAnnotationsMapping = {
-            'title': 'Title', // expected: string
-            'version': 'SchemaVersion', // expected: string
-            'description': 'Description' // expected: string
-        };
-
-        const annotations = this.getAnnotations(content, serviceAnnotationsMapping);
-
-        if (content.info) {
-            for (const [key, value] of Object.entries(infoAnnotationsMapping)) {
-                /** @type {Record<string, *>} */ const info = content.info;
-                if (info[key] && !(info[key] instanceof Object)) {
-                    // info values will always be in string format
-                    annotations['@AsyncAPI.' + value] = info[key];
-                }
-            }
-        }
-
-        return annotations;
-    }
-
-    /**
-     * Returns annotations of a particular event.
-     * @param {AsyncApiMessage} content - message object from components.messages
-     */
-    getEventAnnotations(content) {
-        const eventLevelAnnotationsMapping = {
-            'x-sap-event-spec-version': 'EventSpecVersion', // expected: string
-            'x-sap-event-source': 'EventSource', // expected: string
-            'x-sap-event-version': 'EventSchemaVersion', // expected: string
-            'x-sap-event-source-parameters': 'EventSourceParams', // expected: object
-            'x-sap-event-characteristics': 'EventCharacteristics', // expected: object
-            'x-sap-stateInfo': 'EventStateInfo' // expected: object
-        };
-
-        const annotations = this.getAnnotations(content, eventLevelAnnotationsMapping);
-
-        return annotations;
-    }
-
-    /**
-     * @param {string} annotation - annotation name (without @AsyncAPI. prefix)
-     * @param {*} value
-     */
-    isValidAnnotationValue(annotation, value) {
-        const objectTypeAnnotations = ['StateInfo', 'EventSourceParams', 'EventCharacteristics', 'EventStateInfo'];
-        // if the value is an array or null
-        if (Array.isArray(value) || value === null) return false;
-
-        if (objectTypeAnnotations.includes(annotation) && (value instanceof Object)) {
-            return true;
-        } else if ((!objectTypeAnnotations.includes(annotation)) && (typeof value === 'string')) {
-            return true;
-        } else {
-            console.warn(`WARNING: Annotations which are not following the expected type are omitted.`);
-            return false;
-        }
-    }
-
-    /**
-     * Returns annotations for an event/service.
-     * @param {object} content - event or service object
-     * @param {Record<string, string>} annotationsMapping - map of AsyncAPI extension key to CDS annotation suffix
-     */
-    getAnnotations(content, annotationsMapping) {
-        /** @type {Annotations} */
-        const annotations = {};
-
-        for (const [key, value] of Object.entries(content)) {
-            // case: known annotation
-            if (annotationsMapping[key] && this.isValidAnnotationValue(annotationsMapping[key], value)) {
-                annotations['@AsyncAPI.' + annotationsMapping[key]] = value;
-            }
-            // case: unkown annotation
-            else if (key.startsWith('x-')) {
-                if (!annotations['@AsyncAPI.Extensions']) {
-                    annotations['@AsyncAPI.Extensions'] = {};
-                }
-                // removes x- from the element
-                annotations['@AsyncAPI.Extensions'][key.substring(2)] = value;
-            }
-        }
-
-        return annotations;
-    }
-
-    /**
-     * Merges allOf entries into a single schema object with combined properties.
-     * Resolves any $ref entries within the allOf array using the provided document.
-     * @param {AsyncApiSchema} schema - AsyncAPI schema object, possibly containing allOf
-     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
-     */
-    flattenAllOf(schema, docContent) {
-        if (!schema.allOf) return schema;
-        /** @type {AsyncApiSchema} */
-        const merged = { type: 'object', properties: {} };
-        const required = [];
-        for (const entry of schema.allOf) {
-            const resolved = entry['$ref'] ? this.resolveRef(docContent, entry) : entry;
-            const flat = this.flattenAllOf(resolved, docContent);
-            Object.assign(merged.properties ?? {}, flat.properties || {});
-            if (flat.required) required.push(...flat.required);
-        }
-        if (required.length) merged.required = required;
-        return merged;
-    }
-
-    /**
-     * Returns the referred schema.
-     * @param {AsyncApiDocument} content - root AsyncAPI document
-     * @param {AsyncApiSchema | {'$ref': string}} payloadObject - either a $ref object or an inline schema
-     */
-    resolveRef(content, payloadObject) {
-        /** @type {AsyncApiSchema} */
-        let schema = {};
-
-        if (payloadObject['$ref']) {
-            const pathArray = payloadObject['$ref'].split('/');
-            pathArray.forEach((value) => {
-                if (value === '#') schema = content;
-                else if (schema[value]) schema = schema[value];
-                // in case path doesn't exist in the file
-                else schema = {};
-            });
-
-            if (!Object.keys(schema).length) {
-                console.warn(`WARNING: Unable to resolve ref path: ` + payloadObject['$ref']);
-            }
-        }
-        else if (payloadObject instanceof Object) {
-            // in case ref is not there and schema object is there
-            schema = payloadObject;
-        }
-
-        return schema;
-    }
-
-    /**
-     * Returns the properties and types generated, related to an event.
-     * @param {string} eventName
-     * @param {AsyncApiSchema} content - resolved AsyncAPI schema object for the event payload
-     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
-     * @returns {[Record<string, CsnElement>, CsnTypeMap]}
-     */
-    getPropertiesAndTypes(eventName, content, docContent) {
-        /** @type {Record<string, CsnElement>} */
-        const properties = {};
-        /** @type {CsnTypeMap} */
-        const types = {};
-
-        if (content.properties) {
-            for (const [key, value] of Object.entries(content.properties)) {
-                let isRequired = false;
-                if (content['required']?.includes(key)) isRequired = true;
-                properties[key] = this.parseProperty(eventName, key, value, isRequired, docContent, types);
-            }
-        }
-        return [properties, types];
-    }
-
-    /**
-     * Returns the processed CSN element object for a property.
-     * @param {string} eventName
-     * @param {string} propertyName
-     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
-     * @param {boolean} isRequired
-     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
-     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
-     */
-    parseProperty(eventName, propertyName, propertyContent, isRequired, docContent, types) {
-        let property = {};
-        let propertyAttributes = {};
-
-        if (isRequired === true) {
-            property['@mandatory'] = true;
-        }
-
-        let type = this.getTypeFromArray(propertyContent.type);
-        if (!type && propertyContent.allOf) type = 'object';
-
-        // case where type is defined
-        if (type && (type === 'object' || type === 'array')) {
-            // for generation of type: event name + property name
-            propertyName = propertyName[0].toUpperCase() + propertyName.substring(1);
-            let typeName = eventName + "." + propertyName;
-            // generate object for the introduced type
-            const elements = this.getTypeElements(propertyContent, docContent, types);
-            types[typeName] = { 'kind': 'type', '@cds.external': 'true', ...elements };
-            // referring to the generated type from the property
-            propertyAttributes = { 'type': typeName };
-        } else {
-            propertyAttributes = this.getPropertyObject(propertyContent, docContent, types);
-        }
-        property = { ...property, ...propertyAttributes };
-
-        return property;
-    }
-
-    /**
-     * Returns the CSN structure for a complex (object/array) schema element.
-     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
-     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
-     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
-     * @returns {CsnElement}
-     */
-    getTypeElements(propertyContent, docContent, types) {
-        /** @type {CsnElement} */
-        let properties = {};
-        const schema = propertyContent.allOf ? this.flattenAllOf(propertyContent, docContent) : propertyContent;
-        let type = this.getTypeFromArray(schema.type);
-
-        // for nested object
-        if (type === 'object') {
-            if (!schema.properties) return {};
-            for (const [key, value] of Object.entries(schema.properties)) {
-                properties[key] = this.getTypeElements(value, docContent, types);
-            }
-        }
-        // for nested array
-        else if (type === 'array') {
-            if (!schema.items || (!schema.items.type && !schema.items['$ref'] && !schema.items.allOf)) return {};
-            properties.items = this.getTypeElements(schema.items, docContent, types);
-            return properties;
-        }
-        // base data type mapping
-        else {
-            return this.getPropertyObject(schema, docContent, types);
-        }
-
-        return { elements: properties };
-    }
-
-    /**
-     * Unwraps nullable array type representations to a single type string.
-     * @param {string | string[] | undefined} typeValue
-     */
-    getTypeFromArray(typeValue) {
-        let type;
-        // if type is an array
-        if (Array.isArray(typeValue)) {
-            // one of the value will be null
-            type = typeValue[0] === 'null' ? typeValue[1] : typeValue[0];
-        } else {
-            type = typeValue;
-        }
-
-        return type;
-    }
-
-    /**
-     * Returns the CSN element object for a scalar or $ref property.
-     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
-     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
-     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
-     */
-    getPropertyObject(propertyContent, docContent, types) {
-        /** @type {CsnElement} */
-        const property = {};
-        if ('$ref' in propertyContent) {
-            const refPathParts = (propertyContent['$ref'] ?? '').split('/');
-            const schemaName = refPathParts[3] ?? '';
-            const isWholeSchemaRef = () => refPathParts.length === 4 && refPathParts[1] === 'components' && refPathParts[2] === 'schemas';
-
-            if (isWholeSchemaRef()) {
-                // $ref to a whole top-level schema — resolve it and emit as a CDS type
-                if (!types[schemaName]) {
-                    types[schemaName] = null; // placeholder to guard against circular refs
-                    const resolvedSchema = this.resolveRef(docContent, propertyContent);
-                    const flatSchema = resolvedSchema.allOf ? this.flattenAllOf(resolvedSchema, docContent) : resolvedSchema;
-                    const elements = this.getTypeElements(flatSchema, docContent, types);
-                    // only emit a named type if it has structure; otherwise fall back to LargeString
-                    if (Object.keys(elements).length > 0) {
-                        types[schemaName] = { 'kind': 'type', '@cds.external': 'true', ...elements };
-                    } else {
-                        delete types[schemaName];
-                        property['type'] = 'cds.LargeString';
-                        return property;
-                    }
-                }
-                property['type'] = schemaName;
-            } else {
-                // $ref to a specific property within a schema (e.g. /properties/propName)
-                const propertyName = refPathParts[refPathParts.length - 1];
-                property['type'] = { 'ref': [schemaName, propertyName] };
-            }
-            return property;
-        }
-        const inputType = this.getTypeFromArray(propertyContent.type);
-        const cdsType = this.getDataType(inputType, propertyContent.format);
-
-        property['type'] = cdsType;
-
-        // case: cds type is decimal
-        if (cdsType === 'cds.Decimal') {
-            if (propertyContent['x-sap-precision']) property.precision = propertyContent['x-sap-precision'];
-            if (propertyContent['x-sap-scale']) property.scale = propertyContent['x-sap-scale'];
-        }
-
-        if (propertyContent['default']) {
-            property['default'] = { 'val': propertyContent['default'] };
-        }
-
-        if (propertyContent['enum']) {
-            property['enum'] = this.getEnumObject(propertyContent['enum']);
-        }
-
-        return property;
-    }
-
-    /**
-     * @param {Array<*>} enumArray
-     */
-    getEnumObject(enumArray) {
-        /** @type {Record<string, {}>} */
-        const enumProperty = {};
-
-        enumArray.forEach(val => {
-            enumProperty[String(val)] = {};
-        });
-
-        return enumProperty;
-    }
-
-    /**
-     * @param {string | undefined} type - AsyncAPI primitive type
-     * @param {string | null} format - AsyncAPI format string
-     */
-    getDataType(type, format = null) {
-        if (!type) throw new Error(messages.UNRESOLVED_TYPE + `'${type}'`);
-        /** @type {Record<string, string>} */
-        const asyncapiToCdsMapping = {
-            'number': 'cds.Double',
-            'boolean': 'cds.Boolean',
-            'integer': 'cds.Integer'
-        };
-
-        if (type === 'string') {
-            switch (format) {
-                case 'int64':
-                    return 'cds.Integer64';
-                case 'decimal':
-                    return 'cds.Decimal';
-                case 'uuid':
-                    return 'cds.UUID';
-                case 'date':
-                    return 'cds.Date';
-                case 'partial-time':
-                    return 'cds.Time';
-                case 'date-time':
-                    return 'cds.Timestamp';
-                default:
-                    return 'cds.LargeString';
-            }
-        } else if (asyncapiToCdsMapping[type]) {
-            return asyncapiToCdsMapping[type];
-        } else {
-            throw new Error(messages.UNRESOLVED_TYPE + `'${type}'`);
-        }
-    }
-}

package/lib/import/asyncapi/utils.js

@@ -1,49 +0,0 @@
-const messages = require("../message").getMessages();
-
-function validateAsyncAPI(content) {
-    if ('channels' in content && 'components' in content && 'messages' in content.components) {
-        return;
-    }
-
-    throw new Error(messages.INVALID_ASYNCAPI_FILE);
-}
-
-/**
- * Accepted scenarios:
- * * with version info : <namespace>.<businessObject>.<operation>.<version>
- * * without version info : <namespace>.<businessObject>.<operation>
- *
- * ? Is it mandatory for <namespace> to always follow small case notation?
- * ? Is it mandatory for <businessObject> to follow Camel Case or Upper Came Case notation?
- * 
- * ToDo: Can we support `-` in operations?
- */
-const regExp = new RegExp(
-    '^(?<namespace>(?:[a-z][a-z0-9]*)(?:[.][a-z][a-z0-9]*)+)[.](?<businessObject>[a-zA-Z0-9]+)[.](?<operation>[a-zA-Z0-9]+)[.]?(?<version>v(?:[0-9]|[1-9][0-9]*))?$'
-);
-
-/**
- * Validates the messages' `key` with the regExp and returns the regEx groups.
- * @returns regexGroups
- */
-function getRegExpGroups(key) {
-    /**
-     * Result format:
-     * index 0: key
-     * index 1: <namespace> value
-     * index 2: <businessObject> value
-     * index 3: <operation> value
-     * index 4: <version> value; undefined if <version> is optional
-     */
-    const regExpGroups = regExp.exec(key);
-
-    if (regExpGroups == null) {
-        throw new Error(messages.INVALID_MESSAGE_NAME);
-    }
-    return regExpGroups;
-}
-
-module.exports = {
-    validateAsyncAPI,
-    getRegExpGroups
-}

package/node_modules/@sap/cds/libx/_runtime/ucl/queries.js

@@ -1,61 +0,0 @@
-const READ_QUERY = /* GraphQL */ `
-  query ($key: String!, $value: String!) {
-    applicationTemplates(filter: { key: $key, query: $value }) {
-      data {
-        id
-        name
-        description
-        placeholders {
-          name
-          description
-        }
-        applicationInput
-        labels
-        webhooks {
-          type
-        }
-      }
-    }
-  }
-`
-
-const CREATE_MUTATION = /* GraphQL */ `
-  mutation ($input: ApplicationTemplateInput!) {
-    result: createApplicationTemplate(in: $input) {
-      id
-      name
-      labels
-      applicationInput
-      applicationNamespace
-    }
-  }
-`
-
-const UPDATE_MUTATION = /* GraphQL */ `
-  mutation ($id: ID!, $input: ApplicationTemplateUpdateInput!) {
-    result: updateApplicationTemplate(id: $id, in: $input) {
-      id
-      name
-      labels
-      description
-      applicationInput
-    }
-  }
-`
-
-const DELETE_MUTATION = /* GraphQL */ `
-  mutation ($id: ID!) {
-    result: deleteApplicationTemplate(id: $id) {
-      id
-      name
-      description
-    }
-  }
-`
-
-module.exports = {
-  READ_QUERY,
-  CREATE_MUTATION,
-  UPDATE_MUTATION,
-  DELETE_MUTATION
-}