@dynatrace-sdk/client-query 1.5.1 → 1.7.2

package/esm/index.js

@@ -20,46 +20,34 @@ var __export = (target, all) => {
 };
 
 // packages/client/query/src/lib/apis/query-assistance-api.ts
-import { httpClient as defaultHttpClient } from "@dynatrace-sdk/http-client";
-
-// packages/platform/shared/utils/get-global-with-dt-runtime.ts
-var getGlobalWithDtRuntime = () => typeof globalThis !== "undefined" ? globalThis : window;
-
-// packages/platform/error-handlers/src/lib/add-global-error-serializer.ts
-function addGlobalErrorSerializer(serializer) {
-  const addGlobalErrorSerializerFunc = getAddGlobalErrorSerializer();
-  if (typeof addGlobalErrorSerializerFunc === "function") {
-    addGlobalErrorSerializerFunc(serializer);
-  } else {
-    console.warn("Missing addGlobalErrorSerializer function from sdk-web-runtime.");
-  }
-}
-function isGlobalErrorSerializerSupported() {
-  return typeof getAddGlobalErrorSerializer() === "function";
-}
-function getAddGlobalErrorSerializer() {
-  return getGlobalWithDtRuntime().dtRuntime?.errorHandlers?.addGlobalErrorSerializer;
-}
+import {
+  httpClient as defaultHttpClient,
+  isHttpClientResponseError,
+  isHttpClientAbortError
+} from "@dynatrace-sdk/http-client";
 
 // packages/client/query/src/lib/error-envelopes/api-client-error.ts
+import { ErrorType } from "@dynatrace-sdk/error-handlers";
 var ApiClientError = class extends Error {
-  errorType = "JS Error" /* COMMON */;
-  constructor(name, message) {
+  constructor(name, message, cause) {
     super(message);
+    this.cause = cause;
     this.name = name;
   }
+  errorType = ErrorType.COMMON;
 };
 function isApiClientError(e) {
   return e instanceof ApiClientError;
 }
 
 // packages/client/query/src/lib/error-envelopes/client-request-error.ts
+import { ErrorType as ErrorType2 } from "@dynatrace-sdk/error-handlers";
 var ClientRequestError = class extends ApiClientError {
   body;
   response;
-  constructor(name, response, body, message) {
-    super(name, message);
-    this.errorType = "Http Error" /* HTTP */;
+  constructor(name, response, body, message, cause) {
+    super(name, message, cause);
+    this.errorType = ErrorType2.HTTP;
     this.body = body;
     this.response = response;
   }
@@ -76,6 +64,11 @@ function isErrorEnvelopeError(e) {
 }
 
 // packages/client/query/src/lib/error-envelopes/error-serializer.ts
+import {
+  ErrorType as ErrorType3,
+  addGlobalErrorSerializer,
+  isGlobalErrorSerializerSupported
+} from "@dynatrace-sdk/error-handlers";
 var apiClientErrorSerializer = async (error) => {
   if (isClientRequestError(error)) {
     const status = error.response.status;
@@ -85,8 +78,9 @@ var apiClientErrorSerializer = async (error) => {
       status,
       message,
       stack: error.stack,
-      type: "Http Error" /* HTTP */,
+      type: ErrorType3.HTTP,
       body: error.body,
+      cause: error.cause,
       ...getOptionalErrorRef(error.body)
     };
   } else if (isApiClientError(error)) {
@@ -94,7 +88,8 @@ var apiClientErrorSerializer = async (error) => {
       name: error.name,
       message: error.message,
       stack: error.stack,
-      type: "JS Error" /* COMMON */
+      type: ErrorType3.COMMON,
+      cause: error.cause
     };
   }
 };
@@ -113,15 +108,23 @@ function getOptionalErrorRef(body) {
 }
 
 // packages/client/query/src/lib/error-envelopes/get-error-message.ts
+function serializeData(data) {
+  try {
+    return JSON.stringify(data);
+  } catch (e) {
+    return String(data);
+  }
+}
 function getMessagesFromErrorDetails(details) {
   const messages = [];
   Object.entries(details).forEach(([name, data]) => {
+    const serializedData = serializeData(data);
     switch (name) {
       case "missingScopes":
-        messages.push(`Missing scopes: ${data}`);
+        messages.push(`Missing scopes: ${serializedData}`);
         break;
       default:
-        messages.push(`${name}: ${data}`);
+        messages.push(`${name}: ${serializedData}`);
     }
   }, []);
   return messages;
@@ -1489,94 +1492,102 @@ var QueryAssistanceClient = class {
     const headerParameters = {
       ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
     };
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:verify`,
-      method: "POST",
-      requestBodyType: "json",
-      body: encodedBody,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...headerParameters
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:verify`,
+        method: "POST",
+        requestBodyType: "json",
+        body: encodedBody,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...headerParameters
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200].includes(status);
         }
-        return [400, 500].includes(status);
+      });
+      const responseValue = await response.body("json");
+      try {
+        return fromJson19(responseValue);
+      } catch (err) {
+        throw new InvalidResponseError(
+          `QueryAssistanceClient.query:verify:200`,
+          err,
+          responseValue,
+          void 0,
+          void 0
+        );
       }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "The supplied request is wrong.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+    } catch (e) {
+      if (isHttpClientAbortError(e) || isInvalidResponseError(e)) {
+        throw e;
+      }
+      if (!isHttpClientResponseError(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
+      }
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "The supplied request is wrong."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:verify:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:verify:400`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:verify:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:verify:500`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson19(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:verify:${response.status}`,
-            err,
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            void 0,
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`),
+            e
           );
         }
       }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
