@sap/cds-dk 10.1.2 → 10.2.1

package/bin/completion/templates/cds-tmpl.fish

@@ -1,65 +0,0 @@
-#!/bin/fish
-# This file was generated from bin/completion/templates/cds-tmpl.fish by
-# 'cds completion --generate' and is written to bin/completion/scripts/cds.fish.
-#
-# Do not edit directly — modify the template and regenerate.
-#
-# Fish's completion model differs from bash/zsh: instead of one catch-all function,
-# each subcommand and flag gets its own 'complete' line with a condition (-n).
-# The static section covers all known commands, flags, and positionals up-front;
-# _completeCdsDynamic handles the rest.
-#
-# Key fish completion flags used below:
-#   -c <cmd>   : the command this completion applies to
-#   -n <cond>  : only activate when the condition returns 0 (success)
-#   -f         : do not complete with file names (required when -a provides the values)
-#   -a         : argument values shown as completions
-
-# Erase any previously-loaded completions for 'cds' so stale entries from older
-# versions of this file do not accumulate across shell restarts.
-complete -c cds -e
-
-# Static completions: one 'complete' call per known command, flag, or positional.
-# __fish_use_subcommand  — returns 0 (true) when no subcommand token has been typed yet.
-# __fish_seen_subcommand_from <tokens> — returns 0 when any of <tokens> is on the line.
-{{COMMAND_COMPLETIONS}}
-
-# Helper for comma-separated option values (e.g. --add ai,ams,<tab>).
-# Call with the full list of valid values as arguments:
-#   _cdsCommaComplete val1 val2 val3
-# Reads the current token, splits on commas, omits already-used values,
-# and echoes remaining candidates prefixed with the already-typed portion.
-function _cdsCommaComplete
-    set -l all_values $argv
-    set -l cur (commandline -ct)
-    set -l parts (string split , $cur)
-    set -l prefix (string join , $parts[1..-2])
-    set -l partial $parts[-1]
-    if test (count $parts) -gt 1
-        set prefix $prefix","
-    end
-    for v in $all_values
-        if contains $v $parts[1..-2]
-            continue
-        end
-        if string match -q "$partial*" $v
-            echo $prefix$v
-        end
-    end
-end
-
-# Dynamic fallback — called for subcommands whose arguments cannot be determined
-# statically (e.g. service names, model names, unknown flags).
-# File paths for commands like compile/deploy are handled by the static FILE() sentinel above.
-# Single-quoting $previous/$current prevents bare word 'h' from being interpreted
-# as the 'help' shortcut by the completion handler before it is processed.
-function _completeCdsDynamic
-    set -l tokens (commandline -opc)
-    set -l current (commandline -ct)
-    set -l previous $tokens[-1]
-    set -l line (commandline -cp)
-    cds completion --shell fish --prev "'$previous'" --curr "'$current'" --line "'$line'"
-end
-# Activate the dynamic fallback only after a known subcommand (or its shortcut) has been
-# seen, so it does not shadow the static top-level command list.
-complete -c cds -f -n '__fish_seen_subcommand_from {{CMD_LIST_WITH_SHORTCUTS}}' --arguments "(_completeCdsDynamic)"

package/bin/completion/templates/cds-tmpl.ps1

