@cap-js/cds-typer 0.36.0 → 0.38.0

package/lib/boilerplate/tsBoilerplate.ts

@@ -72,7 +72,7 @@ export type CdsMap = { [key: string]: unknown };
 
 
 export const createEntityProxy = function (fqParts: any, opts = {}) {
-    const { target, customProps } = { target: {}, customProps: [], ...opts }
+    const { target, customProps } = { target: {}, customProps: [] as any[], ...opts }
     const fq = fqParts.filter((p: any) => !!p).join('.')
     return new Proxy(target, {
         get: function (target:any, prop:any) {

package/lib/cli.js

@@ -149,6 +149,10 @@ const flags = enrichFlagSchema({
         default: './',
         type: 'string'
     },
+    outputDTsFiles: parameterTypes.boolean({
+        desc: '(experimental) If set to true, emits .d.ts files for each generated .js file. If set to false (default), emits .ts files instead. Note: skipLibCheck must be set to true in your tsconfig for this option to work properly.',
+        default: 'false',
+    }),
     help: {
         desc: 'This text.',
     },

package/lib/components/property.js

@@ -1,11 +1,15 @@
 /**
  * Determines the proper modifiers for a property.
- * For most properties, this will be "declare". But for some properties,
- * like fields of a type, we don't want any modifiers.
+ *
+ * All properties must be modified by `declare`.
+ * The only exception to this is in case of an action return type being defined
+ * as an object. Here `declare` would cause an error.
+ * This case can be identified by checking the parent of the property:
+ * If the parent is a type and has no name, then it is an action return type.
  * @param {import('../typedefs').resolver.EntityCSN} element - The element to determine the modifiers for.
  * @returns {import('../typedefs').resolver.PropertyModifier[]} The modifiers for the property.
  */
-const getPropertyModifiers = element => element?.parent?.kind !== 'type' ? ['declare'] : []
+const getPropertyModifiers = element => element?.parent?.kind === 'type' && element?.parent?.name === undefined ? [] : ['declare']
 
 module.exports = {
     getPropertyModifiers

package/lib/csn.js

@@ -65,6 +65,11 @@ const isEntity = entity => entity?.kind === 'entity'
  */
 const isEnum = entity => Boolean(entity && Object.hasOwn(entity, 'enum'))
 
+/**
+ * @param {EntityCSN & { '@cds.external'?: boolean } | undefined} entity - the entity
+ */
+const isExternal = entity => entity?.['@cds.external'] === true
+
 /**
  * Attempts to retrieve the max cardinality of a CSN for an entity.
  * @param {EntityCSN} element - csn of entity to retrieve cardinality for
@@ -365,6 +370,7 @@ module.exports = {
     isEnum,
     isUnresolved,
     isType,
+    isExternal,
     getMaxCardinality,
     getProjectionTarget,
     getProjectionAliases,

package/lib/file.js

@@ -162,6 +162,7 @@ class SourceFile extends File {
      * @param {string} options.name - name of the lambda
      * @param {import('./typedefs').visitor.ParamInfo[]} [options.parameters] - list of parameters, passed as [name, modifier, type, doc] pairs
      * @param {string} [options.returns] - the return type of the function
+     * @param {string} [options.self] - what is set as "__self", which is used for bound actions. For unbound actions, this will be `never` (null would lead to incorrect type reduction)
      * @param {'action' | 'function'} options.kind - kind of the lambda
      * @param {string} [options.initialiser] - the initialiser expression
      * @param {boolean} [options.isStatic] - whether the lambda is static
@@ -187,7 +188,7 @@ class SourceFile extends File {
      * stringifyLambda({name: 'f', parameters: [{name:'p',type:'T'}], returns: 'number'})  // { (p: T): number, __parameters: { p: T } }
      * ```
      */
-    static stringifyLambda({name, parameters=[], returns='any', kind, initialiser, isStatic=false, callStyles={positional:true, named:true}, doc}) {
+    static stringifyLambda({name, parameters=[], returns='any', kind, initialiser, self='never', isStatic=false, callStyles={positional:true, named:true}, doc}) {
         let docStr = doc?.length ? doc.join('\n')+'\n' : ''
         const parameterTypes = parameters.map(({name, modifier, type, doc}) => `${doc?'\n'+doc:''}${normalise(name)}${modifier}: ${type}`).join(', ')
         const parameterTypeAsObject = parameterTypes.length
@@ -212,7 +213,7 @@ class SourceFile extends File {
 
         return [
             `${prefix} {`,
-            [...callableSignatures, '// metadata (do not use)', `__parameters: ${parameterTypeAsObject}, __returns: ${returns}`, ...kindDef],
+            [...callableSignatures, '// metadata (do not use)', `__parameters: ${parameterTypeAsObject}, __returns: ${returns}, __self: ${self}`, ...kindDef],
             `}${suffix}`,
         ]
     }
@@ -824,10 +825,11 @@ const writeout = async (root, sources) =>
     Promise.all(
         sources.map(async source => {
             const dir = path.join(root, source.path.asDirectory({local: false, posix: false}))
+            const outputFile = configuration.outputDTsFiles ? 'index.d.ts' : 'index.ts'
             try {
                 await fs.mkdir(dir, { recursive: true })
                 await Promise.all([
-                    fs.writeFile(path.join(dir, 'index.ts'), source.toTypeDefs()),
+                    fs.writeFile(path.join(dir, outputFile), source.toTypeDefs()),
                     fs.writeFile(path.join(dir, 'index.js'), source.toJSExports()),
                 ])
 

package/lib/resolution/entity.js

@@ -184,7 +184,7 @@ class EntityRepository {
 
 /**
  * Derives an identifier from an entity info.
- * That identifier can be used to refer to a specific entity within an index.ts file.
+ * That identifier can be used to refer to a specific entity within an index.ts / index.d.ts file.
  * By passing a relative file, the identifier will be preceeded with a scope if needed.
  * @param {object} options - the options
  * @param {EntityInfo} options.info - the entity info

package/lib/resolution/resolver.js

@@ -7,7 +7,7 @@ const { deepRequire, createToManyAssociation, createToOneAssociation, createArra
 const { StructuredInlineDeclarationResolver } = require('../components/inline')
 const { isInlineEnumType, propertyToInlineEnumName } = require('../components/enum')
 const { isReferenceType } = require('../components/reference')
-const { isEntity, getMaxCardinality } = require('../csn')
+const { isEntity, getMaxCardinality, isExternal } = require('../csn')
 const { getBaseDefinitions } = require('../components/basedefs')
 const { BuiltinResolver } = require('./builtin')
 const { LOG } = require('../logging')
@@ -549,10 +549,11 @@ class Resolver {
             result.isBuiltin = true
             this.resolveType(element.items, file)
             //delete element.items
-        } else if (!result.isBuiltin && element?.elements && (options?.forceInlineStructs || !element?.type)) {
+        } else if (!result.isBuiltin && !isExternal(element) && element?.elements && (options?.forceInlineStructs || !element?.type)) {
             // explicitly skip named type definitions, which have elements too, but should not be considered inline declarations
             // if the resolver option `forceInlineStructs` is `true`, named types in elements will be converted to inline
             // Skipping isBuiltin will skip cds.Map, which has elements
+            // Skipping isExternal will skip @cds.external entities, which have elements as well
             this.#resolveInlineDeclarationType(element.elements, result, file, options)
         }
 

package/lib/typedefs.d.ts

@@ -189,6 +189,7 @@ export module config {
 
     export type Configuration = {
         outputDirectory: string,
+        outputDTsFiles: boolean,
         cache: 'none' | 'blake2s256'
         logLevel: number,
         /**

package/lib/visitor.js

@@ -95,11 +95,12 @@ class Visitor {
 
     /**
      * @param {EntityCSN} entity - the entity to print the actions for
+     * @param {string} clean - the clean entity name
      * @param {Buffer} buffer - the buffer to write the actions into
      * @param {import('./typedefs').resolver.EntityInfo[]} ancestors - the fully qualified names of the ancestors of the entity
      * @param {SourceFile} file - the file the entity is being printed into
      */
-    #printStaticActions(entity, buffer, ancestors, file) {
+    #printStaticActions(entity, clean, buffer, ancestors, file) {
         // TODO: refactor away! All these printing functionalities need to go
         const actions = Object.entries(entity.actions ?? {})
         const inherited = ancestors.map(a => `typeof ${asIdentifier({info: a, relative: file.path})}.actions`)
@@ -110,6 +111,7 @@ class Visitor {
                 () => {
                     for (const [aname, action] of actions) {
                         const [opener, content, closer] = SourceFile.stringifyLambda({
+                            self: clean,
                             name: aname,
                             parameters: this.#stringifyFunctionParams(action.params, file),
                             returns: action.returns
@@ -319,7 +321,7 @@ class Visitor {
                 }
                 this.#printStaticKeys(buffer, clean, ancestorInfos, file)
                 this.#printStaticElements(buffer, clean)
-                this.#printStaticActions(entity, buffer, ancestorInfos, file)
+                this.#printStaticActions(entity, clean, buffer, ancestorInfos, file)
             }, '};') // end of generated class
         }, '}') // end of aspect
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.36.0",
+  "version": "0.38.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",
@@ -45,7 +45,7 @@
   },
   "devDependencies": {
     "@cap-js/cds-types": "^0",
-    "@stylistic/eslint-plugin-js": "^4.2.0",
+    "@stylistic/eslint-plugin": "^5.3.1",
     "acorn": "^8.10.0",
     "eslint": "^9",
     "eslint-plugin-jsdoc": "^51.2.1",
@@ -54,6 +54,7 @@
   "cds": {
     "typer": {
       "output_directory": "@cds-models",
+      "output_d_ts_files": false,
       "inline_declarations": "flat",
       "target_module_type": "auto",
       "properties_optional": true,
@@ -84,6 +85,11 @@
               "description": "Root directory to write the generated files to.",
               "default": "@cds-models"
             },
+            "output_d_ts_files": {
+              "type": "boolean",
+              "description": "(experimental) If set to true, emits .d.ts files for each generated .js file. If set to false (default), emits .ts files instead. Note: skipLibCheck must be set to true in your tsconfig for this option to work properly.",
+              "default": false
+            },
             "log_level": {
               "type": "string",
               "description": "Minimum log level that is printed.\nThe default is only used if no explicit value is passed\nand there is no configuration passed via cds.env either.",