-      }
     }
   }
   async queryParse(config) {
@@ -1587,97 +1598,105 @@ var QueryAssistanceClient = class {
     const headerParameters = {
       ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
     };
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:parse`,
-      method: "POST",
-      requestBodyType: "json",
-      body: encodedBody,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...headerParameters
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:parse`,
+        method: "POST",
+        requestBodyType: "json",
+        body: encodedBody,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...headerParameters
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200].includes(status);
         }
-        return [400, 500].includes(status);
+      });
+      const responseValue = await response.body("json");
+      try {
+        return fromJson6(responseValue);
+      } catch (err) {
+        throw new InvalidResponseError(
+          `QueryAssistanceClient.query:parse:200`,
+          err,
+          responseValue,
+          void 0,
+          void 0
+        );
       }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(
+    } catch (e) {
+      if (isHttpClientAbortError(e) || isInvalidResponseError(e)) {
+        throw e;
+      }
+      if (!isHttpClientResponseError(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
+      }
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
               errorBody,
-              "The supplied request is wrong. Either the query itself or other parameters are wrong."
-            )
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+              getErrorMessage(
+                errorBody,
+                "The supplied request is wrong. Either the query itself or other parameters are wrong."
+              ),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:parse:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:parse:400`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:parse:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:parse:500`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson6(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:parse:${response.status}`,
-            err,
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            void 0,
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`),
+            e
           );
         }
       }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
-      }
     }
   }
   async queryAutocomplete(config) {
@@ -1688,104 +1707,116 @@ var QueryAssistanceClient = class {
     const headerParameters = {
       ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
     };
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:autocomplete`,
-      method: "POST",
-      requestBodyType: "json",
-      body: encodedBody,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...headerParameters
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:autocomplete`,
+        method: "POST",
+        requestBodyType: "json",
+        body: encodedBody,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...headerParameters
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200].includes(status);
         }
-        return [400, 500].includes(status);
+      });
+      const responseValue = await response.body("json");
+      try {
+        return fromJson5(responseValue);
+      } catch (err) {
+        throw new InvalidResponseError(
+          `QueryAssistanceClient.query:autocomplete:200`,
+          err,
+          responseValue,
+          void 0,
+          void 0
+        );
       }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(
+    } catch (e) {
+      if (isHttpClientAbortError(e) || isInvalidResponseError(e)) {
+        throw e;
+      }
+      if (!isHttpClientResponseError(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
+      }
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
               errorBody,
-              "The supplied request is wrong. Either the query itself or other parameters are wrong."
-            )
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+              getErrorMessage(
+                errorBody,
+                "The supplied request is wrong. Either the query itself or other parameters are wrong."
+              ),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:autocomplete:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:autocomplete:400`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryAssistanceClient.query:autocomplete:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:autocomplete:500`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson5(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryAssistanceClient.query:autocomplete:${response.status}`,
-            err,
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            void 0,
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`),
+            e
           );
         }
       }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