@@ -1,217 +0,0 @@
-# This file was generated from bin/completion/templates/cds-tmpl.ps1 by
-# 'cds completion --generate' and is written to bin/completion/scripts/cds.ps1.
-#
-# Do not edit directly — modify the template and regenerate.
-#
-# All static completion data is stored in a single hashtable ($_CDS_COMPLETIONS)
-# for O(1) lookup. The ScriptBlock registered with Register-ArgumentCompleter
-# follows the same fastest-first strategy as the bash/zsh templates:
-#   1. Top-level commands  — when cursor is on the subcommand token.
-#   2. Shortcut resolution — single-char alias → canonical command name.
-#   3. Flags               — when $wordToComplete starts with '-'.
-#   3.5. Option values     — static values for known flags (e.g. --to sqlite).
-#   3.6. Comma values      — comma-separable list (e.g. cds add ai,hana).
-#   4. Positionals         — static known values per subcommand.
-#   4.5. File sentinel     — files only (flags shown only when $wordToComplete starts with '-').
-#   5. Dynamic fallback    — calls 'cds completion' for everything else.
-
-$_CDS_COMMAND = "cds"
-
-# Completion data map:
-#   __commands    — array of all top-level subcommand names
-#   __shortcuts   — hashtable of shortcut → canonical command name
-#   __positionals — hashtable of command → array of known positional string values
-#   __optionValues — hashtable of command → hashtable of flag → array of values,
-#                   or one of the file sentinels ':file', ':dir', ':file:ext1,ext2', ':file+dir:ext1,ext2'
-#   __commaCases  — hashtable of command → hashtable of flag → array of comma-separable values
-#   <cmd>         — array of flags/options for that subcommand (used by step 3)
-$_CDS_COMPLETIONS = @{
-    '__commands' = @({{CMD_ARRAY}});
-    '__shortcuts' = @{
-{{SHORTCUT_ENTRIES}}
-    };
-    '__positionals' = @{
-{{POSITIONAL_ENTRIES}}
-    };
-    '__optionValues' = @{
-{{OPTION_VALUE_ENTRIES}}
-    };
-    '__commaCases' = @{
-{{COMMA_ENTRIES}}
-    };
-{{CMD_ENTRIES}}
-}
-
-# $wordToComplete : the token currently being typed (may be empty if cursor is after a space)
-# $commandAst     : the full parsed command AST; .CommandElements is the token array
-# $cursorPosition : byte offset of the cursor in the command string
-Register-ArgumentCompleter -Native -CommandName $_CDS_COMMAND -ScriptBlock {
-    param($wordToComplete, $commandAst, $cursorPosition)
-
-    $map = $_CDS_COMPLETIONS
-    $cmdSegments = $commandAst.CommandElements
-    if ($null -eq $wordToComplete) { $wordToComplete = '' }
-
-    # Helper: emit file/dir completions for a sentinel value.
-    # Sentinel formats: ':file' (any file), ':dir' (directories only),
-    #                   ':file:ext1,ext2' (files with specific extensions),
-    #                   ':file+dir:ext1,ext2' (files with extensions + directories).
-    # Uses relative paths (preserving any typed prefix) so the completed text stays short.
-    function _CdsFileComplete($sentinel, $word) {
-        $base   = if ($word) { $word } else { '' }
-        $search = if ($word) { "$word*" } else { '*' }
-        $inclDirs = $sentinel -like ':file+dir:*'
-        # Parse extension list from ':file:cds,json' or ':file+dir:cds,json' → @('.cds', '.json')
-        $exts = if ($sentinel -like ':file:*' -or $inclDirs) {
-            ($sentinel -replace '^:file(\+dir)?:', '').Split(',') | ForEach-Object { ".$_" }
-        } else { $null }
-        if ($sentinel -eq ':dir') {
-            Get-ChildItem -Path $search -Directory -ErrorAction SilentlyContinue |
-                ForEach-Object {
-                    $rel = $base + $_.Name
-                    [System.Management.Automation.CompletionResult]::new($rel, $_.Name, 'ProviderItem', $_.Name)
-                }
-        } else {
-            Get-ChildItem -Path $search -File -ErrorAction SilentlyContinue |
-                Where-Object { $null -eq $exts -or $exts -contains $_.Extension } |
-                ForEach-Object {
-                    $rel = $base + $_.Name
-                    [System.Management.Automation.CompletionResult]::new($rel, $_.Name, 'ProviderItem', $_.Name)
-                }
-            if ($inclDirs) {
-                Get-ChildItem -Path $search -Directory -ErrorAction SilentlyContinue |
-                    ForEach-Object {
-                        $rel = $base + $_.Name
-                        [System.Management.Automation.CompletionResult]::new($rel, $_.Name, 'ProviderContainer', $_.Name)
-                    }
-            }
-        }
-    }
-
-    # Step 1: top-level command completion — cursor is on the subcommand token itself.
-    # Either no subcommand yet (count=1) or the user is still typing it (count=2, partial match).
-    $isTopLevel = $cmdSegments.Count -eq 1 -or ($cmdSegments.Count -eq 2 -and $wordToComplete -ne '' -and $cmdSegments[1].Extent.Text -eq $wordToComplete)
-    if ($isTopLevel) {
-        foreach ($cmd in $map['__commands']) {
-            if ($cmd.StartsWith($wordToComplete)) {
-                [System.Management.Automation.CompletionResult]::new($cmd, $cmd, 'ParameterValue', $cmd)
-            }
-        }
-        return
-    }
-
-    # Step 2: resolve shortcut to canonical command name so the rest of the
-    # logic only needs to handle canonical names.
-    $subCmd = $cmdSegments[1].Extent.Text
-    $resolved = $map['__shortcuts'][$subCmd]
-    if ($null -ne $resolved) { $subCmd = $resolved }
-
-    # Compute $previousWord — the token immediately before the cursor.
-    # When $wordToComplete is empty the cursor is after a space, so the last completed
-    # token is the previous word. When non-empty the cursor is mid-token, so look one
-    # further back. EndOffset filtering keeps only tokens that end before the cursor.
-    $prevCandidates = $cmdSegments | Where-Object { $_.Extent.EndOffset -le $cursorPosition }
-    $previousWord = if ($wordToComplete -eq '') {
-        ($prevCandidates | Select-Object -Last 1).Extent.Text
-    } else {
-        ($prevCandidates | Select-Object -Last 2 | Select-Object -First 1).Extent.Text
-    }
-
-    # Step 3: flag/option completion — triggered when $wordToComplete starts with '-'.
-    if ($wordToComplete.StartsWith('-')) {
-        $entry = $map[$subCmd]
-        if ($null -ne $entry) {
-            foreach ($opt in $entry) {
-                if ($opt.StartsWith($wordToComplete)) {
-                    [System.Management.Automation.CompletionResult]::new($opt, $opt, 'ParameterValue', $opt)
-                }
-            }
-            return
-        }
-    }
-
-    # Step 3.5: option-value completion — triggered when the previous word is a known option.
-    $optVals = $map['__optionValues'][$subCmd]
-    if ($null -ne $optVals) {
-        $entry = $optVals[$previousWord]
-        if ($null -ne $entry) {
-            if ($entry -eq ':dir' -or $entry -eq ':file' -or $entry -like ':file:*' -or $entry -like ':file+dir:*') {
-                _CdsFileComplete $entry $wordToComplete
-            } else {
-                foreach ($val in $entry) {
-                    if ($val.StartsWith($wordToComplete)) {
-                        [System.Management.Automation.CompletionResult]::new($val, $val, 'ParameterValue', $val)
-                    }
-                }
-            }
-            return
-        }
-    }
-
-    # Step 3.6: comma-separated option-value completion.
-    $commaVals = $map['__commaCases'][$subCmd]
-    if ($null -ne $commaVals) {
-        # Primary lookup: previous word is the option flag (e.g. '--add').
-        $entry = $commaVals[$previousWord]
-        if ($null -eq $entry -and $previousWord.EndsWith(',')) {
-            # Space-separated continuation: user typed "cds add ai, <tab>" so $previousWord="ai,"
-            # and $wordToComplete is empty. Scan backwards through segments to find the flag.
-            $prevSegs = @($cmdSegments | ForEach-Object { $_.Extent.Text })
-            $prevIdx = [array]::LastIndexOf($prevSegs, $previousWord) - 1
-            while ($prevIdx -ge 0 -and -not $prevSegs[$prevIdx].StartsWith('-')) { $prevIdx-- }
-            if ($prevIdx -ge 0) { $entry = $commaVals[$prevSegs[$prevIdx]] }
-        }
-        # Positional fallback: previous word is not a flag (it's the subcommand or a value).
-        if ($null -eq $entry -and -not $previousWord.StartsWith('-')) {
-            $entry = $commaVals['_']
-        }
-        if ($null -ne $entry) {
-            # For space-separated comma continuation, fold previousWord into the prefix/alreadyUsed.
-            $spaceComma = $previousWord.EndsWith(',')
-            $commaWord = if ($spaceComma) { $previousWord + $wordToComplete } else { $wordToComplete }
-            $parts = $commaWord.Split(',')
-            $prefix = if ($parts.Count -gt 1) { ($parts[0..($parts.Count-2)] -join ',') + ',' } else { '' }
-            $partial = $parts[-1]
-            $alreadyUsed = @{}
-            foreach ($u in $parts[0..($parts.Count-2)]) { if ($u) { $alreadyUsed[$u] = $true } }
-            foreach ($val in $entry) {
-                if (-not $alreadyUsed.ContainsKey($val) -and $val.StartsWith($partial)) {
-                    # When space-separated (prev="ai,"), PS replaces only $wordToComplete (=''),
-                    # so return just $val — the prefix is already on the line.
-                    $full = if ($spaceComma) { $val } else { $prefix + $val }
-                    [System.Management.Automation.CompletionResult]::new($full, $val, 'ParameterValue', $val)
-                }
-            }
-            return
-        }
-    }
-
-    # Step 4: static string positionals (e.g. cds help <tab>).
-    $positionals = $map['__positionals'][$subCmd]
-    if ($null -ne $positionals) {
-        $matched = $false
-        foreach ($pos in $positionals) {
-            if ($pos.StartsWith($wordToComplete)) {
-                [System.Management.Automation.CompletionResult]::new($pos, $pos, 'ParameterValue', $pos)
-                $matched = $true
-            }
-        }
-        if ($matched) { return }
-    }
-
-    # Step 4.5: default file sentinel — files only, no flags appended.
-    $defaultFile = $map['__optionValues'][$subCmd]?['_']
-    if ($null -ne $defaultFile) {
-        _CdsFileComplete $defaultFile $wordToComplete
-        return
-    }
-
-    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
-    # cannot be determined statically (e.g. service names, model names, unknown flags).
-    # Single-quoting $previousWord/$wordToComplete prevents bare word 'h' from being
-    # interpreted as the 'help' shortcut by the completion handler.
-    $options = & $_CDS_COMMAND completion --shell ps --prev "'$previousWord'" --curr "'$wordToComplete'" --line "'$commandAst'"
-    foreach ($option in $options) {
-        [System.Management.Automation.CompletionResult]::new($option, $option, 'ParameterValue', $option)
-    }
-}

