@cap-js/cds-typer 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -4,7 +4,24 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
-## Version 0.5.1 - TBD
+## Version 0.6.1 - TBD
+
+### Changed
+
+### Added
+
+### Fixed
+
+
+## Version 0.6.0 - 2023-08-07
+
+### Added
+- Support for `event` syntax
+
+### Fixed
+- Initialise bound actions with stubs to support `"strict":true` in _tsconfig.json_
+- Add leading underscore to appease `noUnusedParameters` in strict tsconfigs
+- No longer inflect `type` definitions when they are referenced within entities or other type definitions
 
 ## Version 0.5.0 - 2023-07-25
 
@@ -14,7 +31,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Added
 - Support for `array of` syntax
 
-### Fixes
+### Fixed
 - Generate `string` type for date-related types in CDS definitions
 - Generate `Buffer | string` type for the CDS type `LargeBinary`
 

package/lib/components/inline.js

@@ -142,7 +142,7 @@ class FlatInlineDeclarationResolver extends InlineDeclarationResolver {
     flatten(prefix, type) {
         return type.typeInfo.structuredType
             ? Object.entries(type.typeInfo.structuredType).map(([k,v]) => this.flatten(`${this.prefix(prefix)}${k}`, v))
-            : [`${prefix} ${this.getPropertyTypeSeparator()} ${type.typeName}`]
+            : [`${prefix}${this.getPropertyTypeSeparator()} ${type.typeName}`]
     }
 
     printInlineType(name, type, buffer) {
@@ -185,7 +185,7 @@ class StructuredInlineDeclarationResolver extends InlineDeclarationResolver {
         this.printDepth++
         const lineEnding = this.printDepth > 1 ? ',' : statementEnd
         if (type.typeInfo.structuredType) {
-            const prefix = name ? `${name} ${this.getPropertyTypeSeparator()}`: ''
+            const prefix = name ? `${name}${this.getPropertyTypeSeparator()}`: ''
             buffer.add(`${prefix} {`)
             buffer.indent()
             for (const [n, t] of Object.entries(type.typeInfo.structuredType)) {
@@ -194,7 +194,7 @@ class StructuredInlineDeclarationResolver extends InlineDeclarationResolver {
             buffer.outdent()
             buffer.add(`}${lineEnding}`)
         } else {
-            buffer.add(`${name} ${this.getPropertyTypeSeparator()} ${type.typeName}${lineEnding}`)
+            buffer.add(`${name}${this.getPropertyTypeSeparator()} ${type.typeName}${lineEnding}`)
         }
         this.printDepth--
         return buffer

package/lib/components/resolver.js

@@ -116,7 +116,7 @@ class Resolver {
         let qualifier = parts.join('.')
         while (
             this.csn.definitions[qualifier] &&
-            ['entity', 'type', 'aspect'].includes(this.csn.definitions[qualifier].kind)
+            ['entity', 'type', 'aspect', 'event'].includes(this.csn.definitions[qualifier].kind)
         ) {
             parts.pop()
             qualifier = parts.join('.')
@@ -131,6 +131,7 @@ class Resolver {
      * - explicit annotation by the user in the CSN
      * - implicitly derived inflection based on simple grammar rules
      * - collisions between singular and plural name (resolved by appending a '_' suffix)
+     * - type definitions, which are not inflected
      * - inline type definitions, which don't really have a linguistic plural,
      *   but need to expressed as array type to be consumable by the likes of Composition.of.many<T>
      * @param {import('./resolver').TypeResolveInfo} typeInfo information about the type gathered so far.
@@ -138,6 +139,16 @@ class Resolver {
      * @returns {Inflection}
      */
     inflect(typeInfo, namespace) {
+        // TODO: handle builtins here as well?
+        // guard: types don't get inflected
+        if (typeInfo.csn?.kind === 'type') {
+            return { 
+                singular: typeInfo.plainName,
+                plural: typeInfo.plainName,
+                typeName: typeInfo.plainName,
+            }
+        }
+
         let typeName
         let singular
         let plural

package/lib/file.js

@@ -99,6 +99,8 @@ class SourceFile extends File {
         this.imports = {}
         /** @type {Buffer} */
         this.preamble = new Buffer()
+        /** @type {{ buffer: Buffer, fqs: {name: string, fq: string}[]}} */
+        this.events = { buffer: new Buffer(), fqs: []} 
         /** @type {Buffer} */
         this.types = new Buffer()
         /** @type {{ buffer: Buffer, fqs: {name: string, fq: string}[]}} */
@@ -119,8 +121,24 @@ class SourceFile extends File {
         this.inflections = []
     }
 
-    static stringifyLambda(name, parameters = [], returns = 'any') {
-        return `${name}: (${parameters.map(([n, t]) => `${n}: ${t}`).join(', ')}) => ${returns}`
+    /**
+     * Stringifies a lambda expression.
+     * @param {{name: string, parameters: [string, string][], returns: string, initialiser: string}} - name, parameters, return type, and initialiser expression
+     * @returns {string} - the stringified lambda
+     * @example
+     * ```js
+     * stringifyLambda({parameters: [['p','T']]}  // (p: T) => any
+     * stringifyLambda({name: 'f', parameters: [['p','T']]}  // f: (p: T) => any
+     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number'}  // f: (p: T) => number
+     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number', initialiser: '_ => 42'}  // f: (p: T) => string = _ => 42
+     * 
+     * ```
+     */
+    static stringifyLambda({name, parameters=[], returns='any', initialiser}) {
+        const signature = `(${parameters.map(([n, t]) => `${n}: ${t}`).join(', ')}) => ${returns}`
+        const prefix = name ? `${name}: `: ''
+        const suffix = initialiser ? ` = ${initialiser}` : ''
+        return prefix + signature + suffix
     }
 
     /**
@@ -139,27 +157,25 @@ 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}} params list of parameters, passed as [name, type] pairs
+     * @param {{relative: string | undefined, local: boolean, posix: boolean}} parameters list of parameters, passed as [name, type] pairs
      * @param returns the return type of the function
      */
-    addFunction(name, params, returns) {
+    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, params, returns)};`)
+        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}} params list of parameters, passed as [name, type] pairs
+     * @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, params, returns) {
-        //const ps = params.map(([n, t]) => `${n}: ${t}`).join(', ')
+    addAction(name, parameters, returns) {
         this.actions.buffer.add("// action")
-        //this.actions.buffer.add(`export declare const ${name}: ( args: { ${ps} }) => ${returns};`)
-        this.actions.buffer.add(`export declare const ${SourceFile.stringifyLambda(name, params, returns)};`)
+        this.actions.buffer.add(`export declare const ${SourceFile.stringifyLambda({name, parameters, returns})};`)
         this.actions.names.push(name)
     }
 
@@ -196,6 +212,7 @@ class SourceFile extends File {
         // and a type containing all disctinct values.
         // We can get away with this as TS doesn't feature nominal typing, so the structure
         // is all we care about.
+        // FIXME: this really should be in visitor, as File should not contain logic of this kind
         this.enums.fqs.push({ name, fq })
         const bu = this.enums.buffer
         bu.add('// enum')
@@ -210,7 +227,6 @@ class SourceFile extends File {
         bu.add('}')
         bu.add(`export type ${name} = ${[...vals].join(' | ')}`)
         bu.add('')
-        
     }
 
     /**
@@ -225,6 +241,16 @@ class SourceFile extends File {
         this.classNames[clean] = fq
     }
 
+    /**
+     * Adds an event to this file.
+     * are supposed to be present in this file. 
+     * @param {string} name cleaned name of the event
+     * @param {string} fq fully qualified name, including the namespace
+     */
+    addEvent(name, fq) {
+        this.events.fqs.push({ name, fq })
+    }
+
     /**
      * Adds an import if it does not exist yet.
      * @param {Path} imp qualifier for the namespace to import.
@@ -289,6 +315,7 @@ class SourceFile extends File {
             namespaces.join(),
             this.aspects.join(), // needs to be before classes
             this.classes.join(),
+            this.events.buffer.join(),
             this.actions.buffer.join(),
         ].filter(Boolean).join('\n')
     }
@@ -311,6 +338,8 @@ class SourceFile extends File {
                         `module.exports.${original} = csn.${original}`
                     ])))
             ) // 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(['// enums'])
@@ -473,7 +502,7 @@ export namespace Composition {
 }
 
 export class Entity {
-    static data<T extends Entity> (this:T, input:Object) : T {
+    static data<T extends Entity> (this:T, _input:Object) : T {
         return {} as T // mock
     }
 }

package/lib/visitor.js

@@ -132,17 +132,18 @@ class Visitor {
             this.visitElement(ename, element, file, buffer)
         }
         for (const [aname, action] of Object.entries(entity.actions ?? {})) {
+            const lambdaString = 
             buffer.add(
-                SourceFile.stringifyLambda(
-                    aname,
-                    Object.entries(action.params ?? {}).map(([n, t]) => [
+                SourceFile.stringifyLambda({
+                    name: aname,
+                    parameters: Object.entries(action.params ?? {}).map(([n, t]) => [
                         n,
                         this.resolver.resolveAndRequire(t, file).typeName,
                     ]),
-                    action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any'
-                )
+                    returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any',
+                    initialiser: `undefined as unknown as this['${aname}']`
+                })
             )
-            //this.visitEntity(aname, action, file, buffer)
         }
         buffer.outdent()
         buffer.add('};')
@@ -287,6 +288,26 @@ class Visitor {
         this._aspectify(name, aspect, file.aspects, clean)
     }
 
+    #printEvent(name, event) {
+        this.logger.debug(`Printing event ${name}`)
+        const clean = this.resolver.trimNamespace(name)
+        const ns = this.resolver.resolveNamespace(name.split('.'))
+        const file = this.getNamespaceFile(ns)
+        file.addEvent(clean, name)
+        const buffer = file.events.buffer
+        buffer.add('// event')
+        buffer.add(`export class ${clean} {`)
+        buffer.indent()
+        const propOpt = this.options.propertiesOptional
+        this.options.propertiesOptional = false
+        for (const [ename, element] of Object.entries(event.elements ?? {})) {
+            this.visitElement(ename, element, file, buffer)
+        }
+        this.options.propertiesOptional = propOpt
+        buffer.outdent()
+        buffer.add('}')
+    }
+
     /**
      * Visits a single entity from the CSN's definition field.
      * Will call #printEntity or #printAction based on the entity's kind.
@@ -310,6 +331,9 @@ class Visitor {
             case 'aspect':
                 this.#printAspect(name, entity)
                 break
+            case 'event':
+                this.#printEvent(name, entity)
+                break
             default:
                 this.logger.error(`Unhandled entity kind '${entity.kind}'.`)
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Generates .ts files for a CDS model to receive code completion in VS Code",
   "main": "index.js",
   "repository": "github:cap-js/cds-typer",