@sap/cds-dk 10.1.2 → 10.2.0

package/node_modules/@sap/cds/lib/env/cds-requires/messaging.js

@@ -0,0 +1,82 @@
+const _runtime = '@sap/cds/libx/_runtime'
+
+module.exports = {
+
+  "messaging-defaults": {
+    "[development]": { kind: "file-based-messaging" },
+    "[production]": { kind: "enterprise-messaging" },
+    "[hybrid]": { kind: "enterprise-messaging-amqp" },
+  },
+
+  "default-messaging": {
+    "[development]": { kind: "local-messaging" },
+    "[hybrid]": { kind: "enterprise-messaging-amqp" },
+    "[production]": {
+      kind: "enterprise-messaging-amqp",
+      "[multitenant]": { kind: "enterprise-messaging-http" }
+    }
+  },
+
+  "local-messaging": {
+    impl: `${_runtime}/messaging/service.js`,
+    local: true
+  },
+  "file-based-messaging": {
+    impl: `${_runtime}/messaging/file-based.js`,
+    file:'~/.cds-msg-box',
+    outboxed: true
+  },
+
+  "event-mesh": {
+    kind: "enterprise-messaging-http",
+    vcap: { label: "event-mesh-message-client" },
+    managementBasePath: "/sap-event-mesh/rest/api/v1",
+  },
+  "event-mesh-shared": {
+    kind: "enterprise-messaging-amqp",
+    vcap: { label: "event-mesh-message-client" },
+    managementBasePath: "/sap-event-mesh/rest/api/v1",
+  },
+  "enterprise-messaging": {
+    kind: "enterprise-messaging-http",
+  },
+  "enterprise-messaging-shared": {
+    kind: "enterprise-messaging-amqp",
+  },
+  "enterprise-messaging-http": {
+    deployForProvider: true,
+    impl: `${_runtime}/messaging/enterprise-messaging.js`,
+    vcap: { label: "enterprise-messaging" },
+    outboxed: true
+  },
+  "enterprise-messaging-amqp": {
+    impl: `${_runtime}/messaging/enterprise-messaging-shared.js`,
+    vcap: { label: "enterprise-messaging" },
+    outboxed: true
+  },
+  'message-queuing': {
+    impl: `${_runtime}/messaging/message-queuing.js`,
+    outboxed: true
+  },
+  'kafka': {
+    impl: `${_runtime}/messaging/kafka.js`,
+    topic: 'cds.default',
+    outboxed: true,
+    local: false
+  },
+  "composite-messaging": {
+    impl: `${_runtime}/messaging/composite.js`
+  },
+  "mtx-messaging": {
+    kind: "local-messaging",
+    "[production]": {
+      kind: "redis-messaging"
+    }
+  },
+  "redis-messaging": {
+    impl: `${_runtime}/messaging/redis-messaging.js`,
+    vcap: { label: "redis-cache" },
+    outboxed: true
+  }
+
+}

package/node_modules/@sap/cds/lib/env/cds-requires/platform.js

@@ -0,0 +1,23 @@
+module.exports = {
+
+  ucl: {
+    model: '@sap/cds/srv/ucl-service.cds'
+    // REVISIT: how to configure such that a cds.connect.to('ucl') returns the already initialized UCLService?
+    // service: 'UCLService',
+    // impl: `${_runtime}/ucl/Service.js`,
+  },
+
+  destinations: {
+    vcap: {
+      label: 'destination'
+    }
+  },
+  connectivity: {
+    vcap: {
+      label: 'connectivity'
+    }
+  },
+
+  approuter: undefined,
+
+}

package/node_modules/@sap/cds/lib/env/cds-requires/queues.js

@@ -0,0 +1,34 @@
+module.exports = {
+
+  queue: "persistent-queue",
+
+  scheduling: {
+    impl: '@sap/cds/libx/queue/SchedulingService.js',
+    queued: true,
+    // internal!
+    silent: true,
+    markerInterval: '1h',
+    flushInterval: '1h',
+    _optimisticMarkers: true,
+  },
+
+  "in-memory-queue": {},
+
+  "persistent-queue": {
+    model: "@sap/cds/srv/outbox",
+    maxAttempts: 10,
+    timeout: '1h',
+    // deprecated!
+    legacyLocking: false,
+    // internal!
+    chunkSize: 10,
+    parallel: true,
+    // REVISIT: streamline context to serialize with Java and remove this
+    _ignoredContext: ['user', 'http', 'model', 'timestamp', '_locale', '_features']
+  },
+
+  // legacy
+  "in-memory-outbox": "in-memory-queue",
+  "persistent-outbox": "persistent-queue",
+
+}