package/bin/completion/templates/cds-tmpl.sh

@@ -1,93 +0,0 @@
-#!/bin/bash
-# This file was generated from bin/completion/templates/cds-tmpl.sh by
-# 'cds completion --generate' and is written to bin/completion/scripts/cds.sh.
-#
-# Do not edit directly — modify the template and regenerate.
-#
-# Completion strategy (fastest-first):
-#   1. Shortcuts    — single-character aliases resolved before any other logic.
-#   2. Top-level    — all known subcommands when no subcommand has been typed yet.
-#   3. Flags        — matched when the current token starts with '-'.
-#   3.5. Option values  — static values for known flags (e.g. --to sqlite).
-#   3.6. Comma values   — comma-separable list (e.g. cds add ai,hana).
-#   4. File positionals — files/dirs for subcommands that take a path argument.
-#   4.6. String positionals — fixed word list (e.g. cds help <tab>).
-#   5. Dynamic fallback — calls 'cds completion' for anything not covered above.
-#
-# compopt -o nospace suppresses the trailing space bash normally appends after a
-# completion, which is required for path completions (so the user can keep typing
-# a subdirectory) and for flag names (so '=' can follow immediately).
-CDS_COMMAND="cds"
-
-_completeCds()
-{
-    local current previous cmd
-    COMPREPLY=()
-    current="${COMP_WORDS[COMP_CWORD]}"
-    previous="${COMP_WORDS[COMP_CWORD - 1]}"
-    # The subcommand is always the second token (index 1).
-    cmd="${COMP_WORDS[1]}"
-    # Step 1: resolve single-character shortcuts to their canonical command name
-    # so that subsequent case statements only need to handle canonical names.
-{{SHORTCUT_CASE}}
-    # Step 2: top-level — offer all known subcommands when no subcommand has been
-    # typed yet (COMP_WORDS includes the command itself, so ≤ 2 means "cds <cursor>").
-    if [[ "${#COMP_WORDS[@]}" -le 2 ]]; then
-        COMPREPLY=( $(compgen -W "{{COMMANDS}}" -- "$current") )
-        compopt -o nospace
-        return 0
-    fi
-
-    # Step 3: flag/option completion — only triggered when the token starts with '-'.
-    if [[ "$current" == -* ]]; then
-        case "$cmd" in
-{{FLAG_CASES}}
-        esac
-        if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
-            compopt -o nospace
-            return 0
-        fi
-    fi
-
-    # Step 3.5: option-value completion — triggered when the previous word is a known option.
-    case "$cmd" in
-{{OPTION_VALUE_CASES}}
-    esac
-
-    # Step 3.6: comma-separated option-value completion.
-    # Splits $current on commas, filters out already-used values, prepends the prefix.
-    case "$cmd" in
-{{COMMA_CASES}}
-    esac
-
-    # Step 4: file-sentinel positionals — fill COMPREPLY with files and return.
-    case "$cmd" in
-{{FILE_CASES}}
-    esac
-    if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
-        compopt -o nospace
-        return 0
-    fi
-
-    # Step 4.6: string positionals (e.g. cds help <tab>).
-    case "$cmd" in
-{{STRING_POSITIONAL_CASES}}
-    esac
-    if [[ "${#COMPREPLY[@]}" -gt 0 ]]; then
-        compopt -o nospace
-        return 0
-    fi
-
-    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
-    # cannot be determined statically (e.g. service names, model names, unknown flags).
-    # Single-quoting $previous/$current prevents bare word 'h' from being interpreted
-    # as the 'help' shortcut by the completion handler before it is processed.
-    local options
-    options=$($CDS_COMMAND completion --shell bash --prev "'$previous'" --curr "'$current'" --line "'${COMP_WORDS[*]}'")
-    COMPREPLY=( $(compgen -W "${options}" -- "${current}") )
-    compopt -o nospace
-    return 0
-}
-
-# Register the completion function for the 'cds' command.
-complete -F _completeCds "$CDS_COMMAND"