-      }
     }
   }
 };
 var queryAssistanceClient = /* @__PURE__ */ new QueryAssistanceClient(defaultHttpClient);
 
 // packages/client/query/src/lib/apis/query-execution-api.ts
-import { httpClient as defaultHttpClient2 } from "@dynatrace-sdk/http-client";
+import {
+  httpClient as defaultHttpClient2,
+  isHttpClientResponseError as isHttpClientResponseError2,
+  isHttpClientAbortError as isHttpClientAbortError2
+} from "@dynatrace-sdk/http-client";
 
 // packages/client/query/src/lib/models/execute-request.transformation.ts
 var execute_request_transformation_exports = {};
@@ -3062,102 +3093,104 @@ var QueryExecutionClient = class {
       "request-timeout-milliseconds": config.requestTimeoutMilliseconds,
       enrich: config.enrich
     });
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:poll${query}`,
-      method: "GET",
-      headers: {
-        Accept: "application/json"
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:poll${query}`,
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200].includes(status);
         }
-        return [400, 410, 500].includes(status);
+      });
+      const responseValue = await response.body("json");
+      try {
+        return fromJson34(responseValue);
+      } catch (err) {
+        throw new InvalidResponseError(`QueryExecutionClient.query:poll:200`, err, responseValue, void 0, void 0);
       }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(
+    } catch (e) {
+      if (isHttpClientAbortError2(e) || isInvalidResponseError(e)) {
+        throw e;
+      }
+      if (!isHttpClientResponseError2(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
+      }
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
               errorBody,
-              "The supplied request is wrong. Either the query itself or other parameters are wrong."
-            )
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+              getErrorMessage(
+                errorBody,
+                "The supplied request is wrong. Either the query itself or other parameters are wrong."
+              ),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:poll:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:poll:400`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 410: {
-        const responseValue = await response.body("text");
-        throw new ClientRequestError(
-          `410`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
-        );
-      }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
+        case 410: {
+          const responseValue = await response.body("text");
+          throw new ClientRequestError(
+            `410`,
             response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
-          }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:poll:500`,
-            err,
             responseValue,
-            "ErrorEnvelope",
-            void 0
+            getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
           );
         }
-      }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson34(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:poll:${response.status}`,
-            err,
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:poll:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            void 0,
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`),
+            e
           );
         }
       }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
-      }
     }
   }
   async queryExecute(config) {
@@ -3169,133 +3202,241 @@ var QueryExecutionClient = class {
     const headerParameters = {
       ...config.authorization !== void 0 && { Authorization: String(config.authorization) }
     };
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:execute${query}`,
-      method: "POST",
-      requestBodyType: "json",
-      body: encodedBody,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...headerParameters
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:execute${query}`,
+        method: "POST",
+        requestBodyType: "json",
+        body: encodedBody,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...headerParameters
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200, 202].includes(status);
         }
