@cap-js/cds-types 0.1.0 → 0.2.0

package/apis/server.d.ts

@@ -1,143 +1,145 @@
-import { Service, ServiceImpl } from "./services"
-import { CSN } from "./csn"
-import * as http from "http"
+/* eslint-disable @typescript-eslint/ban-types */
+import { Service, ServiceImpl } from './services'
+import { CSN } from './csn'
+import * as http from 'http'
 import * as cds from './cds'
-import { Application } from "express"
+import { Application } from 'express'
 
 type _cds = typeof cds
 
-	export const connect: {
-		/**
+export const connect: {
+
+  /**
 		 * Connects to a specific datasource.
 		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
 		 */
-		to(datasource: string, options?: cds_connect_options): Promise<Service>
+  to(datasource: string, options?: cds_connect_options): Promise<Service>,
 
-		/**
+  /**
 		 * Connects to a specific datasource via options.
 		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
 		 */
-		to(options: cds_connect_options): Promise<Service>
+  to(options: cds_connect_options): Promise<Service>,
 
-		/**
+  /**
 		 * Connects the primary datasource.
 		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect)
 		 */
-                // API extractor cannot handle the direct usages of the cds namespace in typeof cds, so add an indirection.
-		(options?: string | cds_connect_options): Promise<_cds>  //> cds.connect(<options>)
-	}
+  // API extractor cannot handle the direct usages of the cds namespace in typeof cds, so add an indirection.
+  (options?: string | cds_connect_options): Promise<_cds>, // > cds.connect(<options>)
+}
 
-	/**
+/**
 	 * The default bootstrap function as loaded from server.js
 	 */
-	export const server: Function
+export const server: Function
 
-	/**
+/**
 	 * Constructs service providers from respective service definitions
 	 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-serve)
 	 */
-	export const serve: (service : string, options?: {
-		service?: string,
-		from?: '*' | 'all' | string,
-		[key: string]: unknown
-	}) => Promise<cds_services> & cds_serve_fluent
+export const serve: (service: string, options?: {
+  service?: string,
+  from?: '*' | 'all' | string,
+  [key: string]: any,
+}) => Promise<cds_services> & cds_serve_fluent
 
-	/**
+/**
 	 * Emitted whenever a model is loaded using cds.load().
 	 */
-	// FIXME: this is actually supposed to be part of models.d.ts
-	// but had to be moved here so export * would not clash their definitions
-	export function on (event : 'loaded', listener : (model : CSN) => void): _cds
+// FIXME: this is actually supposed to be part of models.d.ts
+// but had to be moved here so export * would not clash their definitions
+export function on (event: 'loaded', listener: (model: CSN) => void): _cds
 
-	/**
+/**
 	 * Emitted whenever a specific service is connected for the first time.
 	 */
-	export function on(event: 'connect', listener: (srv: Service) => void):  _cds
+export function on (event: 'connect', listener: (srv: Service) => void): _cds
 
 
-	/**
+/**
 	 * Emitted at the very beginning of the bootsrapping process, when the
 	 * express application has been constructed but no middlewares or routes
 	 * added yet.
 	 */
-	export function on (event : 'bootstrap', listener : (app : Application) => void) : _cds
-	export function once (event : 'bootstrap', listener : (app : Application) => void) :  _cds
+export function on (event: 'bootstrap', listener: (app: Application) => void): _cds
+export function once (event: 'bootstrap', listener: (app: Application) => void): _cds
 
-	/**
+/**
 	 * Emitted for each service served by cds.serve().
 	 */
-	export function on (event : 'serving', listener : (srv : Service) => void) :  _cds
+export function on (event: 'serving', listener: (srv: Service) => void): _cds
 
-	/**
+/**
 	 * Emitted by the default, built-in `server.js` when all services are
 	 * constructed and mounted by cds.serve().
 	 */
-	export function on   (event : 'served', listener : (all : cds_services) => void) :  _cds
-	export function once (event : 'served', listener : (all : cds_services) => void) :  _cds
+export function on (event: 'served', listener: (all: cds_services) => void): _cds
+export function once (event: 'served', listener: (all: cds_services) => void): _cds
 
