@sap/cds-dk 9.8.3 → 9.9.0

package/lib/mtx/push.js

@@ -1,15 +1,13 @@
 const { utils: { local }} = require ('../cds');
 const { join } = require('path');
 const { readFileSync, existsSync } = require('fs');
-const axios = require('axios');
 
 const { login } = require('./auth_manager');
 const buildSystem = require('../build')
 
-require('../util/axios').pruneErrors();
+const { buildResponseError, buildNetworkError, mtxFetch } = require('./util/request');
 const { getMessage } = require('./util/logging');
 const { schemaRegex } = require('./util/urls');
-const { handleHttpError } = require('./util/errors');
 
 const JOB_STATUS = {
     QUEUED: 'QUEUED',
@@ -35,9 +33,9 @@ module.exports = class Push {
         const target = { url, ...subdomain && { subdomain } };
 
         console.log(`\nPushing extension '${extensionName}' from`, { src }, 'to', target);
-        const push = await this.pushTgz(params, content, extensionName);
+        const pushResult = await this.pushTgz(params, content, extensionName);
         if (params.get('async')) {
-            await this.pollUntilFinished(push.headers.location, params)
+            await this.pollUntilFinished(pushResult.headers.get('location'), params)
         }
         console.log ('Activation succeeded.\n')
     }
@@ -52,11 +50,8 @@ module.exports = class Push {
             if (!schemaRegex.test(src)) {
                 throw getMessage(`Non-existent path: ${src}`, { command: 'push' });
             }
-            try {
-                content = (await axios.get(src, { responseEncoding: 'base64' })).data;
-            } catch (error) {
-                handleHttpError(error, params, { url: src });
-            }
+            const response = await mtxFetch('GET', src, {}, params);
+            content = Buffer.from(await response.arrayBuffer()).toString('base64');
         }
         return { src, content };
     }