package/bin/completion/templates/cds-tmpl.zsh

@@ -1,74 +0,0 @@
-#!/bin/zsh
-# This file was generated from bin/completion/templates/cds-tmpl.zsh by
-# 'cds completion --generate' and is written to bin/completion/scripts/cds.zsh.
-#
-# Do not edit directly — modify the template and regenerate.
-#
-# Completion strategy (fastest-first):
-#   1. Shortcuts    — single-character aliases resolved before any other logic.
-#   2. Top-level    — all known subcommands when no subcommand has been typed yet.
-#   3. Flags        — matched when the current token starts with '-'.
-#   3.5. Option values  — static values for known flags (e.g. --to sqlite).
-#   3.6. Comma values   — comma-separable list (e.g. cds add ai,hana).
-#   4. File positionals — files/dirs for subcommands that take a path argument.
-#   4.6. String positionals — fixed word list (e.g. cds help <tab>).
-#   5. Dynamic fallback — calls 'cds completion' for anything not covered above.
-#
-# Zsh uses $words (1-based token array) and $CURRENT (index of cursor token).
-# Completions are added with compadd instead of bash's COMPREPLY.
-# 'case ... esac && return' exits the function when a case arm matched.
-
-CDS_COMMAND="cds"
-
-_completeCds() {
-    local current="${words[CURRENT]}"
-    local previous="${words[CURRENT-1]}"
-    # The subcommand is always the second token (index 2 in 1-based zsh arrays).
-    local cmd="${words[2]}"
-    # Step 1: resolve single-character shortcuts to their canonical command name.
-{{SHORTCUT_CASE}}
-    # Step 2: top-level — offer all known subcommands when no subcommand has been
-    # typed yet ($words is 1-based; ≤ 2 means "cds <cursor>").
-    if [[ "${#words[@]}" -le 2 ]]; then
-        compadd -S '' -- {{COMMANDS}}
-        return
-    fi
-
-    # Step 3: flag/option completion — only triggered when the token starts with '-'.
-    # 'case ... esac && return' exits the function when a case arm matched.
-    if [[ "$current" == -* ]]; then
-        case "$cmd" in
-{{FLAG_CASES}}
-        esac && return
-    fi
-
-    # Step 3.5: option-value completion — triggered when the previous word is a known option.
-    case "$cmd" in
-{{OPTION_VALUE_CASES}}
-    esac
-
-    # Step 3.6: comma-separated option-value completion.
-    case "$cmd" in
-{{COMMA_CASES}}
-    esac
-
-    # Step 4: file-sentinel positionals — emit files and return.
-    case "$cmd" in
-{{FILE_CASES}}
-    esac
-
-    # Step 4.6: string positionals (e.g. cds help <tab>) — return after matching.
-    case "$cmd" in
-{{STRING_POSITIONAL_CASES}}
-    esac && return
-
-    # Step 5: dynamic fallback — calls 'cds completion' for subcommands whose arguments
-    # cannot be determined statically (e.g. service names, model names, unknown flags).
-    # Single-quoting $prev/$curr prevents bare word 'h' from being interpreted
-    # as the 'help' shortcut by the completion handler before it is processed.
-    # compadd -S '' suppresses the trailing space zsh normally appends after a completion.
-    compadd -S '' -- $(${CDS_COMMAND} completion --shell zsh --prev "'${words[CURRENT-1]}'" --curr "'${words[CURRENT]}'" --line "'${words[*]}'")
-}
-
-# Register the completion function for the 'cds' command.
-compdef _completeCds ${CDS_COMMAND}

package/node_modules/@cap-js/db-service/lib/recursion-guard.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const cds = require('@sap/cds')
-
-// shared across cqn4sql and infer to guard against stack overflow from user-controlled nesting depth
-const MAX_RECURSION_DEPTH = 100
-
-let recursionDepth = 0
-
-function enterRecursion() {
-  if (++recursionDepth > MAX_RECURSION_DEPTH) throw cds.error(400, `Query exceeds the maximum nesting depth of ${MAX_RECURSION_DEPTH}`)
-}
-
-function depthGuarded(fn) {
-  return function (...args) {
-    enterRecursion()
-    try {
-      return fn.apply(this, args)
-    } finally {
-      recursionDepth--
-    }
-  }
-}
-
-// entry points (infer / cqn4sql): outermost call resets the counter, so a thrown
-// depth error can't leave it polluted for the next request
-function guardEntry(fn) {
-  return function (...args) {
-    const outermost = recursionDepth === 0
-    enterRecursion()
-    try {
-      return fn.apply(this, args)
-    } finally {
-      if (outermost) recursionDepth = 0
-      else recursionDepth--
-    }
-  }
-}
-
-module.exports = { depthGuarded, guardEntry }