@cap-js/cds-typer 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -4,7 +4,18 @@ 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.13.0 - TBD
+## Version 0.15.0 - TBD
+
+## Version 0.14.0 - 2023-12-13
+### Added
+- Entities that are database views now also receive typings
+
+## Version 0.13.0 - 2023-12-06
+### Changes
+- Enums are now generated ecplicitly in the respective _index.js_ files and don't have to extract their values from the model at runtime anymore
+
+### Added
+- The `excluding` clause in projections now actually excludes the specified properties in the generated types
 
 ## Version 0.12.0 - 2023-11-23
 

package/lib/components/enum.js

@@ -31,8 +31,8 @@ function printEnum(buffer, name, kvs, options = {}) {
     buffer.indent()
     const vals = new Set()
     for (const [k, v] of kvs) {
-        buffer.add(`${k}: ${JSON.stringify(v)},`)
-        vals.add(JSON.stringify(v.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
+        buffer.add(`${k}: ${v},`)
+        vals.add(v?.val ?? v)  // in case of wrapped vals we need to unwrap here for the type
     }
     buffer.outdent()
     buffer.add('} as const;')
@@ -41,27 +41,32 @@ function printEnum(buffer, name, kvs, options = {}) {
 }
 
 // in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
-const enumVal = (key, value, enumType) => enumType === 'cds.String' ? `${value ?? key}` : value
+const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
 
 /**
+ * Converts a CSN type describing an enum into a list of kv-pairs.
+ * Values from CSN are unwrapped from their `.val` structure and
+ * will fall back to the key if no value is provided.
+ * 
  * @param {{enum: {[key: name]: string}, type: string}} enumCsn
  * @param {{unwrapVals: boolean}} options if `unwrapVals` is passed,
  *  then the CSN structure `{val:x}` is flattened to just `x`.
  *  Retaining `val` is closer to the actual CSN structure and should be used where we want
- *  to mimic the runtime as closely as possible (anoymous enum types).
+ *  to mimic the runtime as closely as possible (inline enum types).
  *  Stripping that additional wrapper would be more readable for users.
+ * 
  * @example
  * ```ts 
- * const csn = {enum: {x: {val: 42}, y: {val: -42}}}
- * csnToEnum(csn) // -> [['x', 42], ['y': -42]]
- * csnToEnum(csn, {unwrapVals: false}) // -> [['x', {val:42}], ['y': {val:-42}]]
+ * const csn = {enum: {X: {val: 'a'}, Y: {val: 'b'}, Z: {}}}
+ * csnToEnumPairs(csn) // -> [['X', 'a'], ['Y': 'b'], ['Z': 'Z']]
+ * csnToEnumPairs(csn, {unwrapVals: false}) // -> [['X', {val:'a'}], ['Y': {val:'b'}], ['Z':'Z']]
  * ```
  */
-const csnToEnum = ({enum: enm, type}, options = {}) => {
+const csnToEnumPairs = ({enum: enm, type}, options = {}) => {
     options = {...{unwrapVals: true}, ...options}
     return Object.entries(enm).map(([k, v]) => {
         const val = enumVal(k, v.val, type)
-        return [k, options.unwrapVals ? val : { val }]
+        return [k, (options.unwrapVals ? val : { val })]
     })
 }
 
@@ -69,7 +74,7 @@ const csnToEnum = ({enum: enm, type}, options = {}) => {
  * @param {string} entity
  * @param {string} property
  */
-const propertyToAnonymousEnumName = (entity, property) => `${entity}_${property}`
+const propertyToInlineEnumName = (entity, property) => `${entity}_${property}`
 
 /**
  * A type is considered to be an inline enum, iff it has a `.enum` property
@@ -82,27 +87,30 @@ const propertyToAnonymousEnumName = (entity, property) => `${entity}_${property}
  */
 const isInlineEnumType = (element, csn) => element.enum && !(element.type in csn.definitions)
 
-const stringifyEnumImplementation = (name, enm) => `module.exports.${name} = Object.fromEntries(Object.entries(${enm}).map(([k,v]) => [k,v.val??k]))`
-
-/**
- * @param {string} name
- * @param {string} fq
- * @returns {string}
- */
-const stringifyNamedEnum = (name, fq) => stringifyEnumImplementation(name, `cds.model.definitions['${fq}'].enum`)
 /**
+ * Stringifies an enum into a runtime artifact.
+ * ```cds
+ * type Language: String enum {
+ *   DE = "German";
+ *   EN = "English";
+ *   FR;
+ * }
+ * ```
+ * becomes
+ * 
+ * ```js
+ * module.exports.Language = { DE: "German", EN: "English", FR: "FR" }
+ * ```
  * @param {string} name
- * @param {string} fq
- * @param {string} property
- * @returns {string}
+ * @param {[string, string][]} kvs a list of key-value pairs. Values that are falsey are replaced by 
  */
-const stringifyAnonymousEnum = (name, fq, property) => stringifyEnumImplementation(fq, `cds.model.definitions['${name}'].elements.${property}.enum`)
+const stringifyEnumImplementation = (name, kvs) => `module.exports.${name} = { ${kvs.map(([k,v]) => `${k}: ${v}`).join(', ')} }`
+
 
 module.exports = {
     printEnum,
-    csnToEnum,
-    propertyToAnonymousEnumName,
+    csnToEnumPairs,
+    propertyToInlineEnumName,
     isInlineEnumType,
-    stringifyNamedEnum,
-    stringifyAnonymousEnum
+    stringifyEnumImplementation
 }

package/lib/components/resolver.js

@@ -2,10 +2,10 @@
 
 const util = require('../util')
 // eslint-disable-next-line no-unused-vars
-const { Buffer, SourceFile, Path, Library, baseDefinitions } = require("../file")
+const { Buffer, SourceFile, Path, Library, baseDefinitions } = require('../file')
 const { deepRequire, createToManyAssociation, createToOneAssociation, createArrayOf, createCompositionOfMany, createCompositionOfOne } = require('./wrappers')
-const { StructuredInlineDeclarationResolver } = require("./inline")
-const { isInlineEnumType, propertyToAnonymousEnumName } = require('./enum')
+const { StructuredInlineDeclarationResolver } = require('./inline')
+const { isInlineEnumType, propertyToInlineEnumName } = require('./enum')
 
 /** @typedef {{ cardinality?: { max?: '*' | number } }} EntityCSN */
 /** @typedef {{ definitions?: Object<string, EntityCSN> }} CSN */
@@ -374,7 +374,7 @@ class Resolver {
                 // we use the singular as the initial declaration of these enums takes place
                 // while defining the singular class. Which therefore uses the singular over the plural name.
                 const cleanEntityName = util.singular4(element.parent, true)
-                const enumName = propertyToAnonymousEnumName(cleanEntityName, element.name)
+                const enumName = propertyToInlineEnumName(cleanEntityName, element.name)
                 result.type = enumName
                 result.plainName = enumName
                 result.isInlineDeclaration = true

package/lib/csn.js

@@ -226,4 +226,18 @@ function amendCSN(csn) {
     propagateForeignKeys(csn)
 }
 
-module.exports = { amendCSN }
+/**
+ * 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
+
+/**
+ * @see isView
+ * Unresolved entities have to be looked up from inferred csn.
+ */
+const isUnresolved = entity => entity._unresolved === true
+
+module.exports = { amendCSN, isView, isUnresolved }

package/lib/file.js

@@ -2,7 +2,7 @@
 
 const fs = require('fs').promises
 const { readFileSync } = require('fs')
-const { printEnum, stringifyNamedEnum, stringifyAnonymousEnum, propertyToAnonymousEnumName } = require('./components/enum')
+const { printEnum, propertyToInlineEnumName, stringifyEnumImplementation } = require('./components/enum')
 const path = require('path')
 
 const AUTO_GEN_NOTE = "// This is an automatically generated file. Please do not change its contents manually!"
@@ -104,8 +104,8 @@ class SourceFile extends File {
         this.events = { buffer: new Buffer(), fqs: []} 
         /** @type {Buffer} */
         this.types = new Buffer()
-        /** @type {{ buffer: Buffer, fqs: {name: string, fq: string, property?: string}[]}} */
-        this.enums = { buffer: new Buffer(), fqs: [] }
+        /** @type {{ buffer: Buffer, data: {kvs: [string[]], name: string, fq: string, property?: string}[]}} */
+        this.enums = { buffer: new Buffer(), data: [] }
         /** @type {{ buffer: Buffer }} */
         this.inlineEnums = { buffer: new Buffer() }
         /** @type {Buffer} */
@@ -226,28 +226,28 @@ class SourceFile extends File {
      * @param {string} fq fully qualified name of the enum (entity name within CSN)
      * @param {string} name local name of the enum
      * @param {[string, string][]} kvs list of key-value pairs
-     * @param {string} [property] property to which the enum is attached. 
-     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     * @param {string} [property] property to which the enum is attached.
+     *  If given, the enum is considered to be an inline definition of an enum.
      *  If not, it is considered to be regular, named enum.
      */
     addEnum(fq, name, kvs) {
-        this.enums.fqs.push({ name, fq })
+        this.enums.data.push({ name, fq, kvs })
         printEnum(this.enums.buffer, name, kvs)
     }
 
     /**
-     * Adds an anonymous enum to this file.
+     * Adds an inline enum to this file.
      * @param {string} entityCleanName name of the entity the enum is attached to without namespace
      * @param {string} entityFqName name of the entity the enum is attached to with namespace
      * 
      * @param {string} propertyName property to which the enum is attached. 
      * @param {[string, string][]} kvs list of key-value pairs
-     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     *  If given, the enum is considered to be an inline definition of an enum.
      *  If not, it is considered to be regular, named enum.
      * 
      * @example
      * ```js
-     * addAnonymousEnum('Books.genre', 'Books', 'genre', [['horror','horror']])
+     * addInlineEnum('Books.genre', 'Books', 'genre', [['horror','horror']])
      * ```
      * generates
      * ```js
@@ -266,13 +266,14 @@ class SourceFile extends File {
      * }
      * ```
      */
-    addAnonymousEnum(entityCleanName, entityFqName, propertyName, kvs) {
-        this.enums.fqs.push({ 
+    addInlineEnum(entityCleanName, entityFqName, propertyName, kvs) {
+        this.enums.data.push({ 
             name: entityFqName,
             property: propertyName,
+            kvs,
             fq: `${entityCleanName}.${propertyName}`
         })
-        printEnum(this.inlineEnums.buffer, propertyToAnonymousEnumName(entityCleanName, propertyName), kvs, {export: false})
+        printEnum(this.inlineEnums.buffer, propertyToInlineEnumName(entityCleanName, propertyName), kvs, {export: false})
     }
 
     /**
@@ -410,9 +411,7 @@ class SourceFile extends File {
             .concat(['// actions'])
             .concat(this.actions.names.map(name => `module.exports.${name} = '${name}'`))
             .concat(['// enums'])
-            .concat(this.enums.fqs.map(({name, fq, property}) => property 
-                ? stringifyAnonymousEnum(name, fq, property)
-                : stringifyNamedEnum(name, fq)))
+            .concat(this.enums.data.map(({name, kvs}) => stringifyEnumImplementation(name, kvs)))
             .join('\n') + '\n'
     }
 }
@@ -608,6 +607,7 @@ const writeout = async (root, sources) =>
             } catch (err) {
                 // eslint-disable-next-line no-console
                 console.error(`Could not create parent directory ${dir}: ${err}.`)
+                console.error(err.stack)
             }
             return dir
         })

package/lib/visitor.js

@@ -2,14 +2,14 @@
 
 const util = require('./util')
 
-const { amendCSN } = require('./csn')
+const { amendCSN, isView, isUnresolved } = require('./csn')
 // eslint-disable-next-line no-unused-vars
 const { SourceFile, baseDefinitions, Buffer } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
 const { Resolver } = require('./components/resolver')
 const { Logger } = require('./logging')
 const { docify } = require('./components/wrappers')
-const { csnToEnum, propertyToAnonymousEnumName, isInlineEnumType } = require('./components/enum')
+const { csnToEnumPairs, propertyToInlineEnumName, isInlineEnumType } = require('./components/enum')
 
  /** @typedef {import('./file').File} File */
  /** @typedef {{ entity: String }} Context */
@@ -99,10 +99,12 @@ class Visitor {
      */
     visitDefinitions() {
         for (const [name, entity] of Object.entries(this.csn.xtended.definitions)) {
-            if (entity._unresolved === true) {
-                this.logger.error(`Skipping unresolved entity: ${JSON.stringify(entity)}`)
-            } else {
+            if (isView(entity)) {
+                this.visitEntity(name, this.csn.inferred.definitions[name])
+            } else if (!isUnresolved(entity)) {
                 this.visitEntity(name, entity)
+            } else {
+                this.logger.warning(`Skipping unresolved entity: ${name}`)
             }
         }
         // FIXME: optimise
@@ -156,7 +158,9 @@ class Visitor {
         buffer.indent()
 
         const enums = []
-        for (const [ename, element] of Object.entries(entity.elements ?? {})) {
+        const exclusions = new Set(entity.projection?.excluding ?? [])
+        const elements = Object.entries(entity.elements ?? {}).filter(([ename]) => !exclusions.has(ename))
+        for (const [ename, element] of elements) {
             this.visitElement(ename, element, file, buffer)
 
             // make foreign keys explicit
@@ -180,8 +184,8 @@ class Visitor {
 
         buffer.indent()
         for (const e of enums) {
-            buffer.add(`static ${e.name} = ${propertyToAnonymousEnumName(clean, e.name)}`)
-            file.addAnonymousEnum(clean, name, e.name, csnToEnum(e, {unwrapVals: true}))
+            buffer.add(`static ${e.name} = ${propertyToInlineEnumName(clean, e.name)}`)
+            file.addInlineEnum(clean, name, e.name, csnToEnumPairs(e, {unwrapVals: true}))
         }
         buffer.add('static actions: {')
         buffer.indent()
@@ -341,7 +345,7 @@ class Visitor {
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
         if ('enum' in type) {
-            file.addEnum(name, clean, csnToEnum(type))
+            file.addEnum(name, clean, csnToEnumPairs(type))
         } else {
             // alias
             file.addType(name, clean, this.resolver.resolveAndRequire(type, file).typeName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.12.0",
+  "version": "0.14.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",