-	/**
+/**
 	 * Emitted by the default, built-in `server.js` when the http server
 	 * is started and listening for incoming requests.
 	 */
-	export function on   (event : 'listening', listener : (args : { server: http.Server, url:string }) => void) :  _cds
-	export function once (event : 'listening', listener : (args : { server: http.Server, url:string }) => void) :  _cds
+export function on (event: 'listening', listener: (args: { server: http.Server, url: string }) => void): _cds
+export function once (event: 'listening', listener: (args: { server: http.Server, url: string }) => void): _cds
 
-	/**
+/**
 	 * Emitted by the default, built-in `server.js` when the http server
 	 * is shutdown.
 	 */
-	export function on (event : 'shutdown', listener : () => void) :  _cds
-	export function once (event : 'shutdown', listener : () => void) :  _cds
+export function on (event: 'shutdown', listener: () => void): _cds
+export function once (event: 'shutdown', listener: () => void): _cds
 
-	/**
+/**
 	 * Dictionary of all services constructed and/or connected.
 	 */
-	export const services : cds_services
+export const services: cds_services
 
-	/**
+/**
 	 * Shortcut to base class for all service definitions from linked models.
 	 * Plus accessors to impl functions and constructed providers.
 	 */
-	export const service : service
+export const service: service
 
-  /**
+/**
    * Provides a graceful shutdown for running servers, by first emitting `cds.emit('shutdown')`.
    * @see [capire](https://cap.cloud.sap/docs/node.js/cds-facade#cds-exit)
    */
-  export function exit(): void
-
+export function exit (): void
 
 
 export type service = {
-	/**
+
+  /**
 	 * Dummy wrapper for service implementation functions.
 	 * Use that in modules to get IntelliSense.
 	 */
-	impl (impl: ServiceImpl) : typeof impl
-	// impl <T> (srv:T, impl: (  _cds: T, srv: (T) ) => any) : typeof impl
+  impl (impl: ServiceImpl): typeof impl,
+  // impl <T> (srv:T, impl: (  _cds: T, srv: (T) ) => any) : typeof impl
 
-	/**
+  /**
 	 * Array of all services constructed.
 	 */
-	providers : Service[]
+  providers: Service[],
 }
 
 
-type cds_services = { [name:string]: Service }
+type cds_services = { [name: string]: Service }
 
 interface cds_serve_fluent {
-	from (model : string | CSN) :  cds_serve_fluent
-	to (protocol: string) :  cds_serve_fluent
-	at (path: string) :  cds_serve_fluent
-	in (app: Application) :  cds_serve_fluent
-	with (impl: ServiceImpl | string) :  cds_serve_fluent
-	// (req,res) : void
+  from (model: string | CSN): cds_serve_fluent
+  to (protocol: string): cds_serve_fluent
+  at (path: string): cds_serve_fluent
+  in (app: Application): cds_serve_fluent
+  with (impl: ServiceImpl | string): cds_serve_fluent
+  // (req,res) : void
 }
 
 interface cds_connect_options {
-	impl?: string,
-	service?: string,
-	kind?: string,
-	model?: string,
-	credentials?: object
+  impl?: string
+  service?: string
+  kind?: string
+  model?: string
+  credentials?: object
 }

package/apis/services.d.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-types */
 import { SELECT, INSERT, UPDATE, DELETE, Query, ConstructedQuery, UPSERT } from './ql'
 import { Awaitable } from './ql'
 import { ArrayConstructable, Constructable } from './internal/inference'
@@ -7,58 +8,59 @@ import { EventContext } from './events'
 import { Request } from './events'
 import { ReadableStream } from 'node:stream/web'
 
