@cap-js/cds-typer 0.19.0 → 0.20.0

package/lib/csn.js

@@ -1,5 +1,33 @@
 const annotation = '@odata.draft.enabled'
 
+/**
+ * FIXME: this is pretty handwavey: we are looking for view-entities,
+ * i.e. ones that have a query, but are not a cds level projection.
+ * Those are still not expanded and we have to retrieve their definition
+ * with all properties from the inferred model.
+ */
+const isView = entity => entity.query && !entity.projection
+
+const isProjection = entity => entity.projection
+
+const getViewTarget = entity => entity.query?.SELECT?.from?.ref?.[0]
+
+const getProjectionTarget = entity => entity.projection?.from?.ref?.[0]
+
+const isDraftEnabled = entity => entity['@odata.draft.enabled'] === true
+
+const isType = entity => entity?.kind === 'type'
+
+const isEntity = entity => entity?.kind === 'entity'
+
+/**
+ * @see isView
+ * Unresolved entities have to be looked up from inferred csn.
+ */
+const isUnresolved = entity => entity._unresolved === true
+
+const isCsnAny = entity => entity?.constructor?.name === 'any'
+
 class DraftUnroller {
     /** @type {Set<string>} */
     #positives = new Set()
@@ -226,19 +254,6 @@ function amendCSN(csn) {
     propagateForeignKeys(csn)
 }
 
-/**
- * FIXME: this is pretty handwavey: we are looking for view-entities,
- * i.e. ones that have a query, but are not a cds level projection.
- * Those are still not expanded and we have to retrieve their definition
- * with all properties from the inferred model.
- */
-const isView = entity => entity.query && !entity.projection
-
-const isProjection = entity => entity.projection
-
-const getViewTarget = entity => entity.query?.SELECT?.from?.ref?.[0]
-
-const getProjectionTarget = entity => entity.projection?.from?.ref?.[0]
 
 const getProjectionAliases = entity => {
     const aliases = {}
@@ -255,25 +270,17 @@ const getProjectionAliases = entity => {
     return { aliases, all }
 }
 
-const isDraftEnabled = entity => entity['@odata.draft.enabled'] === true
-
-const isType = entity => entity?.kind === 'type'
-
-/**
- * @see isView
- * Unresolved entities have to be looked up from inferred csn.
- */
-const isUnresolved = entity => entity._unresolved === true
-
 module.exports = { 
     amendCSN, 
     isView, 
     isProjection,
     isDraftEnabled,
+    isEntity,
     isUnresolved,
     isType,
     getProjectionTarget,
     getProjectionAliases,
     getViewTarget,
-    propagateForeignKeys
+    propagateForeignKeys,
+    isCsnAny
 }

package/lib/file.js

@@ -1,12 +1,14 @@
 'use strict'
 
 const fs = require('fs').promises
+const path = require('path')
 const { readFileSync } = require('fs')
 const { printEnum, propertyToInlineEnumName, stringifyEnumImplementation } = require('./components/enum')
 const { normalise } = require('./components/identifier')
-const path = require('path')
+const { empty } = require('./components/typescript')
+const { createObjectOf } = require('./components/wrappers')
 
-const AUTO_GEN_NOTE = "// This is an automatically generated file. Please do not change its contents manually!"
+const AUTO_GEN_NOTE = '// This is an automatically generated file. Please do not change its contents manually!'
 
 /** @typedef {Object<string, Buffer>} Namespace */ 
 
@@ -115,7 +117,7 @@ class SourceFile extends File {
         /** @type {Buffer} */
         this.classes = new Buffer()
         /** @type {{ buffer: Buffer, names: string[]}} */
-        this.actions = { buffer: new Buffer(), names: [] }
+        this.operations = { buffer: new Buffer(), names: [] }
         /** @type {Buffer} */
         this.aspects = new Buffer()
         /** @type {Namespace} */
@@ -154,15 +156,19 @@ class SourceFile extends File {
      * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number'})  // { (p: T): number, __parameters: { p: T } }
      * ```
      */
-    static stringifyLambda({name, parameters=[], returns='any', initialiser, isStatic=false}) {
+    static stringifyLambda({name, parameters=[], returns='any', initialiser, isStatic=false, kind}) {
         const parameterTypes = parameters.map(([n, t]) => `${normalise(n)}: ${t}`).join(', ')
+        const parameterTypeAsObject = parameterTypes.length
+            ? createObjectOf(parameterTypes)
+            : empty
         const callableSignature = `(${parameterTypes}): ${returns}`
         let prefix = name ? `${normalise(name)}: `: ''
         if (prefix && isStatic) {
             prefix = `static ${prefix}`
         }
+        const kindDef = kind ? `, kind: '${kind}'` : ''
         const suffix = initialiser ? ` = ${initialiser}` : ''
-        const lambda = `{ ${callableSignature}, __parameters: {${parameterTypes}}, __returns: ${returns} }`
+        const lambda = `{ ${callableSignature}, __parameters: ${parameterTypeAsObject}, __returns: ${returns}${kindDef}}`
         return prefix + lambda + suffix
     }
 
@@ -183,25 +189,13 @@ class SourceFile extends File {
      * Adds a function definition in form of a arrow function to the file.
      * @param {string} name name of the function
      * @param {{relative: string | undefined, local: boolean, posix: boolean}} parameters list of parameters, passed as [name, type] pairs
+     * @param {'function' | 'action'} kind
      * @param returns the return type of the function
      */
-    addFunction(name, parameters, returns) {
-        // FIXME: use different buffers for buffers and actions, or at least rename buffer to the more general category "functions"?
-        this.actions.buffer.add("// function")
-        this.actions.buffer.add(`export declare const ${SourceFile.stringifyLambda({name, parameters, returns})};`)
-        this.actions.names.push(name)
-    }
-
-    /**
-     * Adds an action definition in form of a arrow function to the file.
-     * @param {string} name name of the action
-     * @param {{relative: string | undefined, local: boolean, posix: boolean}} parameters list of parameters, passed as [name, type] pairs
-     * @param returns the return type of the action
-     */
-    addAction(name, parameters, returns) {
-        this.actions.buffer.add("// action")
-        this.actions.buffer.add(`export declare const ${SourceFile.stringifyLambda({name, parameters, returns})};`)
-        this.actions.names.push(name)
+    addOperation(name, parameters, returns, kind) {
+        //this.operations.buffer.add("// operation")
+        this.operations.buffer.add(`export declare const ${SourceFile.stringifyLambda({name, parameters, returns, kind})};`)
+        this.operations.names.push(name)
     }
 
     /**
@@ -382,38 +376,38 @@ class SourceFile extends File {
             this.aspects.join(), // needs to be before classes
             this.classes.join(),
             this.events.buffer.join(),
-            this.actions.buffer.join(),
+            this.operations.buffer.join(),
             namespaces.join()  // needs to be after classes for possible declaration merging
         ].filter(Boolean).join('\n')
     }
 
     toJSExports() {
-        return [AUTO_GEN_NOTE, "const cds = require('@sap/cds')", `const csn = cds.entities('${this.path.asNamespace()}')`] // boilerplate
+        return [AUTO_GEN_NOTE, 'const cds = require(\'@sap/cds\')', `const csn = cds.entities('${this.path.asNamespace()}')`] // boilerplate
             .concat(
                 // FIXME: move stringification of service into own module
                 this.services.names.map(name => `module.exports = { name: '${name}' }`))  // there should be only one
-                .concat(this.inflections
-                    // sorting the entries based on the number of dots in their singular.
-                    // that makes sure we have defined all parent namespaces before adding subclasses to them e.g.:
-                    // "module.exports.Books" is defined before "module.exports.Books.text"
-                    .sort(([a], [b]) => a.split('.').length - b.split('.').length)
-                    // by using a temporary Set we make sure to catch cases where
-                    // (1) plural is the same as original (default case) and
-                    // (2) plural differs from original, i.e. when a @plural annotation is present
-                    //     or when plural4 produced weird inflection.
-                    .flatMap(([singular, plural, original]) => Array.from(new Set([
-                        `module.exports.${singular} = csn.${original}`,
-                        /Array<.*>/.test(plural) ? undefined : `module.exports.${plural} = csn.${original}`,
-                        // FIXME: we currently produce at most 3 entries.
-                        // This could be an issue when the user re-used the original name in a @singular/@plural annotation.
-                        // Seems unlikely, but we have to eliminate the original entry if users start running into this.
-                        `module.exports.${original} = csn.${original}`
-                    ].filter(Boolean))))  // FIXME: this is a hack to support CDS types that will produce "Array<MyType>" as plural, which we do not want as export in the index.js files
+            .concat(this.inflections
+            // sorting the entries based on the number of dots in their singular.
+            // that makes sure we have defined all parent namespaces before adding subclasses to them e.g.:
+            // "module.exports.Books" is defined before "module.exports.Books.text"
+                .sort(([a], [b]) => a.split('.').length - b.split('.').length)
+            // by using a temporary Set we make sure to catch cases where
+            // (1) plural is the same as original (default case) and
+            // (2) plural differs from original, i.e. when a @plural annotation is present
+            //     or when plural4 produced weird inflection.
+                .flatMap(([singular, plural, original]) => Array.from(new Set([
+                    `module.exports.${singular} = csn.${original}`,
+                    /Array<.*>/.test(plural) ? undefined : `module.exports.${plural} = csn.${original}`,
+                    // FIXME: we currently produce at most 3 entries.
+                    // This could be an issue when the user re-used the original name in a @singular/@plural annotation.
+                    // Seems unlikely, but we have to eliminate the original entry if users start running into this.
+                    `module.exports.${original} = csn.${original}`
+                ].filter(Boolean))))  // FIXME: this is a hack to support CDS types that will produce "Array<MyType>" as plural, which we do not want as export in the index.js files
             ) // singular -> plural aliases
             .concat(['// events'])
             .concat(this.events.fqs.map(({fq, name}) => `module.exports.${name} = '${fq}'`))
             .concat(['// actions'])
-            .concat(this.actions.names.map(name => `module.exports.${name} = '${name}'`))
+            .concat(this.operations.names.map(name => `module.exports.${name} = '${name}'`))
             .concat(['// enums'])
             .concat(this.enums.data.map(({name, kvs}) => stringifyEnumImplementation(name, kvs)))
             .join('\n') + '\n'
@@ -494,7 +488,7 @@ class Buffer {
         if (typeof part === 'function') {
             part()
         } else if (Array.isArray(part)) {
-            part.forEach(p => this.add(p))
+            part.forEach(p => { this.add(p) })
         }
         this.outdent()
     }
@@ -610,44 +604,6 @@ class FileRepository {
     }
 }
 
-/**
- * Base definitions used throughout the typing process,
- * such as Associations and Compositions.
- * @type {SourceFile}
- */
-const baseDefinitions = new SourceFile('_')
-// FIXME: this should be a library someday
-baseDefinitions.addPreamble(`
-export namespace Association {
-    export type to <T> = T;
-    export namespace to {
-        export type many <T extends readonly any[]> = T;
-    }
-}
-
-export namespace Composition {
-    export type of <T> = T;
-    export namespace of {
-        export type many <T extends readonly any[]> = T;
-    }
-}
-
-export class Entity {
-    static data<T extends Entity> (this:T, _input:Object) : T {
-        return {} as T // mock
-    }
-}
-
-export type EntitySet<T> = T[] & {
-    data (input:object[]) : T[]
-    data (input:object) : T
-};
-
-export type DeepRequired<T> = { 
-    [K in keyof T]: DeepRequired<T[K]>
-} & Exclude<Required<T>, null>;
-`)
-
 /**
  * Writes the files to disk. For each source, a index.d.ts holding the type definitions
  * and a index.js holding implementation stubs is generated at the appropriate directory.
@@ -658,18 +614,19 @@ export type DeepRequired<T> = {
  */
 const writeout = async (root, sources) =>
     Promise.all(
-        sources.map(async (source) => {
+        sources.map(async source => {
             const dir = path.join(root, source.path.asDirectory({local: false, posix: false}))
             try {
                 await fs.mkdir(dir, { recursive: true })
                 await Promise.all([
-                        fs.writeFile(path.join(dir, 'index.ts'), source.toTypeDefs()),
-                        fs.writeFile(path.join(dir, 'index.js'), source.toJSExports()),
-                    ])
+                    fs.writeFile(path.join(dir, 'index.ts'), source.toTypeDefs()),
+                    fs.writeFile(path.join(dir, 'index.js'), source.toJSExports()),
+                ])
 
             } catch (err) {
                 // eslint-disable-next-line no-console
                 console.error(`Could not create parent directory ${dir}: ${err}.`)
+                // eslint-disable-next-line no-console
                 console.error(err.stack)
             }
             return dir
@@ -683,6 +640,5 @@ module.exports = {
     FileRepository,
     SourceFile,
     Path,
-    writeout,
-    baseDefinitions,
+    writeout
 }

package/lib/util.js

@@ -1,5 +1,3 @@
-/* eslint-disable indent */
-
 /**
  * @typedef { {name?: string, '@singular'?: string, '@plural'?: string,} } Annotations
  * @typedef { {desc: string, default?: any} } CommandlineFlag
@@ -30,7 +28,7 @@ const annotations = {
  * @param {Object} csn the CSN of an entity to check
  * @returns {string | undefined} the singular annotation or undefined
  */
-const getSingularAnnotation = (csn) => csn[annotations.singular.find(a => Object.hasOwn(csn, a))]
+const getSingularAnnotation = csn => csn[annotations.singular.find(a => Object.hasOwn(csn, a))]
 
 /**
  * Tries to retrieve an annotation that specifies the plural name
@@ -40,9 +38,9 @@ const getSingularAnnotation = (csn) => csn[annotations.singular.find(a => Object
  * @param {Object} csn the CSN of an entity to check
  * @returns {string | undefined} the plural annotation or undefined
  */
-const getPluralAnnotation = (csn) => csn[annotations.plural.find(a => Object.hasOwn(csn, a))]
+const getPluralAnnotation = csn => csn[annotations.plural.find(a => Object.hasOwn(csn, a))]
 
- /**
+/**
   * Users can specify that they want to refer to localisation
   * using the syntax {i18n>Foo}, where Foo is the name of the
   * entity as found in the .cds file
@@ -53,9 +51,9 @@ const getPluralAnnotation = (csn) => csn[annotations.plural.find(a => Object.has
   * @returns {string} the name without localisation syntax or untouched.
   * @deprecated we have dropped this feature altogether, users specify custom names via @singular/@plural now
   */
-const unlocalize = (name) => {
-	const match = name.match(/\{i18n>(.*)\}/)
-	return match ? match[1] : name
+const unlocalize = name => {
+    const match = name.match(/\{i18n>(.*)\}/)
+    return match ? match[1] : name
 }
 
 /**
@@ -74,19 +72,19 @@ const singular4 = (dn, stripped = false) => {
         (/.*species|news$/i.test(n)
             ? n
             : /.*ess$/.test(n)
-            ? n // Address
-            : /.*ees$/.test(n)
-            ? n.slice(0, -1) // Employees --> Employee
-            : /.*[sz]es$/.test(n)
-            ? n.slice(0, -2)
-            : /.*[^aeiou]ies$/.test(n)
-            ? n.slice(0, -3) + 'y' // Deliveries --> Delivery
-            : /.*s$/.test(n)
-            ? n.slice(0, -1)
-            : /.*_$/.test(n) // special cdstyper case where we revert the _ suffix for when a plural can not be determined
-            ? n.slice(0, -1)
-            : n
-            )
+                ? n // Address
+                : /.*ees$/.test(n)
+                    ? n.slice(0, -1) // Employees --> Employee
+                    : /.*[sz]es$/.test(n)
+                        ? n.slice(0, -2)
+                        : /.*[^aeiou]ies$/.test(n)
+                            ? n.slice(0, -3) + 'y' // Deliveries --> Delivery
+                            : /.*s$/.test(n)
+                                ? n.slice(0, -1)
+                                : /.*_$/.test(n) // special cdstyper case where we revert the _ suffix for when a plural can not be determined
+                                    ? n.slice(0, -1)
+                                    : n
+        )
     )
 }
 
@@ -106,10 +104,10 @@ const plural4 = (dn, stripped) => {
         (/.*analysis|status|species|news$/i.test(n)
             ? n
             : /.*[^aeiou]y$/.test(n)
-            ? n.slice(0, -1) + 'ies'
-            : /.*(s|x|z|ch|sh)$/.test(n)
-            ? n + 'es'
-            : n + 's')
+                ? n.slice(0, -1) + 'ies'
+                : /.*(s|x|z|ch|sh)$/.test(n)
+                    ? n + 'es'
+                    : n + 's')
     )
 }
 
@@ -121,8 +119,8 @@ const plural4 = (dn, stripped) => {
  */
 const deepMerge = (target, source) => {
     Object.keys(target)
-        .filter((k) => k in source)
-        .forEach((k) => deepMerge(target[k], source[k]))
+        .filter(k => k in source)
+        .forEach(k => { deepMerge(target[k], source[k]) })
     Object.assign(target, source)
 }
 
@@ -141,7 +139,7 @@ const deepMerge = (target, source) => {
  * @returns {ParsedFlags}
  */
 const parseCommandlineArgs = (argv, validFlags) => {
-    const isFlag = (arg) => arg.startsWith('--')
+    const isFlag = arg => arg.startsWith('--')
     const positional = []
     const named = {}
 
@@ -173,7 +171,7 @@ const parseCommandlineArgs = (argv, validFlags) => {
     }
 
     const defaults = Object.entries(validFlags)
-        .filter((e) => !!e[1].default)
+        .filter(e => !!e[1].default)
         .reduce((dict, [k, v]) => {
             dict[k] = v.default
             return dict