-        return [400, 500, 503].includes(status);
-      }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(
-              errorBody,
-              "The supplied request is wrong. Either the query itself or other parameters are wrong."
-            )
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+      });
+      switch (response.status) {
+        case 200: {
+          const responseValue = await response.body("json");
+          try {
+            return fromJson35(responseValue);
+          } catch (err) {
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:${response.status}`,
+              err,
+              responseValue,
+              void 0,
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:execute:400`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+        case 202: {
+          const responseValue = await response.body("json");
+          try {
+            return fromJson35(responseValue);
+          } catch (err) {
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:${response.status}`,
+              err,
+              responseValue,
+              void 0,
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:execute:500`,
-            err,
-            responseValue,
-            "ErrorEnvelope",
-            void 0
-          );
         }
-      }
-      case 503: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "503",
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
             response,
-            errorBody,
-            getErrorMessage(errorBody, "Service is unavailable.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
-          }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:execute:503`,
-            err,
             responseValue,
-            "ErrorEnvelope",
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
           );
         }
       }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson35(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:execute:${response.status}`,
-            err,
-            responseValue,
-            void 0,
-            void 0
-          );
-        }
+    } catch (e) {
+      if (isHttpClientAbortError2(e) || isInvalidResponseError(e) || isClientRequestError(e)) {
+        throw e;
       }
-      case 202: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson35(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:execute:${response.status}`,
-            err,
-            responseValue,
-            void 0,
-            void 0
-          );
-        }
+      if (!isHttpClientResponseError2(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
       }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
+              errorBody,
+              getErrorMessage(
+                errorBody,
+                "The supplied request is wrong. Either the query itself or other parameters are wrong."
+              ),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        case 403: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "403",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "Insufficient permissions."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:403`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        case 429: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "429",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "Too many requests."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:429`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        case 503: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "503",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "Service is unavailable."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:execute:503`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        default: {
+          if (response.status >= 400 && response.status <= 499) {
+            const responseValue = await response.body("json");
+            try {
+              const errorBody = fromJson15(responseValue);
+              throw new ErrorEnvelopeError("4XX", response, errorBody, getErrorMessage(errorBody, "Client error."), e);
+            } catch (err) {
+              if (err instanceof ErrorEnvelopeError) {
+                throw err;
+              }
+              throw new InvalidResponseError(
+                `QueryExecutionClient.query:execute:4XX`,
+                err,
+                responseValue,
+                "ErrorEnvelope",
+                void 0
+              );
+            }
+          } else if (response.status >= 500 && response.status <= 599) {
+            const responseValue = await response.body("json");
+            try {
+              const errorBody = fromJson15(responseValue);
+              throw new ErrorEnvelopeError("5XX", response, errorBody, getErrorMessage(errorBody, "Server error."), e);
+            } catch (err) {
+              if (err instanceof ErrorEnvelopeError) {
+                throw err;
+              }
+              throw new InvalidResponseError(
+                `QueryExecutionClient.query:execute:5XX`,
+                err,
+                responseValue,
+                "ErrorEnvelope",
+                void 0
+              );
+            }
+          } else {
+            const responseValue = await response.body("text").catch(() => "");
+            throw new ClientRequestError(
+              `${response.status}`,
+              response,
+              responseValue,
+              getErrorMessage(
+                responseValue,
+                `Unexpected api response: code=${response.status} body="${responseValue}"`
+              )
+            );
+          }
+        }
       }
     }
   }