@@ -71,40 +66,59 @@ module.exports = class Push {
 
     static async pushTgz(params, tgz, extensionName) {
         const pushUrl = `${params.get('appUrl')}/-/cds/extensibility/push`;
-        const options = { ...params.get('reqAuth') };
+        const reqAuth = params.get('reqAuth') || {};
+        const headers = { 'content-type': 'application/json', ...reqAuth.headers };
         const async = params.get('async');
         if (async) {
-            options.headers = { prefer: 'respond-async', ...options.headers }
+            headers['prefer'] = 'respond-async';
         }
 
-        return axios.post(pushUrl, {
-            extension: tgz,
-            tag: extensionName
-        }, options)
-            .catch(error => handleHttpError(error, params, { url: pushUrl }));
+        const response = await mtxFetch('POST', pushUrl, {
+            headers,
+            body: JSON.stringify({ extension: tgz, tag: extensionName })
+        }, params);
+        return response;
     }
 
     static async pollUntilFinished(jobUrl, params) {
-        return new Promise((resolve, reject) => {
-          const options = { ...params.get('reqAuth') };
+        const reqAuth = params.get('reqAuth') || {};
+        const headers = { ...reqAuth.headers };
 
+        return new Promise((resolve, reject) => {
           const timeout = setTimeout(() => {
             clearInterval(interval);
             reject(new Error('cds push timed out after 5 minutes'));
           }, 5 * 60 * 1000);
 
           const interval = setInterval(async () => {
-            const jobResult = await axios.get(jobUrl, options);
-            const { status, tasks } = jobResult.data;
-            const error = tasks[0]?.error ?? 'cds push failed'
-            if (status === JOB_STATUS.FINISHED || status === JOB_STATUS.FAILED) {
+            try {
+              const response = await fetch(jobUrl, { headers });
+              if (!response.ok) {
+                clearInterval(interval);
+                clearTimeout(timeout);
+                reject(await buildResponseError('GET', jobUrl, response));
+                return;
+              }
+              const jobResult = await response.json();
+              const { status, tasks } = jobResult;
+              const error = tasks[0]?.error ?? 'cds push failed'
+              if (status === JOB_STATUS.FINISHED || status === JOB_STATUS.FAILED) {
+                clearInterval(interval);
+                clearTimeout(timeout);
+
+                if (status === JOB_STATUS.FINISHED) {
+                  resolve();
+                } else if (status === JOB_STATUS.FAILED) {
+                  reject(new Error(error));
+                }
+              }
+            } catch (e) {
               clearInterval(interval);
               clearTimeout(timeout);
-
-              if (status === JOB_STATUS.FINISHED) {
-                resolve();
-              } else if (status === JOB_STATUS.FAILED) {
-                reject(new Error(error));
+              if (e.status) {
+                reject(e);
+              } else {
+                reject(buildNetworkError('GET', jobUrl, e));
               }
             }
           }, 1000);

package/lib/mtx/settings_manager.js

@@ -1,14 +1,13 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const axios = require('axios');
-
 const cds = require('../cds');
 
 const { requireGlobal } = require('./util/dependencies');
 const { getAppFromSuggestions, getSubdomain } = require('./util/cf');
 const isBas = require('./util/env');
 const { getMessage } = require('./util/logging');
+const { buildResponseError, buildNetworkError, parseResponseBody } = require('./util/request');
 const Question = require('./util/question');
 const { httpSchema, httpsSchema, schemaRegex, localhostRegex } = require('./util/urls');
 const { capitalize } = require('./util/strings');
@@ -111,20 +110,28 @@ async function getTokenUrl(params, renewUrl) {
 }
 
 async function fetchPasscodeUrl(params) {
-    const url = appUrlWith(OAUTH_META_PATH, params);
-    DEBUG?.(`Trying to get passcode URL from GET`, url);
+    let fetchUrl = appUrlWith(OAUTH_META_PATH, params);
+    DEBUG?.(`Trying to get passcode URL from GET`, fetchUrl);
+    if (params.has('subdomain')) {
+        const u = new URL(fetchUrl);
+        u.searchParams.set('subdomain', params.get('subdomain'));
+        fetchUrl = u.toString();
+    }
     let responseData;
     try {
-        const config = params.has('subdomain')
-            ? { params: { subdomain: params.get('subdomain') } }
-            : undefined;
-        const response = await axios.get(url, config /* no auth required */);
-        responseData = response.data;
+        const response = await fetch(fetchUrl /* no auth required */);
+        if (!response.ok) {
+            throw await buildResponseError('GET', fetchUrl, response);
+        }
+        responseData = await parseResponseBody(response);
     } catch (error) {
         if (error.status === 404) {
             DEBUG?.(`Request unsupported by server, ignoring (${error.message.replace(/ *Details:.*/s, '')})`);
-        } else {
+        } else if (error.status) {
             DEBUG?.(getMessage(`Getting passcode URL failed`, { error }));
+        } else {
+            const netError = buildNetworkError('GET', fetchUrl, error);
+            DEBUG?.(getMessage(`Getting passcode URL failed`, { error: netError }));
         }
         return undefined;
     }

package/lib/mtx/tenant_action.js

@@ -3,10 +3,9 @@ const { ParamCollection } = require('./params');
 const AuthManager = require('./auth_manager');
 const { localhostRegex } = require('./util/urls');
 
-require('../util/axios').pruneErrors();
+const { mtxFetch } = require('./util/request');
 const { getMessage } = require('./util/logging');
 const { capitalize } = require('./util/strings');
-const { handleHttpError } = require('./util/errors');
 
 const DEBUG = cds.debug('cli');
 
@@ -63,16 +62,17 @@ module.exports = class TenantAction {
         let parsedBody;
         if (body) {
             try {
-                parsedBody = JSON.parse(body)
+                parsedBody = JSON.parse(body);
             } catch (error) {
                 throw getMessage('Invalid subscription body', { error, command: this.command });
             }
         }
-        try {
-            await require('axios').post(url, { tenant, metadata: parsedBody, options: parsedBody }, params.get('reqAuth'));
-        } catch (error) {
-            handleHttpError(error, params, { url });
-        }
+        const reqAuth = params.get('reqAuth') || {};
+        const headers = { 'content-type': 'application/json', ...reqAuth.headers };
+        await mtxFetch('POST', url, {
+            headers,
+            body: JSON.stringify({ tenant, metadata: parsedBody, options: parsedBody })
+        }, params);
     }
 
     async runWithServer(params, tenant) {
@@ -91,7 +91,7 @@ module.exports = class TenantAction {
         }
 
         const { cds_mtx } = require(libPath);
-        const body = params.get('body')
+        const body = params.get('body');
         return cds_mtx(this.command, tenant, body);
     }
 }

package/lib/mtx/util/request.js

@@ -0,0 +1,158 @@
+const { inspect } = require('util');
+
+const debug = require('../../cds').log('req');
+
+function stacklessError(message) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  const error = new Error(message);
+  Error.stackTraceLimit = stackTraceLimit;
+  return error;
+}
+
+function extractDetails(data) {
+  if (!data) return undefined;
+  if (typeof data === 'string') {
+    if (/<html/i.test(data)) {
+      return '(HTML response received. If applicable, ensure the route to MTX is configured correctly in App Router.)';
+    }
+    if (data.length >= 1000) return undefined;
+    return data.trim();
+  }
+  if (typeof data === 'object') {
+    if (data.error_description) return data.error_description;
+    if (data.error && typeof data.error === 'object' && data.error.message) return data.error.message;
+    if (data.error && typeof data.error === 'string') return data.error;
+    if (typeof data.message === 'string') return data.message;
+    return inspect(data);
+  }
+  return undefined;
+}
+
+function buildError(method, url, { status, statusText, data, errno, code, fetchError } = {}) {
+  const obfuscateUrl = url => url?.replace(/(passcode|refreshToken|clientsecret|key)=[^&]+/g, '$1=...');
+  const prefix = (url && method ? `${method.toUpperCase()} ${obfuscateUrl(url)}` : 'Request') + ' failed';
+  let error;
+
+  if (errno || code) {
+    const errInfo = [errno, code].filter(Boolean).join(' ');
+    const message = prefix +
+      `: ${errInfo}` +
+      (/\b(ENOTFOUND|EAI_AGAIN)\b/.test(code)
+        ? `. Make sure the URL is correct and the server is running.`
+        : '');
+    error = stacklessError(message);
+  } else {
+    const details = extractDetails(data);
+    const reason = typeof data?.error === 'string' ? data.error : undefined;
+    const errObj = debug._debug && typeof data?.error === 'object'
+      ? inspect(data.error)
+      : undefined;
+
+    const message = prefix +
+      (status || statusText || reason || details
+        ? (status || statusText ? ':' : '') +
+          (status ? ` ${status}` : '') +
+          (statusText ? ` ${statusText}` : '') +
+          (reason ? `. ${reason}` : '') +
+          (details ? `. Details: ${details}` : '') +
+          (errObj ? `. Error object: ${errObj}` : '')
+        : '');
+    error = stacklessError(message);
+    if (status) error.status = status;
+    if (data?.passcode_url) {
+      error.auth = { passcode_url: data.passcode_url };
+    }
+  }
+
+  if (debug._debug && fetchError) {
+    error.cause = fetchError;
+  }
+
+  return error;
+}
+
+async function parseResponseBody(response) {
+  const contentType = response.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) {
+    return response.json();
+  }
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch { /* ignore */ }
+  return text;
+}
+
+/**
+ * Build a fetch error from a non-ok response.
+ * Reads the response body and constructs a rich error with .status, .message, and .auth.
+ *
+ * @param {string} method - HTTP method
+ * @param {string} url - Request URL
+ * @param {Response} response - Fetch Response object
+ * @returns {Promise<Error>} error with .status, .message, .auth properties
+ */
+async function buildResponseError(method, url, response) {
+  let data;
+  try {
+    data = await parseResponseBody(response);
+  } catch { /* ignore */ }
+  return buildError(method, url, {
+    status: response.status,
+    statusText: response.statusText,
+    data,
+    fetchError: new Error(`${response.status} ${response.statusText}`)
+  });
+}
+
+/**
+ * Build a fetch error from a network/system error.
+ *
+ * @param {string} method - HTTP method
+ * @param {string} url - Request URL
+ * @param {Error} fetchError - The caught error from fetch()
+ * @returns {Error} error with formatted message
+ */
+function buildNetworkError(method, url, fetchError) {
+  const cause = fetchError.cause ?? {};
+  const errno = fetchError.errno || cause.errno;
+  const code = fetchError.code || cause.code
+    || fetchError.message?.match(/\b(ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EHOSTUNREACH)\b/)?.[1]
+    || cause.message?.match(/\b(ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EHOSTUNREACH)\b/)?.[1];
+  return buildError(method, url, { errno, code, fetchError });
+}
+
+const { handleHttpError } = require('./errors');
+
+/**
+ * Fetch with standardized error handling for mtx modules.
+ * Network errors are wrapped via buildNetworkError.
+ * HTTP errors are passed through handleHttpError which maps status codes to user-facing messages.
+ *
+ * @param {string} method - HTTP method
+ * @param {string} url - Request URL
+ * @param {object} [options] - fetch options (headers, body, etc.)
+ * @param {object} [params] - ParamCollection for handleHttpError context
+ * @returns {Promise<Response>}
+ */
+async function mtxFetch(method, url, options = {}, params) {
+  let response;
+  try {
+    response = await fetch(url, { method, ...options });
+  } catch (e) {
+    throw buildNetworkError(method, url, e);
+  }
+  if (!response.ok) {
+    handleHttpError(await buildResponseError(method, url, response), params, { url });
+  }
+  return response;
+}
+
+module.exports = {
+  buildError,
+  buildResponseError,
+  buildNetworkError,
+  parseResponseBody,
+  mtxFetch
+};

package/lib/util/cf.js

@@ -4,8 +4,6 @@ const os = require('os');
 const path = require('path');
 const util = require('util');
 
-const axios = require('axios');
-
 const IS_WIN = os.platform() === 'win32';
 const execAsync = util.promisify(cp.exec);
 
@@ -29,7 +27,6 @@ const OPERATION_STATE_FAILED = 'failed';
 const OPERATION_STATE_SUCCEEDED = 'succeeded';
 
 const CF_CLIENT_MINIMUM_VERSION = 8;
-const ENCODED_COMMA = encodeURIComponent(',');
 
 module.exports = new class CfUtil {
 
@@ -68,42 +65,46 @@ module.exports = new class CfUtil {
     }
 
     async curl(urlPath, queryObj, bodyObj) {
-        const url = this.#target.apiEndpoint + urlPath;
+        let url = this.#target.apiEndpoint + urlPath
 
-        const options = {
-            headers: { 'Authorization': this.#target.token }
-        };
+        const headers = { 'Authorization': this.#target.token }
 
         if (queryObj && Object.keys(queryObj).length > 0) {
-            const params = {};
+            const parts = []
             for (const [k, v] of Object.entries(queryObj)) {
-                // cf rest API does not accept comma in query parameters
-                params[k] = v.replaceAll(',', ENCODED_COMMA);
+                parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
             }
-            options.params = params;
+            url += '?' + parts.join('&')
         }
 
-        try {
-            let response;
-            if (bodyObj) {
-                response = (await axios.post(url, bodyObj, options));
-            } else {
-                response = (await axios.get(url, options));
-            }
-            if (LOG._debug) {
-                options.headers.Authorization = 'bearer <token>';
-                LOG.debug(`POST ${url}\n${JSON.stringify(options, null, 4)}\n${JSON.stringify(response.data, null, 4)}`);
-            }
+        const fetchOptions = { headers }
+        if (bodyObj) {
+            fetchOptions.method = 'POST'
+            fetchOptions.headers['Content-Type'] = 'application/json'
+            fetchOptions.body = JSON.stringify(bodyObj)
+        }
 
-            return response.data;
-        } catch (err) {
-            if (err instanceof axios.AxiosError) {
-                if (err.response?.data?.errors[0]) {
-                    throw JSON.stringify(err.response.data.errors[0], null, 4);
-                }
-                throw `${err.name} ${err.code} ${err.status||''}: ${err.message} while accessing ${url}`;
+        const response = await fetch(url, fetchOptions)
+
+        if (!response.ok) {
+            const text = await response.text()
+            let data
+            try { data = JSON.parse(text) } catch { /* ignore */ }
+            if (data?.errors?.[0]) {
+                throw JSON.stringify(data.errors[0], null, 2)
             }
+            throw `${response.status} ${response.statusText}: while accessing ${url}`
+        }
+
+        const text = await response.text()
+        const data = text ? JSON.parse(text) : {}
+
+        if (LOG._debug) {
+            const method = fetchOptions.method || 'GET'
+            LOG.debug(`${method} ${url}\n${JSON.stringify({ headers: { ...headers, Authorization: 'bearer <token>' } }, null, 4)}\n${JSON.stringify(data, null, 4)}`)
         }
+
+        return data
     }
 
     _extract(string, pattern, errorMsg) {

package/lib/watch/node-watch.js

@@ -31,7 +31,7 @@ module.exports = ({ cwd = process.cwd(), script, ext, ignore=RegExp(), watched,
 
       const updated = eventsAndOpts.filter(evt => evt.type && evt.type === 'update').map(evt => evt.name)
       emitter.emit ('restart', updated)
-      env.CDS_WATCH_HOT_RELOAD = options['experimental-hot-reload']
+      // env.CDS_WATCH_HOT_RELOAD = options['experimental-hot-reload']
       child = fork (script, { cwd, env, stdio:'inherit', execArgv }, (err)=>{
         if (err)  console.error (err)
       })

package/lib/watch/vite-watch.js

@@ -0,0 +1,76 @@
+const cds = require('../../lib/cds')
+const { pathToFileURL } = require('node:url')
+const { path, stat, readdir, isdir, colors: { BOLD, RESET } } = cds.utils
+
+let hmrPort = 24100
+
+async function hasViteConfig(appPath) {
+  for (const name of ['vite.config.js', 'vite.config.mjs', 'vite.config.ts']) {
+    const file = await stat(path.join(appPath, name)).catch(e => e.code === 'ENOENT' ? null : Promise.reject(e))
+    return !!file
+  }
+  return false
+}
+
+async function findViteApps() {
+  const app = cds.env.folders.app
+  const apps = []
+  if (!isdir(app)) return apps
+  const entries = await readdir(app)
+  for (const entry of entries) {
+    const appName = typeof entry === 'string' ? entry : entry.name
+    if (!appName) continue
+    const appPath = path.join(cds.root, app, appName)
+    if (!isdir(appPath)) continue
+    if (await hasViteConfig(appPath)) apps.push({ name: appName, path: appPath })
+  }
+  return apps
+}
+
+async function loadCreateServer(fromPath) {
+  try {
+      const vitePath = require.resolve('vite', { paths: [fromPath] })
+      return (await import(pathToFileURL(vitePath).href)).createServer
+    } catch(e) {
+      if (e.code !== 'MODULE_NOT_FOUND') throw e
+      /* try next path */
+  }
+  const relative = path.relative(cds.root, fromPath)
+  throw `[cds] - Found Vite app in ${relative}, but package "vite" is not installed. Run ${BOLD}npm install vite --prefix ${relative}${RESET} to install it.`
+}
+
+cds.on('bootstrap', app => {
+
+  let viteMiddleware = null
+  app.use((req, res, next) => {
+    if (viteMiddleware) return viteMiddleware(req, res, next)
+    next()
+  })
+
+  cds.on('served', async () => {
+    const viteApps = await findViteApps()
+    if (!viteApps.length) return
+
+    const createServer = await loadCreateServer(viteApps[0].path)
+
+    // Build a middleware chain from all Vite servers, keyed by base path
+    const viteServers = []
+    const normalizeBase = base => {
+      if (!base.startsWith('/')) base = `/${base}`
+      return base.endsWith('/') ? base : `${base}/`
+    }
+
+    for (const viteApp of viteApps) {
+      const base = normalizeBase(viteApp.name)
+      const server = await createServer({ base, root: viteApp.path, server: { middlewareMode: true, hmr: { port: hmrPort++ } }})
+      viteServers.push({ base, middlewares: server.middlewares })
+    }
+
+    viteMiddleware = (req, res, next) => {
+      const url = req.url || ''
+      const match = viteServers.find(v => url.startsWith(v.base) || url.startsWith('/@'))
+      if (match) return match.middlewares(req, res, next)
+      next()
+    }
+  })
+})

package/lib/watch/watched.js

@@ -8,14 +8,15 @@
   // run through cli in order to use its error handling
   const args = JSON.parse(process.env._args)
   const cds = require('../cds'); cds.watched = true
+  require('./vite-watch')
   const bootstrap = require('../../bin/cds')(...args)
 
   cds.once('listening', async ({ server }) => {
     process.send({ code: 'listening', port: server.address().port })
-    if (process.env.CDS_WATCH_HOT_RELOAD && process.env.CDS_WATCH_HOT_RELOAD !== 'false') {
-      const hotReload = require('./hot-reload');
-      await hotReload()
-    }
+    // if (process.env.CDS_WATCH_HOT_RELOAD) {
+    //   const hotReload = require('./hot-reload');
+    //   await hotReload()
+    // }
   })
 
   try {