package/node_modules/@sap/cds/lib/env/cds-requires/services.js

@@ -0,0 +1,32 @@
+module.exports = {
+
+  "app-service": {
+    // this is the default implementation used for provided services
+    impl: `@sap/cds/srv/app-service.js`,
+  },
+  "rest": {
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+  "hcql": {
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+  "odata": {
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+  "odata-v2": { // REVISIT: we should introduce .version
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+  "odata-v4": { // REVISIT: we should introduce .version
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+  "graphql": { // REVISIT: we should introduce .version
+    impl: `@sap/cds/srv/remote-service.js`,
+    external: true
+  },
+
+}

package/node_modules/@sap/cds/lib/env/defaults.js

@@ -26,7 +26,10 @@ module.exports = exports = {
     'odata-v4' : { path: '/odata/v4' },
     'odata-v2' : { path: '/odata/v2' },
     'rest' : { path: '/rest' },
-    'hcql' : { path: '/hcql' },
+    'hcql' : { path: '/hcql', allows: {
+      UPDATE: { many: false },
+      DELETE: { many: false },
+    }},
     'data.product' : null, // data products are not http-served protocols
   },
 
@@ -57,6 +60,7 @@ module.exports = exports = {
     annotate_for_flows: true,
     history_for_flows: true,
     compile_for_assert: undefined,
+    cap_yaml: false
   },
 
   fiori: {
@@ -69,9 +73,13 @@ module.exports = exports = {
     draft_messages: true,
     draft_new_action: false,
     bypass_draft: true,
+    draft_admin_integrity: false,
+    draft_orphan_cleanup: false,
   },
 
   ql: {
+    /** @type {'cds-compiler'|'cap.core'|'compatible'} */
+    parser: process.env.JEST_WORKER_ID ? 'cds-compiler' : 'compatible'
   },
 
   log: {

package/node_modules/@sap/cds/lib/i18n/files.js

@@ -34,9 +34,9 @@ class I18nFiles {
     if (basename === 'messages') _add_entries4 (path.resolve (__dirname,'../../_i18n'))
 
     // fetch relatively specified i18n.folders in the neighborhood of sources...
-    const relative_folders = folders.filter (f => f[0] !== '/')
+    const relative_folders = folders.filter (f => !path.isAbsolute(f))
     if (relative_folders.length) {
-      const outbox_cds = cds.env.requires.queue?.model // ignore outbox.cds if present in model.$sources
+      const outbox_cds = cds.requires.queue?.model // ignore outbox.cds if present in model.$sources
       const leafs = model?.$sources.filter(f => !f.startsWith(outbox_cds)).map(path.dirname) ?? roots, visited = {}
       ;[...new Set(leafs)].reverse() .forEach (function _visit (dir) {
         if (dir in visited) return; else visited[dir] = true
@@ -52,8 +52,8 @@ class I18nFiles {
       })
     }
 
-    // fetch fully specified i18n.folders, i.e., those starting with /
-    const specific_folders = folders.filter (f => f[0] === '/')
+    // fetch fully specified i18n.folders, i.e., absolute paths
+    const specific_folders = folders.filter (f => path.isAbsolute(f))
     for (const f of specific_folders) {
       const _exists = _folders[f] ??= exists(f)
       _add_entries4 (_exists ? f : path.join(cds.root,f))

package/node_modules/@sap/cds/lib/i18n/locale.js

@@ -13,7 +13,7 @@ function normalized_locale_from (req) {
   const locale = header .match (/^[^,; ]*/)[0] .replace (/-/g,'_')
   return req.locale = COMMON[locale]
   || locale.match(/[A-Za-z]+/)?.[0].toLowerCase()
-  || i18n.default_language // wildcard or invalid header, fall back to default
+  || _default // wildcard or invalid header, fall back to default
 }
 
 function raw_locale_from (req) {

package/node_modules/@sap/cds/lib/index.js

@@ -15,12 +15,16 @@ const cds = exports = module.exports = global.cds = new class cds extends EventE
   }
   get spawn() { return super.spawn = require('./req/spawn.js') }
 
+  /** CLI args */ cli = { command:'', options:{}, argv:[] }
   /** @import {LinkedCSN} from './core/linked-csn.js' */
   /** @import {Service} from './srv/cds.Service.js' */
-  /** @type LinkedCSN */ model = undefined
+  /** @type { Record<string,Service> } */ services = new class {
+    *[Symbol.iterator](){ for (let e in this) yield this[e] }
+  }
   /** @type Service */ db = undefined
-  /** CLI args */ cli = { command:'', options:{}, argv:[] }
+  /** @type LinkedCSN */ model = undefined
   /** Working dir */ root = process.cwd()
+  /** My home dir */ home = __dirname.slice(0,-4)
 
   emit (eve, ...args) {
     if (eve === 'served') return this.listeners(eve) .reduce (
@@ -31,11 +35,10 @@ const cds = exports = module.exports = global.cds = new class cds extends EventE
   }
 
   // Configuration & Information
-  get requires() { return super.requires = this.env.requires._resolved() }
+  get env()      { let e = super.env = require('./env/cds-env.js').for(this); this.emit('env',e); return e }
+  get requires() { return this.env.requires }
   get plugins()  { return super.plugins = require('./plugins.js').activate() }
   get version()  { return super.version = require('../package.json').version }
-  get env()      { return super.env = require('./env/cds-env.js').for(this) }
-  get home()     { return super.home = __dirname.slice(0,-4) }
   get schema()   { return super.schema = require('./env/schemas/index.js') } // REVISIT: Better move that to cds-dk?
 
   // Loading and Compiling Models
@@ -69,9 +72,6 @@ const cds = exports = module.exports = global.cds = new class cds extends EventE
   })}
 
   // Providing and Consuming Services
-  /** @type { Record<string,Service> } */ services = new class {
-    *[Symbol.iterator](){ for (let e in this) yield this[e] }
-  }
   get server() { return super.server = require('../server.js') }
   get serve() { return super.serve = require('./srv/cds-serve.js') }
   get connect() { return super.connect = require('./srv/cds-connect.js') }
@@ -153,4 +153,4 @@ function G (p,v) { Object.defineProperty (global, p, { value:v, enumerable:1,con
 Object.defineProperties (exports, { default: {value:cds}, __esModule: {value:true} })
 
 // track from where we loaded cds, lowercase to avoid path duplicates on Windows
-!(global.__cds_loaded_from ??= new Set).add(cds.home.toLowerCase()) 
+!(global.__cds_loaded_from ??= new Set).add(cds.home.toLowerCase())

package/node_modules/@sap/cds/lib/log/cds-log.js

@@ -162,10 +162,10 @@ const { ERROR, WARN, INFO, DEBUG, TRACE } = exports.levels = {
   SILENT:0, ERROR:1, WARN:2, INFO:3, DEBUG:4, TRACE:5, SILLY:5, VERBOSE:5
 }
 
-function applyLogConfig() {
+function applyLogConfig (env = cds.env) {
   let { loggers, format } = exports, fmt = format
   let { plain } = log.formatters
-  conf = cds.env.log
+  conf = env.log
 
   // Update log levels for already existing loggers
   if (conf.levels) {
@@ -178,7 +178,7 @@ function applyLogConfig() {
   }
 
   // Include tenant in plain log output if multitenancy is enabled
-  if (fmt === plain && cds.env.requires.multitenancy) {
+  if (fmt === plain && cds.requires.multitenancy) {
     fmt = exports.format = (label, level, ...args) => {
       const t = cds.context?.tenant; if (t) label += '|'+t
       return plain (label, level, ...args)

package/node_modules/@sap/cds/lib/ql/SELECT.js

@@ -31,11 +31,13 @@ class SELECT extends Whereable {
       from:       (..._) => (new this).one.from(..._),
     }),
     read:         (..._) => (new this)._select_or_from(..._),
+    stream:       (..._) => (new this).streamed._select_or_from(..._),
     class: this
   }
 
   get localized() { this.SELECT.localized = true; return this }
   get distinct() { this.SELECT.distinct = true; return this }
+  get streamed() { this.SELECT.stream = true; return this }
   get one() { this.SELECT.one = true; return this }
 
   /** @private */ _select_or_from (x,...etc) {

package/node_modules/@sap/cds/lib/ql/UPDATE.js

@@ -107,5 +107,5 @@ const _parse_set_expr = (q,expr) => {
 const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }
 
 
-/** @type UPDATE.API & (...entries:[]) => UPDATE */
+/** @type UPDATE.API & (entity : string | object, pk?: any) => UPDATE */
 module.exports = UPDATE.init()

package/node_modules/@sap/cds/lib/ql/cds.ql-Query.js

@@ -54,7 +54,10 @@ class Query {
     return Object.defineProperty (this,'_srv',{ value:srv, configurable:true, writable:true })
   }
 
-  /** Turns all queries into Thenables which execute with primary db by default */
+  /**
+   * Turns all queries into Thenables which execute with primary db by default
+   * @returns {(r:(x:any) => any, e?:any) => PromiseLike}
+   */
   get then() {
     const srv = this._srv || cds.db || cds.error `Can't execute query as no primary database is connected.`
     const q = new AsyncResource('await cds.query')

package/node_modules/@sap/cds/lib/ql/core/@types/cqn.d.ts

@@ -0,0 +1,146 @@
+/**
+ * `INSERT` and `UPSERT` queries are represented by the same internal
+ * structures. The `UPSERT` keyword is used to indicate that the
+ * statement should be updated if the targeted data exists.
+ * The `into` property specifies the target entity.
+ *
+ * The data to be inserted or updated can be specified in different ways:
+ *
+ * - in the `entries` property as deeply nested records.
+ * - in the `columns` and `values` properties as in SQL.
+ * - in the `columns` and `rows` properties, with `rows` being array of `values`.
+ * - in the `from` property with a `SELECT` query to provide the data to be inserted.
+ *
+ * The latter is the equivalent of SQL's `INSERT INTO ... SELECT ...` statements.
+ */
+export class INSERT { INSERT: UPSERT['UPSERT'] }
+export class UPSERT { UPSERT: {
+  into      : ref
+  entries?  : data[]
+  columns?  : string[]
+  values?   : scalar[]
+  rows?     : scalar[][]
+  from?     : SELECT
+}}
+
+
+/**
+ * `UPDATE` queries are used to capture modifications to existing data.
+ * They support a `where` clause to specify the rows to be updated,
+ * and a `with` clause to specify the new values. Alternatively, the
+ * `data` property can be used to specify updates with plain data only.
+ */
+export class UPDATE { UPDATE: {
+  entity  : ref
+  where?  : expr
+  data    : data
+  with    : changes
+}}
+
+
+/**
+ * `DELETE` queries are used to remove data from a target datasource.
+ * They support a `where` clause to specify the rows to be deleted.
+ */
+export class DELETE { DELETE: {
+  from    : ref
+  where?  : expr
+}}
+
+
+/**
+ * `SELECT` queries are used to retrieve data from a target datasource,
+ * and very much resemble SQL's `SELECT` statements, with these noteworthy
+ * additions:
+ *
+ * - The `from` clause supports `{ref}` paths with infix filters.
+ * - The `columns` clause supports deeply nested projections.
+ * - The `count` property requests the total count, similar to OData's `$count`.
+ * - The `one` property indicates that only a single record object shall be
+ *   returned instead of an array.
+ *
+ * Also, CDS, and hence CQN, supports minimalistic `SELECT` statements with a `from`
+ * as the only mandatory property, which is equivalent to SQL's `SELECT * from ...`.
+ */
+export class SELECT { SELECT: {
+  distinct?   : true
+  count?      : true
+  one?        : true
+  from        : source
+  columns?    : column[]
+  where?      : xo[]
+  having?     : xo[]
+  groupBy?    : expr[]
+  orderBy?    : order[]
+  limit?      : { rows: val, offset: val }
+}}
+
+type source = OneOf< ref &as | SELECT | {
+  join : 'inner' | 'left' | 'right'
+  args : [ source, source ]
+  on?  : expr
+}>
+
+type column = OneOf< '*' | expr &as &cast | ref &as & OneOf<(
+  { expand?: column[] } |
+  { inline?: column[] }
+)> &infix >
+
+type order = expr & {
+  sort  : 'asc' | 'desc'
+  nulls : 'first' | 'last'
+}
+
+
+interface changes { [elm:string]: OneOf< scalar | expr | changes | changes[] >}
+interface data { [elm:string]: OneOf< scalar | data | data[] >}
+interface as { as?: name }
+interface cast { cast?: {type:name} }
+
+interface infix {
+  orderBy?  : order[]
+  where?    : expr
+  limit?    : { rows: val, offset: val }
+}
+
+
+/**
+ * Expressions can be entity or element references, query parameters,
+ * literal values, lists of all the former, function calls, sub selects,
+ * or compound expressions.
+ */
+export type expr  = OneOf< ref | val | xpr | list | func | param | SELECT >
+export type ref   = { ref: OneOf< name | { id:name } &infix >[] }
+export type val   = { val: string | number | boolean | null }
+export type xpr   = { xpr: xo[] }
+export type list  = { list: expr[] }
+export type func  = { func: string, args: expr[] }
+export type param = { ref: [ '?' | number | string ], param: true }
+
+/**
+ * This is used in `{xpr}` objects as well as in `SELECT.where` clauses to
+ * represent compound expressions as flat `xo` sequences.
+ * Note that CQN by intent does not _understand_ expressions and therefore
+ * keywords and operators are just represented as plain strings.
+ * This allows us to translate to and from any other query languages,
+ * including support for native SQL features.
+ */
+export type xo = OneOf< expr | keyword | operator >
+export type operator = '=' | '==' | '!=' | '<' | '<=' | '>' | '>='
+export type keyword  = 'in' | 'like' | 'and' | 'or' | 'not'
+export type scalar   = number | string | boolean | null
+export type name     = string
+
+
+
+// ---------------------------------------------------------------------------
+//  maybe coming later...
+
+declare class CREATE { CREATE: {} }
+declare class DROP { DROP: {} }
+
+
+// ---------------------------------------------------------------------------
+//  internal helpers...
+
+type OneOf<U> = Partial<(U extends any ? (k:U) => void : never) extends (k: infer I) => void ? I : never>

package/node_modules/@sap/cds/lib/ql/core/@types/exprs.d.ts

@@ -0,0 +1,51 @@
+import * as cqn from './cqn'
+
+type ttl = TemplateStringsArray
+type scalar = cqn.scalar
+type path = string
+
+/**
+ * Constructs a `{val}` CQN object. The argument can be either a template string
+ * with interpolations of strings, numbers, booleans, null, or a simple scalar value.
+ */
+export function val (strings: ttl) : cqn.val
+export function val <T extends scalar> (val: T) : { val: T }
+
+/**
+ * Constructs a `{ref}` CQN object. The argument can be either a template string which
+ * can contain complex path expressions, including infix filters, function calls,
+ * or a string which will be split into path segments.
+ */
+export function ref (strings: ttl) : cqn.ref
+export function ref (path: path) : cqn.ref
+
+/**
+ * Contstructs a `{xpr}`, `{ref}`, `{val}`, `{func}`, or `{list}` CQN object.
+ * The argument can be either a template string which can contain complex expressions
+ * with operators, function calls, or a simple value or an array of simple values.
+ */
+export function expr (ttl: ttl) : cqn.expr
+export function expr <T extends scalar> (val: T) : { val: T }
+export function expr (vals: scalar[] ) : cqn.list
+
+export function subject(): cqn.ref
+export function columns() : cqn.column[]
+export function values(): cqn.val[]
+export function where() : cqn.xo[]
+export function having() : cqn.xo[]
+export function groupBy() : cqn.column[]
+export function orderBy() : cqn.order[]
+
+
+export interface fluent {
+  val : typeof val
+  ref : typeof ref
+  expr : typeof expr
+  subject : typeof subject
+  columns : typeof columns
+  values : typeof values
+  where : typeof where
+  having : typeof having
+  groupBy : typeof groupBy
+  orderBy : typeof orderBy
+}

package/node_modules/@sap/cds/lib/ql/core/@types/index.d.ts

@@ -0,0 +1,29 @@
+import { Query } from './query.js'
+import { SELECT as SELECT_ } from './ql/select.js'
+import { INSERT as INSERT_ } from './ql/insert.js'
+import { UPSERT as UPSERT_ } from './ql/insert.js'
+import { UPDATE as UPDATE_ } from './ql/update.js'
+import { DELETE as DELETE_ } from './ql/delete.js'
+
+/**
+ * This is the central entry point for creating queries from various types of input:
+ * - If the input is a `Query` instance already, it's returned as-is.
+ * - If the input is a `string` or a template literal, it's parsed into a CQN object.
+ * - If the input is an `object` with a recognized query kind, it's cast into an instance of
+ *   the corresponding query class.
+ * @param { Query | string | object } qso - The input, as described above, to be converted into an instance of a Query subclass.
+ * @param { ...any } args - Optional arguments for template literals or parameterized queries.
+ * @returns { SELECT & INSERT & UPSERT & UPDATE & DELETE }
+ */
+export function cql (
+  qso: Query | string | object, ...args: any[]
+): SELECT_ & INSERT_ & UPSERT_ & UPDATE_ & DELETE_
+
+export * from './exprs'
+export { Query }
+export const SELECT: (() => typeof SELECT_) & typeof SELECT_
+export const INSERT: (() => typeof INSERT_) & typeof INSERT_
+export const UPSERT: (() => typeof UPSERT_) & typeof UPSERT_
+export const UPDATE: (() => typeof UPDATE_) & typeof UPDATE_
+export const DELETE: (() => typeof DELETE_) & typeof DELETE_
+export default cql

package/node_modules/@sap/cds/lib/ql/core/@types/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@types/cap.core__ql",
+  "version": "1.2.3",
+  "description": "Type declarations for @cap.core/ql",
+  "author": "daniel.hutzel@sap.com",
+  "license": "Apache-2.0"
+}

package/node_modules/@sap/cds/lib/ql/core/@types/ql/delete.d.ts

@@ -0,0 +1,8 @@
+import { Query } from '../query.js';
+import * as cqn from '../cqn'
+
+export class DELETE extends Query {
+  static from(...args: any[]): DELETE;
+  DELETE: cqn.DELETE;
+  where(...args: any[]): this;
+}

package/node_modules/@sap/cds/lib/ql/core/@types/ql/insert.d.ts

@@ -0,0 +1,19 @@
+import { Query } from '../query.js';
+import * as cqn from '../cqn'
+
+export class XSERT extends Query {
+  static entries(...args: any[]): XSERT;
+  static into(x: any, ...tail: any[]): XSERT;
+  into(...args: any[]): this;
+  entries(...args: any[]): this;
+  columns(...args: any[]): this;
+  values(...args: any[]): this;
+  rows(...args: any[]): this;
+  from(...args: any[]): this;
+}
+export class INSERT extends XSERT {
+  INSERT: cqn.INSERT;
+}
+export class UPSERT extends XSERT {
+  UPSERT: cqn.UPSERT;
+}

package/node_modules/@sap/cds/lib/ql/core/@types/ql/select.d.ts

@@ -0,0 +1,24 @@
+import { Query } from '../query.js';
+import * as cqn from '../cqn'
+
+export class SELECT extends Query {
+  static from(...args: any[]): SELECT;
+  static columns(...args: any[]): SELECT;
+  static get localized(): SELECT;
+  static get distinct(): SELECT;
+  static get one(): SELECT;
+  SELECT: cqn.SELECT;
+  get localized(): this;
+  get distinct(): this;
+  get one(): this;
+  columns(...args: any[]): this;
+  from(...args: any[]): this;
+  where(...args: any[]): this;
+  having(...args: any[]): this;
+  groupBy(...args: any[]): this;
+  orderBy(...args: any[]): this;
+  limit(...args: any[]): this;
+  top(...args: any[]): this;
+  skip(...args: any[]): this;
+  offset(...args: any[]): this;
+}

package/node_modules/@sap/cds/lib/ql/core/@types/ql/update.d.ts

@@ -0,0 +1,10 @@
+import { Query } from '../query.js';
+import * as cqn from '../cqn'
+
+export class UPDATE extends Query {
+  static entity(...args: any[]): UPDATE;
+  UPDATE: cqn.UPDATE;
+  where(...args: any[]): this;
+  with(data: any, x: any): this;
+  set(data: any, x: any): this;
+}

package/node_modules/@sap/cds/lib/ql/core/@types/query.d.ts

@@ -0,0 +1,18 @@
+import * as cqn from './cqn'
+
+export class Query {
+  /**
+  * - Fills in any binding `{param}`s with corresponding `{val}`s from given `args`.
+  * - If no `args` are provided, the ones collected during parsing are used.
+  */
+  bind(...args: any[]): this;
+
+  /**
+  * Returns the main subject `{ref}` of the query, which refers to the entity being queried or modified.
+  * - For `SELECT` and `DELETE` queries, this is the `from` clause.
+  * - For `INSERT` and `UPSERT` queries, this is the `into` clause.
+  * - For `UPDATE` queries, this is the `entity` clause.
+  * @returns {ref:string[]} The main subject of the query.
+  */
+  get subject(): cqn.ref;
+}