@@ -3303,106 +3444,127 @@ var QueryExecutionClient = class {
     if (!config) {
       throw new ApiClientError("API client error", "API client call is missing mandatory config parameter");
     }
-    const query = toQueryString({ "request-token": config.requestToken });
-    const response = await this.httpClient.send({
-      url: `/platform/storage/query/v1/query:cancel${query}`,
-      method: "POST",
-      headers: {
-        Accept: "application/json"
-      },
-      abortSignal: config.abortSignal,
-      statusValidator: (status) => {
-        if (200 <= status && status < 300) {
-          return true;
+    const query = toQueryString({ "request-token": config.requestToken, enrich: config.enrich });
+    try {
+      const response = await this.httpClient.send({
+        url: `/platform/storage/query/v1/query:cancel${query}`,
+        method: "POST",
+        headers: {
+          Accept: "application/json"
+        },
+        abortSignal: config.abortSignal,
+        statusValidator: (status) => {
+          return [200, 202].includes(status);
         }
-        return [400, 410, 500].includes(status);
-      }
-    });
-    switch (response.status) {
-      case 400: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "400",
-            response,
-            errorBody,
-            getErrorMessage(
-              errorBody,
-              "The supplied request is wrong. Either the query itself or other parameters are wrong."
-            )
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+      });
+      switch (response.status) {
+        case 200: {
+          const responseValue = await response.body("json");
+          try {
+            return fromJson34(responseValue);
+          } catch (err) {
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:cancel:${response.status}`,
+              err,
+              responseValue,
+              void 0,
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:cancel:400`,
-            err,
+        }
+        case 202: {
+          return;
+        }
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            "ErrorEnvelope",
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
           );
         }
       }
-      case 410: {
-        const responseValue = await response.body("text");
-        throw new ClientRequestError(
-          `410`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
-        );
+    } catch (e) {
+      if (isHttpClientAbortError2(e) || isInvalidResponseError(e) || isClientRequestError(e)) {
+        throw e;
       }
-      case 500: {
-        const responseValue = await response.body("json");
-        try {
-          const errorBody = fromJson15(responseValue);
-          throw new ErrorEnvelopeError(
-            "500",
-            response,
-            errorBody,
-            getErrorMessage(errorBody, "An internal server error has occurred.")
-          );
-        } catch (err) {
-          if (err instanceof ErrorEnvelopeError) {
-            throw err;
+      if (!isHttpClientResponseError2(e)) {
+        throw new ApiClientError("UnexpectedError", "Unexpected error", e);
+      }
+      const response = e.response;
+      switch (response.status) {
+        case 400: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "400",
+              response,
+              errorBody,
+              getErrorMessage(
+                errorBody,
+                "The supplied request is wrong. Either the query itself or other parameters are wrong."
+              ),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:cancel:400`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
           }
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:cancel:500`,
-            err,
+        }
+        case 410: {
+          const responseValue = await response.body("text");
+          throw new ClientRequestError(
+            `410`,
+            response,
             responseValue,
-            "ErrorEnvelope",
-            void 0
+            getErrorMessage(responseValue, `The query for the given request-token is not available anymore.`)
           );
         }
-      }
-      case 200: {
-        const responseValue = await response.body("json");
-        try {
-          return fromJson34(responseValue);
-        } catch (err) {
-          throw new InvalidResponseError(
-            `QueryExecutionClient.query:cancel:${response.status}`,
-            err,
+        case 500: {
+          const responseValue = await response.body("json");
+          try {
+            const errorBody = fromJson15(responseValue);
+            throw new ErrorEnvelopeError(
+              "500",
+              response,
+              errorBody,
+              getErrorMessage(errorBody, "An internal server error has occurred."),
+              e
+            );
+          } catch (err) {
+            if (err instanceof ErrorEnvelopeError) {
+              throw err;
+            }
+            throw new InvalidResponseError(
+              `QueryExecutionClient.query:cancel:500`,
+              err,
+              responseValue,
+              "ErrorEnvelope",
+              void 0
+            );
+          }
+        }
+        default: {
+          const responseValue = await response.body("text").catch(() => "");
+          throw new ClientRequestError(
+            `${response.status}`,
+            response,
             responseValue,
-            void 0,
-            void 0
+            getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`),
+            e
           );
         }
       }
-      case 202: {
-        return;
-      }
-      default: {
-        const responseValue = await response.body("text").catch(() => "");
-        throw new ClientRequestError(
-          `${response.status}`,
-          response,
-          responseValue,
-          getErrorMessage(responseValue, `Unexpected api response: code=${response.status} body="${responseValue}"`)
-        );
-      }
     }
   }
 };
@@ -3430,6 +3592,7 @@ var FieldTypeType = /* @__PURE__ */ ((FieldTypeType2) => {
   FieldTypeType2["GeoPoint"] = "geo_point";
   FieldTypeType2["Array"] = "array";
   FieldTypeType2["Record"] = "record";
+  FieldTypeType2["Uid"] = "uid";
   FieldTypeType2["Undefined"] = "undefined";
   return FieldTypeType2;
 })(FieldTypeType || {});
@@ -3484,6 +3647,7 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2["MetricKey"] = "METRIC_KEY";
   TokenType2["Variable"] = "VARIABLE";
   TokenType2["EndComment"] = "END_COMMENT";
+  TokenType2["UidValue"] = "UID_VALUE";
   return TokenType2;
 })(TokenType || {});
 export {