@zowe/db2-for-zowe-cli 6.1.17 → 6.1.19

package/node_modules/axios/index.d.cts

@@ -181,7 +181,7 @@ declare class CanceledError<T, D = any, P = any> extends AxiosError<T, D, P> {
 
 declare const axiosResponseDefault: unique symbol;
 
-type AxiosResponseDefault = typeof axiosResponseDefault;
+type AxiosResponseDefault = axios.AxiosResponseDefault;
 
 type AxiosResponseResult<T, R, D, P> = R extends AxiosResponseDefault
   ? axios.AxiosResponse<T, D, {}, P>
@@ -288,14 +288,18 @@ declare enum HttpStatusCode {
   Gone = 410,
   LengthRequired = 411,
   PreconditionFailed = 412,
+  /** @deprecated Use `ContentTooLarge` instead. */
   PayloadTooLarge = 413,
+  ContentTooLarge = 413,
   UriTooLong = 414,
   UnsupportedMediaType = 415,
   RangeNotSatisfiable = 416,
   ExpectationFailed = 417,
   ImATeapot = 418,
   MisdirectedRequest = 421,
+  /** @deprecated Use `UnprocessableContent` instead. */
   UnprocessableEntity = 422,
+  UnprocessableContent = 422,
   Locked = 423,
   FailedDependency = 424,
   TooEarly = 425,
@@ -327,6 +331,10 @@ declare enum HttpStatusCode {
 type InternalAxiosError<T = unknown, D = any, P = any> = AxiosError<T, D, P>;
 
 declare namespace axios {
+  interface AxiosResponseDefault {
+    readonly [axiosResponseDefault]: true;
+  }
+
   type AxiosHeaderParameters = Record<string, string>;
 
   type AxiosError<T = unknown, D = any, P = any> = InternalAxiosError<T, D, P>;
@@ -426,6 +434,8 @@ declare namespace axios {
     legacyInterceptorReqResOrdering?: boolean;
     advertiseZstdAcceptEncoding?: boolean;
     validateStatusUndefinedResolves?: boolean;
+    /** Opt in to UTF-8 Basic auth usernames in XHR/Fetch config resolution. Defaults to false. */
+    encodeBasicAuthUsername?: boolean;
   }
 
   interface GenericAbortSignal {
@@ -557,6 +567,14 @@ declare namespace axios {
       FormData?: new (...args: any[]) => object;
       fetch?: (input: URL | Request | string, init?: RequestInit) => Promise<Response>;
       Request?: new (input: URL | Request | string, init?: RequestInit) => Request;
+      /**
+       * Custom Response constructor for the fetch adapter.
+       * When response-body streaming is supported, must also accept
+       * `ReadableStream<Uint8Array>` bodies at runtime for `onDownloadProgress`,
+       * enabled `maxContentLength` limits, or cancellation/timeout tracking with
+       * `responseType: 'stream'` or `'response'`.
+       * The body parameter retains its legacy type for compatibility.
+       */
       Response?: new (
         body?: ArrayBuffer | ArrayBufferView | Blob | FormData | URLSearchParams | string | null,
         init?: ResponseInit
@@ -632,6 +650,11 @@ declare namespace axios {
     data: T;
     status: number;
     statusText: string;
+    /**
+     * Wall-clock milliseconds from adapter invocation to settlement, clamped at zero.
+     * Excludes interceptors and request/response transforms. Stream consumption is not included.
+     */
+    duration?: number;
     headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;
     config: InternalAxiosRequestConfig<D, P>;
     request?: any;

package/node_modules/axios/index.d.ts

@@ -214,14 +214,18 @@ export enum HttpStatusCode {
   Gone = 410,
   LengthRequired = 411,
   PreconditionFailed = 412,
+  /** @deprecated Use `ContentTooLarge` instead. */
   PayloadTooLarge = 413,
+  ContentTooLarge = 413,
   UriTooLong = 414,
   UnsupportedMediaType = 415,
   RangeNotSatisfiable = 416,
   ExpectationFailed = 417,
   ImATeapot = 418,
   MisdirectedRequest = 421,
+  /** @deprecated Use `UnprocessableContent` instead. */
   UnprocessableEntity = 422,
+  UnprocessableContent = 422,
   Locked = 423,
   FailedDependency = 424,
   TooEarly = 425,
@@ -300,6 +304,8 @@ export interface TransitionalOptions {
   legacyInterceptorReqResOrdering?: boolean;
   advertiseZstdAcceptEncoding?: boolean;
   validateStatusUndefinedResolves?: boolean;
+  /** Opt in to UTF-8 Basic auth usernames in XHR/Fetch config resolution. Defaults to false. */
+  encodeBasicAuthUsername?: boolean;
 }
 
 export interface GenericAbortSignal {
@@ -440,6 +446,14 @@ export interface AxiosRequestConfig<D = any, P = any> {
     FormData?: new (...args: any[]) => object;
     fetch?: (input: URL | Request | string, init?: RequestInit) => Promise<Response>;
     Request?: new (input: URL | Request | string, init?: RequestInit) => Request;
+    /**
+     * Custom Response constructor for the fetch adapter.
+     * When response-body streaming is supported, must also accept
+     * `ReadableStream<Uint8Array>` bodies at runtime for `onDownloadProgress`,
+     * enabled `maxContentLength` limits, or cancellation/timeout tracking with
+     * `responseType: 'stream'` or `'response'`.
+     * The body parameter retains its legacy type for compatibility.
+     */
     Response?: new (
       body?: ArrayBuffer | ArrayBufferView | Blob | FormData | URLSearchParams | string | null,
       init?: ResponseInit
@@ -512,6 +526,11 @@ export interface AxiosResponse<T = any, D = any, H = {}, P = any> {
   data: T;
   status: number;
   statusText: string;
+  /**
+   * Wall-clock milliseconds from adapter invocation to settlement, clamped at zero.
+   * Excludes interceptors and request/response transforms. Stream consumption is not included.
+   */
+  duration?: number;
   headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;
   config: InternalAxiosRequestConfig<D, P>;
   request?: any;
@@ -567,7 +586,9 @@ export class CanceledError<T, D = any, P = any> extends AxiosError<T, D, P> {
 
 declare const axiosResponseDefault: unique symbol;
 
-type AxiosResponseDefault = typeof axiosResponseDefault;
+export interface AxiosResponseDefault {
+  readonly [axiosResponseDefault]: true;
+}
 
 type AxiosResponseResult<T, R, D, P> = R extends AxiosResponseDefault
   ? AxiosResponse<T, D, {}, P>

package/node_modules/axios/lib/adapters/fetch.js

@@ -3,6 +3,7 @@ import utils from '../utils.js';
 import AxiosError from '../core/AxiosError.js';
 import composeSignals from '../helpers/composeSignals.js';
 import { trackStream } from '../helpers/trackStream.js';
+import createMultipartBody from '../core/createMultipartBody.js';
 import AxiosHeaders from '../core/AxiosHeaders.js';
 import {
   progressEventReducer,
@@ -17,6 +18,18 @@ import { toByteStringHeaderObject } from '../helpers/sanitizeHeaderValue.js';
 
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
+const DEFAULT_REQUEST_OPTIONS = {
+  cache: 'default',
+  redirect: 'follow',
+  referrer: 'about:client',
+  referrerPolicy: '',
+  mode: 'cors',
+  integrity: '',
+  keepalive: false,
+  priority: 'auto',
+  window: null,
+};
+
 const { isFunction } = utils;
 
 /**
@@ -67,9 +80,7 @@ const maybeWithAuthCredentials = (url) => {
 
 const factory = (env) => {
   const globalObject =
-    utils.global !== undefined && utils.global !== null
-      ? utils.global
-      : globalThis;
+    utils.global !== undefined && utils.global !== null ? utils.global : globalThis;
   const { ReadableStream, TextEncoder } = globalObject;
 
   env = utils.merge.call(
@@ -79,11 +90,13 @@ const factory = (env) => {
     {
       Request: globalObject.Request,
       Response: globalObject.Response,
+      Blob: globalObject.Blob,
     },
     env
   );
 
-  const { fetch: envFetch, Request, Response } = env;
+  const envFetch = utils.hasOwnProp(env, 'fetch') ? env.fetch : undefined;
+  const { Request, Response, Blob } = env;
   const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
   const isRequestSupported = isFunction(Request);
   const isResponseSupported = isFunction(Response);
@@ -132,6 +145,20 @@ const factory = (env) => {
     isReadableStreamSupported &&
     test(() => utils.isReadableStream(new Response('').body));
 
+  // Some runtimes reject every explicit cache mode. Use own defaults for both
+  // probes so unrelated polluted options cannot affect cache-mode detection.
+  const requestDefaults = Object.assign(Object.create(null), DEFAULT_REQUEST_OPTIONS);
+
+  if (isRequestSupported && !test(() => new Request(platform.origin, requestDefaults))) {
+    delete requestDefaults.cache;
+
+    // Only omit cache when that makes Request construction succeed. Otherwise
+    // retain the explicit default that protects supporting runtimes from pollution.
+    if (!test(() => new Request(platform.origin, requestDefaults))) {
+      requestDefaults.cache = DEFAULT_REQUEST_OPTIONS.cache;
+    }
+  }
+
   const resolvers = {
     stream: supportsResponseStream && ((res) => res.body),
   };
@@ -165,14 +192,6 @@ const factory = (env) => {
       return body.size;
     }
 
-    if (utils.isSpecCompliantForm(body)) {
-      const _request = new Request(platform.origin, {
-        method: 'POST',
-        body,
-      });
-      return (await _request.arrayBuffer()).byteLength;
-    }
-
     if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
       return body.byteLength;
     }
@@ -208,6 +227,7 @@ const factory = (env) => {
       fetchOptions,
       maxContentLength,
       maxBodyLength,
+      maxRedirects,
     } = resolveConfig(config);
 
     const hasMaxContentLength = utils.isNumber(maxContentLength) && maxContentLength > -1;
@@ -234,11 +254,12 @@ const factory = (env) => {
 
     let requestContentLength;
 
-    // AxiosError we raise while the request body is being streamed. Captured
+    // AxiosErrors we raise while request or response bodies are being streamed. Captured
     // by identity so the catch block can surface it directly, regardless of
     // how the runtime wraps the resulting fetch rejection (undici exposes it
     // as `err.cause`; some browsers drop the original error entirely).
     let pendingBodyError = null;
+    let pendingResponseError = null;
 
     const maxBodyLengthError = () =>
       new AxiosError(
@@ -258,19 +279,20 @@ const factory = (env) => {
         const password = utils.getSafeProp(configAuth, 'password') || '';
         auth = {
           username,
-          password
+          password,
         };
       }
 
+      let parsedURL;
       if (maybeWithAuthCredentials(url)) {
-        const parsedURL = new URL(url, platform.origin);
+        parsedURL = new URL(url, platform.origin);
 
         if (!auth && (parsedURL.username || parsedURL.password)) {
           const urlUsername = decodeURIComponentSafe(parsedURL.username);
           const urlPassword = decodeURIComponentSafe(parsedURL.password);
           auth = {
             username: urlUsername,
-            password: urlPassword
+            password: urlPassword,
           };
         }
 
@@ -292,8 +314,8 @@ const factory = (env) => {
       // Enforce maxContentLength for data: URLs up-front so we never materialize
       // an oversized payload. The HTTP adapter applies the same check (see http.js
       // "if (protocol === 'data:')" branch).
-      if (hasMaxContentLength && typeof url === 'string' && url.startsWith('data:')) {
-        const estimated = estimateDataURLDecodedBytes(url);
+      if (hasMaxContentLength && parsedURL && parsedURL.protocol === 'data:') {
+        const estimated = estimateDataURLDecodedBytes(parsedURL.href);
         if (estimated > maxContentLength) {
           throw new AxiosError(
             'maxContentLength size of ' + maxContentLength + ' exceeded',
@@ -304,6 +326,38 @@ const factory = (env) => {
         }
       }
 
+      const formContentType =
+        utils.isSpecCompliantForm(data) && AxiosHeaders.from(own('headers')).getContentType();
+      let formBoundary;
+      if (
+        utils.isString(formContentType) &&
+        /^multipart\/form-data(?:\s*;|$)/i.test(formContentType.trim())
+      ) {
+        const parameters = AxiosHeaders.parseParameters(formContentType);
+        if (utils.hasOwnProp(parameters, 'boundary')) formBoundary = parameters.boundary;
+      }
+
+      if (
+        utils.isSpecCompliantForm(data) &&
+        method !== 'get' &&
+        method !== 'head' &&
+        (hasMaxBodyLength ||
+          (onUploadProgress && supportsRequestStream) ||
+          formBoundary !== undefined)
+      ) {
+        data = createMultipartBody(
+          data,
+          Blob,
+          hasMaxBodyLength ? maxBodyLength : Infinity,
+          maxBodyLengthError,
+          formBoundary
+        );
+        // Blob.type lowercases its value, including a case-sensitive boundary.
+        // Retain the caller's header when an explicit boundary was serialized.
+        headers.setContentType(formBoundary === undefined ? data.type : formContentType);
+        requestContentLength = data.size;
+      }
+
       // Enforce maxBodyLength against known-size bodies before dispatch using
       // the body's *actual* size — never a caller-declared Content-Length,
       // which could under-report to slip an oversized body past the check.
@@ -344,7 +398,9 @@ const factory = (env) => {
         (onUploadProgress || mustEnforceStreamBody)
       ) {
         requestContentLength =
-          requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;
+          requestContentLength == null
+            ? await resolveBodyLength(headers, data)
+            : requestContentLength;
 
         // A declared length of 0 is only trusted to skip the wrap when we are
         // not enforcing a stream limit (which must not rely on that header).
@@ -357,7 +413,10 @@ const factory = (env) => {
 
           let contentTypeHeader;
 
-          if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+          if (
+            utils.isFormData(data) &&
+            (contentTypeHeader = _request.headers.get('content-type'))
+          ) {
             headers.setContentType(contentTypeHeader);
           }
 
@@ -420,20 +479,57 @@ const factory = (env) => {
       // Set User-Agent header if not already set (fetch defaults to 'node' in Node.js)
       headers.set('User-Agent', 'axios/' + VERSION, false);
 
-      const resolvedOptions = {
-        ...fetchOptions,
+      const safeFetchOptions =
+        fetchOptions == null ? fetchOptions : Object.assign(Object.create(null), fetchOptions);
+
+      if (safeFetchOptions) {
+        // These options are owned by Axios and are already reflected in the
+        // resolved Request passed to fetch.
+        delete safeFetchOptions.body;
+        delete safeFetchOptions.headers;
+        delete safeFetchOptions.method;
+        delete safeFetchOptions.signal;
+        delete safeFetchOptions.duplex;
+        delete safeFetchOptions.credentials;
+      }
+
+      const resolvedOptions = Object.assign(Object.create(null), safeFetchOptions, {
         signal: composedSignal,
         method: method.toUpperCase(),
         headers: toByteStringHeaderObject(headers.normalize()),
         body: data,
         duplex: 'half',
         credentials: isCredentialsSupported ? withCredentials : undefined,
-      };
+      });
+
+      if (isRequestSupported) {
+        utils.forEach(requestDefaults, (value, key) => {
+          if (resolvedOptions[key] === undefined) {
+            resolvedOptions[key] = value;
+          }
+        });
+
+        if (resolvedOptions.signal === undefined) {
+          resolvedOptions.signal = null;
+        }
+
+        if (resolvedOptions.body === undefined) {
+          resolvedOptions.body = null;
+        }
+      }
+
+      if (maxRedirects === 0) {
+        resolvedOptions.redirect = 'manual';
+
+        if (safeFetchOptions) {
+          safeFetchOptions.redirect = 'manual';
+        }
+      }
 
       request = isRequestSupported && new Request(url, resolvedOptions);
 
       let response = await (isRequestSupported
-        ? _fetch(request, fetchOptions)
+        ? _fetch(request, safeFetchOptions)
         : _fetch(url, resolvedOptions));
 
       const responseHeaders = AxiosHeaders.from(response.headers);
@@ -481,12 +577,12 @@ const factory = (env) => {
           if (hasMaxContentLength) {
             bytesRead = loadedBytes;
             if (bytesRead > maxContentLength) {
-              throw new AxiosError(
+              throw (pendingResponseError = new AxiosError(
                 'maxContentLength size of ' + maxContentLength + ' exceeded',
                 AxiosError.ERR_BAD_RESPONSE,
                 config,
                 request
-              );
+              ));
             }
           }
           onProgress && onProgress(loadedBytes);
@@ -572,7 +668,7 @@ const factory = (env) => {
       }
 
       // Surface a maxBodyLength violation we raised while the request body was
-      // being streamed. Matching by identity (rather than reading
+      // being streamed. Keeping the original error (rather than reading
       // `err.cause.isAxiosError`) keeps the error deterministic across runtimes
       // and avoids both prototype-pollution reads and mis-attributing a foreign
       // AxiosError that merely happened to land in `err.cause`.
@@ -581,6 +677,10 @@ const factory = (env) => {
         throw pendingBodyError;
       }
 
+      if (pendingResponseError) {
+        throw pendingResponseError;
+      }
+
       // Re-throw AxiosErrors we raised synchronously (data: URL / content-length
       // pre-checks, response size enforcement) without re-wrapping them.
       if (err instanceof AxiosError) {
@@ -616,9 +716,15 @@ const factory = (env) => {
 const seedCache = new Map();
 
 export const getFetch = (config) => {
-  let env = (config && config.env) || {};
-  const { fetch, Request, Response } = env;
-  const seeds = [Request, Response, fetch];
+  const env = Object.create(null);
+  const configuredEnv = config && utils.hasOwnProp(config, 'env') && config.env;
+  ['fetch', 'Request', 'Response', 'Blob'].forEach((key) => {
+    if (configuredEnv && utils.hasOwnProp(configuredEnv, key)) {
+      env[key] = configuredEnv[key];
+    }
+  });
+  const { fetch, Request, Response, Blob } = env;
+  const seeds = [Request, Response, fetch, Blob];
 
   let len = seeds.length,
     i = len,