+type Key = number | string | any
 
 export class QueryAPI {
 
-  entities : LinkedCSN['entities']
+  entities: LinkedCSN['entities']
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   read: {
-    <T extends ArrayConstructable<any>>(entity: T, key?: any): Awaitable<SELECT<T>, InstanceType<T>>
-    <T>(entity: LinkedDefinition | string, key?: any): SELECT<T>
+    <T extends ArrayConstructable>(entity: T, key?: Key): Awaitable<SELECT<T>, InstanceType<T>>,
+    <T>(entity: LinkedDefinition | string, key?: Key): SELECT<T>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   create: {
-    <T extends ArrayConstructable<any>>(entity: T, key?: any): INSERT<T>
-    <T>(entity: LinkedDefinition | string, key?: any): INSERT<T>
+    <T extends ArrayConstructable>(entity: T, key?: Key): INSERT<T>,
+    <T>(entity: LinkedDefinition | string, key?: Key): INSERT<T>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   insert: {
-    <T extends ArrayConstructable<any>>(data: T): INSERT<T>
-    <T>(data: object | object[]): INSERT<T>
+    <T extends ArrayConstructable>(data: T): INSERT<T>,
+    <T>(data: object | object[]): INSERT<T>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   upsert: {
-    <T extends ArrayConstructable<any>>(data: T): UPSERT<T>
-    <T>(data: object | object[]): UPSERT<T>
+    <T extends ArrayConstructable>(data: T): UPSERT<T>,
+    <T>(data: object | object[]): UPSERT<T>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   update: {
-    <T extends ArrayConstructable<any>>(entity: T, key?: any): UPDATE<T>
-    <T>(entity: LinkedDefinition | string, key?: any): UPDATE<T>
+    <T extends ArrayConstructable>(entity: T, key?: Key): UPDATE<T>,
+    <T>(entity: LinkedDefinition | string, key?: Key): UPDATE<T>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
   run: {
-    (query: ConstructedQuery | ConstructedQuery[]): Promise<ResultSet | any>
-    (query: Query): Promise<ResultSet | any>
-    (query: string, args?: any[] | object): Promise<ResultSet | any>
+    (query: ConstructedQuery | ConstructedQuery[]): Promise<ResultSet | any>,
+    (query: Query): Promise<ResultSet | any>,
+    (query: string, args?: any[] | object): Promise<ResultSet | any>,
   }
 
   /**
@@ -67,27 +69,27 @@ export class QueryAPI {
   stream: {
     (column: string): {
       from(entity: LinkedDefinition | string): {
-        where(filter: any): ReadableStream
-      }
-    }
-    (query: Query): Promise<ReadableStream>
+        where(filter: any): ReadableStream,
+      },
+    },
+    (query: Query): Promise<ReadableStream>,
   }
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#crud-style-api)
    */
-  delete<T>(entity: LinkedDefinition | string, key?: any): DELETE<T>
+  delete<T>(entity: LinkedDefinition | string, key?: Key): DELETE<T>
 
   /**
    * @see [docs](https://cap.cloud.sap/docs/node.js/core-services#srv-foreach-entity)
    */
-  foreach(query: Query, callback: (row: object) => void): this
-
+  foreach (query: Query, callback: (row: object) => void): this
   transaction: {
-    (fn: (tx: Transaction) => {}): Promise<unknown>
-    (context?: object): Transaction
-    (context: object, fn: (tx: Transaction) => {}): Promise<unknown>
+    (fn: (tx: Transaction) => object): Promise<any>,
+    (context?: object): Transaction,
+    (context: object, fn: (tx: Transaction) => object): Promise<any>,
   }
+
 }
 
 
@@ -96,12 +98,13 @@ export class QueryAPI {
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
  */
 export class Service extends QueryAPI {
-  constructor(
+
+  constructor (
     name?: string,
     model?: CSN,
     options?: {
-      kind: string
-      impl: string | ServiceImpl
+      kind: string,
+      impl: string | ServiceImpl,
     }
   )
 
@@ -150,15 +153,15 @@ export class Service extends QueryAPI {
    * You may register own handlers before the base class’s ones, to intercept requests before the default handlers snap in.
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#srv-init)
    */
-  init(): Promise<void>
+  init (): Promise<void>
 
   /**
    * Constructs and emits an asynchronous event.
    * @see [capire docs](https://cap.cloud.sap/docs/core-services#srv-emit-event)
    */
   emit: {
-    <T = any>(details: { event: types.event; data?: object; headers?: object }): Promise<T>
-    <T = any>(event: types.event, data?: object, headers?: object): Promise<T>
+    <T = any>(details: { event: types.event, data?: object, headers?: object }): Promise<T>,
+    <T = any>(event: types.event, data?: object, headers?: object): Promise<T>,
   }
 
   /**
@@ -166,12 +169,12 @@ export class Service extends QueryAPI {
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#srv-send-request)
    */
   send: {
-    <T = any>(event: types.event, path: string, data?: object, headers?: object): Promise<T>
-    <T = any>(event: types.event, data?: object, headers?: object): Promise<T>
-    <T = any>(details: { event: types.event; data?: object; headers?: object }): Promise<T>
-    <T = any>(details: { query: ConstructedQuery; data?: object; headers?: object }): Promise<T>
-    <T = any>(details: { method: types.eventName; path: string; data?: object; headers?: object }): Promise<T>
-    <T = any>(details: { event: types.eventName; entity: LinkedDefinition | string; data?: object; params?: object }): Promise<T>
+    <T = any>(event: types.event, path: string, data?: object, headers?: object): Promise<T>,
+    <T = any>(event: types.event, data?: object, headers?: object): Promise<T>,
+    <T = any>(details: { event: types.event, data?: object, headers?: object }): Promise<T>,
+    <T = any>(details: { query: ConstructedQuery, data?: object, headers?: object }): Promise<T>,
+    <T = any>(details: { method: types.eventName, path: string, data?: object, headers?: object }): Promise<T>,
+    <T = any>(details: { event: types.eventName, entity: LinkedDefinition | string, data?: object, params?: object, headers?: object }): Promise<T>,
   }
 
   /**
@@ -179,43 +182,54 @@ export class Service extends QueryAPI {
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
    */
   get<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
   /**
    * Constructs and sends a POST request.
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
    */
   post<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
   /**
    * Constructs and sends a PUT request.
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
    */
   put<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
   /**
    * Constructs and sends a PATCH request.
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services#rest-style-api)
    */
   patch<T = any>(entityOrPath: types.target, data?: object): Promise<T>
+
   /**
    * Constructs and sends a DELETE request.
    */
   delete: {
-    <T = any>(entityOrPath: types.target, data?: object): DELETE<T>
-    <T extends ArrayConstructable<any>>(entity: T, key?: any): DELETE<T>
-    <T>(entity: LinkedDefinition | string, key?: any): DELETE<T>
+    <T = any>(entityOrPath: types.target, data?: object): DELETE<T>,
+    <T extends ArrayConstructable>(entity: T, key?: Key): DELETE<T>,
+    <T>(entity: LinkedDefinition | string, key?: Key): DELETE<T>,
   }
 
   // The central method to dispatch events
-  dispatch(msg: types.event): Promise<any>
+  dispatch (msg: types.event): Promise<any>
 
   // FIXME: not yet documented, will come in future version
-  //disconnect (tenant?: string): Promise<void>
+  // disconnect (tenant?: string): Promise<void>
 
   // Provider API
-  prepend(fn: ServiceImpl): Promise<this>
+  prepend (fn: ServiceImpl): Promise<this>
+
   on<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.On<InstanceType<T>, InstanceType<T> | void | Error>): this
+
   on<F extends CdsFunction>(boundAction: F, service: string, handler: ActionEventHandler<F['__parameters'], void | Error | F['__returns']>): this
+
   on<F extends CdsFunction>(unboundAction: F, handler: ActionEventHandler<F['__parameters'], void | Error | F['__returns']>): this
-  on(eve: types.event, entity: types.target, handler: OnEventHandler): this
-  on(eve: types.event, handler: OnEventHandler): this
+
+  on (eve: types.event, entity: types.target, handler: OnEventHandler): this
+
+  on (eve: types.event, handler: OnEventHandler): this
+
+  on (eve: 'error', handler: OnErrorHandler): this
 
 
   // onSucceeded (eve: types.Events, entity: types.Target, handler: types.EventHandler): this
@@ -223,26 +237,40 @@ export class Service extends QueryAPI {
   // onFailed (eve: types.Events, entity: types.Target, handler: types.EventHandler): this
   // onFailed (eve: types.Events, handler: types.EventHandler): this
   before<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.Before<InstanceType<T>, InstanceType<T> | void | Error>): this
-  before(eve: types.event, entity: types.target, handler: EventHandler): this
-  before(eve: types.event, handler: EventHandler): this
+
+  before (eve: types.event, entity: types.target, handler: EventHandler): this
+
+  before (eve: types.event, handler: EventHandler): this
+
   after<T extends Constructable>(eve: types.event, entity: T, handler: CRUDEventHandler.After<InstanceType<T>, InstanceType<T> | void | Error>): this
-  after(eve: types.event, entity: types.target, handler: ResultsHandler): this
-  after(eve: types.event, handler: ResultsHandler): this
-  reject(eves: types.event, ...entity: types.target[]): this
+
+  after (eve: types.event, entity: types.target, handler: ResultsHandler): this
+
+  after (eve: types.event, handler: ResultsHandler): this
+
+  reject (eves: types.event, ...entity: types.target[]): this
+
 }
 
 export class ApplicationService extends Service {}
 export class MessagingService extends Service {}
 export class RemoteService extends Service {}
 export class DatabaseService extends Service {
-  deploy(model?: CSN | string): Promise<CSN>
-  begin(): Promise<void>
-  commit(): Promise<void>
-  rollback(): Promise<void>
+
+  deploy (model?: CSN | string): Promise<CSN>
+
+  begin (): Promise<void>
+
+  commit (): Promise<void>
+
+  rollback (): Promise<void>
+
 }
 
 
 export default class cds {
+
+
   /**
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/core-services)
    */
@@ -267,6 +295,7 @@ export default class cds {
    * @see [capire docs](https://cap.cloud.sap/docs/node.js/databases)
    */
   DatabaseService: typeof DatabaseService
+
 }
 
 
@@ -275,7 +304,7 @@ export interface Transaction extends Service {
   rollback(): Promise<void>
 }
 
-interface ResultSet extends Array<{}> {}
+interface ResultSet extends Array<object> {}
 
 interface ServiceImpl {
   (this: Service, srv: Service): any
@@ -290,6 +319,10 @@ interface OnEventHandler {
   (req: Request, next: Function): Promise<any> | any | void
 }
 
+interface OnErrorHandler {
+  (err: Error, req: Request): any | void
+}
+
 // `Partial` wraps any type and allows all properties to be undefined
 // in addition to their actual type.
 // This is important in the context of CRUD events, where
@@ -300,7 +333,7 @@ type Partial<T> = { [Key in keyof T]: undefined | T[Key] }
 // Naming the first parameter in a handler `each` has special voodoo
 // semantic which makes it impossible for us to infer the exact behaviour on a type level.
 // So we always have to expect scalars as well as arrays in some callbacks.
-type OneOrMany<T> = T | T[];
+type OneOrMany<T> = T | T[]
 
 // functions generated by cds-typer explicitly carry types for
 // parameters and return type, as their names are not accessible from
@@ -309,23 +342,23 @@ type OneOrMany<T> = T | T[];
 type CdsFunction = {
   (...args: any[]): any,
   __parameters: object,
-  __returns: unknown
+  __returns: any,
 }
 
 type TypedRequest<T> = Omit<Request, 'data'> & { data: T }
 
 // https://cap.cloud.sap/docs/node.js/core-services#srv-on-before-after
 declare namespace CRUDEventHandler {
-  type Before<P,R> = (req: TypedRequest<P>) => Promise<R> | R
-  type On<P,R> = (req: TypedRequest<P>, next: (...args: any) => Promise<R> | R) => Promise<R> | R
-  type After<P,R> = (data: undefined | P, req: TypedRequest<P>) => Promise<R> | R
+  type Before<P, R> = (req: TypedRequest<P>) => Promise<R> | R
+  type On<P, R> = (req: TypedRequest<P>, next: (...args: any[]) => Promise<R> | R) => Promise<R> | R
+  type After<P, R> = (data: undefined | P, req: TypedRequest<P>) => Promise<R> | R
 }
 
 // Handlers for actions try to infer the passed .data property
 // as strictly as possible and therefore have to remove
 // { data: any } (inherited EventMessage} with a more restricted
 // type, based on the parameters of the action.
-interface ActionEventHandler<P,R> {
+interface ActionEventHandler<P, R> {
   (req: Omit<Request, 'data'> & { data: P }, next: Function): Promise<R> | R
 }
 
@@ -342,36 +375,38 @@ interface ResultsHandler {
 }
 
 interface SpawnEvents {
-  'succeeded': (res: any) => void
-  'failed': (error: any) => void
-  'done': () => void
+  succeeded: (res: any) => void
+  failed: (error: any) => void
+  done: () => void
 }
 
 declare class SpawnEventEmitter {
+
   on<U extends keyof SpawnEvents>(
     event: U, listener: SpawnEvents[U]
-  ): this;
+  ): this
 
   emit<U extends keyof SpawnEvents>(
     event: U, ...args: Parameters<SpawnEvents[U]>
-  ): boolean;
+  ): boolean
   timer: any
+
 }
 
 declare namespace types {
   type event = eventName | eventName[]
-  type eventName = (string & {})
+  type eventName = string
     | 'CREATE' | 'READ' | 'UPDATE' | 'DELETE'
     | 'NEW' | 'EDIT' | 'PATCH' | 'SAVE'
     | 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE'
     | 'COMMIT' | 'ROLLBACK'
-  type target = string | LinkedDefinition | LinkedEntity | (string | LinkedDefinition | LinkedEntity)[] | ArrayConstructable<any>
+  type target = string | LinkedDefinition | LinkedEntity | (string | LinkedDefinition | LinkedEntity)[] | ArrayConstructable
 }
 
 type SpawnOptions = {
-  [key: string]: any
-  every?: number
-  after?: number
+  [key: string]: any,
+  every?: number,
+  after?: number,
 }
 
 // FIXME: this was ?: EventContext before. Is context supposed to not be present sometimes?
@@ -384,7 +419,7 @@ export let context: EventContext | undefined
 /**
 * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx#cds-spawn)
 */
-export function spawn(options: SpawnOptions, fn: (tx: Transaction) => {}): SpawnEventEmitter
+export function spawn (options: SpawnOptions, fn: (tx: Transaction) => object): SpawnEventEmitter
 
 
 // facade proxies into cds.db, which is a Service
@@ -393,9 +428,9 @@ export function spawn(options: SpawnOptions, fn: (tx: Transaction) => {}): Spawn
 * @see [docs](https://cap.cloud.sap/docs/node.js/cds-tx)
 */
 export const tx: {
-  (fn: (tx: Transaction) => {}): Promise<unknown>
-  (context?: object): Transaction
-  (context: object, fn: (tx: Transaction) => {}): Promise<unknown>
+  (fn: (tx: Transaction) => object): Promise<any>,
+  (context?: object): Transaction,
+  (context: object, fn: (tx: Transaction) => object): Promise<any>,
 }
 export const entities: Service['entities']
 export const run: Service['run']
@@ -408,7 +443,7 @@ export const update: Service['update']
 // temporarily moved to cds.d.ts, as "delete" is a reserved keyword
 // export const delete: Service['delete']
 // FIXME: see Service.disconnect comment
-//export const disconnect: Service['disconnect']
+// export const disconnect: Service['disconnect']
 export const transaction: Service['transaction']
 export const db: DatabaseService
-//export const upsert: Service['upsert']
+// export const upsert: Service['upsert']