@dynatrace-sdk/client-query 1.20.0 → 1.20.2

package/CHANGELOG.md

@@ -2,9 +2,23 @@
 
 @dynatrace-sdk/client-query
 
+## 1.20.2
+
+### Patch Changes
+
+- Improve performance of date transformations. (APPDEV-12840)
+
+## 1.20.1
+
+### Patch Changes
+
+- Improve performance of payload transformations. (APPDEV-12840)
+- Remove generatedAt property from metadata file. (APPDEV-12696)
+
 ## 1.20.0
 
 ### Minor changes
+
 - Add request body parameter `includeTypes` to `ExecuteRequest`
 - Add header `dt-client-context` to all query endpoints
 - Add `enforce-query-consumption-limit` header to `/query:execute` and `/query:autocomplete` endpoints

package/README.md

@@ -1,6 +1,6 @@
 # @dynatrace-sdk/client-query
 
-[![npm](https://img.shields.io/badge/npm-v1.20.0-blue)](https://www.npmjs.com/package/@dynatrace-sdk/client-query/v/1.20.0)
+[![npm](https://img.shields.io/badge/npm-v1.20.2-blue)](https://www.npmjs.com/package/@dynatrace-sdk/client-query/v/1.20.2)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 Exposes an API to fetch records stored in Grail
@@ -528,7 +528,7 @@ It is guaranteed that every field of every record will have a corresponding type
 
 | Return type | Description |
 |---|---|
-|Promise<QueryPollResponse | void>|The query already finished.|
+|Promise<QueryPollResponse \| void>|The query already finished.|
 
 
 #### Throws

package/cjs/index.js

@@ -123,49 +123,93 @@ function mergeKeys(key1, key2) {
     return key1;
   return `${key1}.${key2}`;
 }
-function matchKey(key, keys) {
-  const match = keys.find((k) => {
-    const ruleKey = Array.isArray(k) ? k[0] : k;
-    if (key === ruleKey) {
-      return true;
+function matchKey(key, rules, cache) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  for (const rule of rules) {
+    const pattern = Array.isArray(rule) ? rule[0] : rule;
+    const config = Array.isArray(rule) ? rule[1] : defaultRuleConfig;
+    if (key === pattern) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
     }
-    if (!key || !ruleKey) {
-      return false;
+    let i = 0;
+    let j = 0;
+    const keyLen = key.length;
+    const patternLen = pattern.length;
+    let isMatch = true;
+    while (i < keyLen && j < patternLen) {
+      let keyPartEnd = key.indexOf(".", i);
+      let patternPartEnd = pattern.indexOf(".", j);
+      if (keyPartEnd === -1)
+        keyPartEnd = keyLen;
+      if (patternPartEnd === -1)
+        patternPartEnd = patternLen;
+      const keyPart = key.slice(i, keyPartEnd);
+      const patternPart = pattern.slice(j, patternPartEnd);
+      if (patternPart !== "*" && patternPart !== "**" && keyPart !== patternPart) {
+        isMatch = false;
+        break;
+      }
+      i = keyPartEnd + 1;
+      j = patternPartEnd + 1;
     }
-    const [keyParts, ruleKeyParts] = [key.split("."), ruleKey.split(".")];
-    const [keyPartsReversed, ruleKeyPartsReversed] = [[...keyParts].reverse(), [...ruleKeyParts].reverse()];
-    let wildcard = false;
-    let matchResult = true;
-    keyParts.forEach((keyPart, idx) => {
-      if (keyPart !== ruleKeyParts[idx] && !wildcard) {
-        if (ruleKeyParts[idx] === "**") {
-          wildcard = true;
-        } else if (ruleKeyParts[idx] === "*") {
-          wildcard = true;
-        } else {
-          matchResult = false;
+    if (isMatch) {
+      if (j < patternLen) {
+        const remaining = pattern.slice(j);
+        if (remaining !== "**" && remaining !== "*") {
+          isMatch = false;
         }
       }
-    });
-    wildcard = false;
-    keyPartsReversed.forEach((keyPart, idx) => {
-      if (keyPart !== ruleKeyPartsReversed[idx] && !wildcard) {
-        if (ruleKeyPartsReversed[idx] === "**") {
-          wildcard = true;
-        } else if (ruleKeyPartsReversed[idx] === "*") {
-          wildcard = true;
-        } else {
-          matchResult = false;
-        }
+      if (i < keyLen && pattern.slice(j - 1) !== "**") {
+        isMatch = false;
       }
-    });
-    return matchResult;
-  });
-  if (match) {
-    return Array.isArray(match) ? match : [match, defaultRuleConfig];
+    }
+    if (isMatch) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
+    }
   }
+  cache.set(key, null);
   return null;
 }
+var potentialMatchForRoot = (pattern, key) => pattern.startsWith(key) || pattern.startsWith("*") || pattern.startsWith("**");
+var potentialMatch = (pattern, key) => pattern.startsWith(key) || pattern.includes("*") || pattern.includes("**");
+function partialMatch(key, keyPatterns) {
+  const keyPatternsLen = keyPatterns.length;
+  if (!key.includes(".")) {
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (potentialMatchForRoot(pattern, key))
+        return true;
+    }
+    return false;
+  }
+  let dotIndex = -1;
+  let currentKeyEnd = 0;
+  while ((dotIndex = key.indexOf(".", currentKeyEnd)) !== -1) {
+    const currentKey = key.slice(0, dotIndex);
+    const isRoot = !currentKey.includes(".");
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (isRoot) {
+        if (potentialMatchForRoot(pattern, currentKey))
+          return true;
+      } else if (potentialMatch(pattern, currentKey))
+        return true;
+    }
+    currentKeyEnd = dotIndex + 1;
+  }
+  for (let i = 0; i < keyPatternsLen; i++) {
+    const pattern = keyPatterns[i];
+    if (potentialMatch(pattern, key))
+      return true;
+  }
+  return false;
+}
 var dateTimePattern = /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[+-]\d{2}:\d{2})?)$/i;
 function isDateLike(value) {
   if (typeof value === "string") {
@@ -184,37 +228,48 @@ function transformValue(value, rules, direction) {
   }
   return value;
 }
-function transform(direction, object, keys) {
-  function walk(obj, currentKey = "") {
-    if (Array.isArray(obj)) {
-      obj.forEach((item, idx) => {
-        const match = matchKey(currentKey, keys);
-        if (typeof item === "object" && item !== null) {
-          walk(item, currentKey);
-        } else if (match) {
-          obj[idx] = transformValue(obj[idx], match[1], direction);
-        }
-      });
-    }
-    if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
-      for (const key of Object.keys(obj)) {
-        const mergedKey = mergeKeys(currentKey, key);
-        const match = matchKey(mergedKey, keys);
-        if (match) {
-          obj[key] = transformValue(obj[key], match[1], direction);
-        }
-        walk(obj[key], mergedKey);
+function walk(obj, direction, rules, rulesCache, keyPatterns, currentKey = "") {
+  if (rules.length <= 0) {
+    return obj;
+  }
+  if (!partialMatch(currentKey, keyPatterns)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    const match = matchKey(currentKey, rules, rulesCache);
+    obj.forEach((item, idx) => {
+      if (typeof item === "object" && item !== null) {
+        walk(item, direction, rules, rulesCache, keyPatterns, currentKey);
+      } else if (match) {
+        obj[idx] = transformValue(obj[idx], match[1], direction);
+      }
+    });
+  }
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    for (const key of Object.keys(obj)) {
+      const mergedKey = mergeKeys(currentKey, key);
+      const match = matchKey(mergedKey, rules, rulesCache);
+      if (match) {
+        obj[key] = transformValue(obj[key], match[1], direction);
       }
+      walk(obj[key], direction, rules, rulesCache, keyPatterns, mergedKey);
     }
-    return obj;
   }
-  return walk(object);
+  return obj;
+}
+function flattenKeyPatterns(keyPatterns) {
+  return keyPatterns.map((k) => Array.isArray(k) ? k[0] : k);
+}
+function transform(direction, object, rules) {
+  const flatKeyPatterns = flattenKeyPatterns(rules);
+  const rulesCache = /* @__PURE__ */ new Map();
+  return walk(object, direction, rules, rulesCache, flatKeyPatterns);
 }
-function transformRequest(object, keys) {
-  return transform("from", object, keys);
+function transformRequest(object, rules) {
+  return transform("from", object, rules);
 }
-function transformResponse(object, keys) {
-  return transform("to", object, keys);
+function transformResponse(object, rules) {
+  return transform("to", object, rules);
 }
 
 // packages/client/query/src/lib/apis/query-assistance-api.ts

package/dynatrace-metadata.json

@@ -1,10 +1,9 @@
 {
   "dynagen": {
-    "version": "0.18.0",
-    "generatedAt": "2025-03-31T11:21:40.514Z",
+    "version": "0.19.2",
     "template": {
       "name": "@dynatrace-sdk/template-typescript-client",
-      "version": "0.33.2"
+      "version": "0.33.7"
     },
     "featureFlags": {
       "typeguards": true

package/esm/index.js

@@ -88,49 +88,93 @@ function mergeKeys(key1, key2) {
     return key1;
   return `${key1}.${key2}`;
 }
-function matchKey(key, keys) {
-  const match = keys.find((k) => {
-    const ruleKey = Array.isArray(k) ? k[0] : k;
-    if (key === ruleKey) {
-      return true;
+function matchKey(key, rules, cache) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  for (const rule of rules) {
+    const pattern = Array.isArray(rule) ? rule[0] : rule;
+    const config = Array.isArray(rule) ? rule[1] : defaultRuleConfig;
+    if (key === pattern) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
     }
-    if (!key || !ruleKey) {
-      return false;
+    let i = 0;
+    let j = 0;
+    const keyLen = key.length;
+    const patternLen = pattern.length;
+    let isMatch = true;
+    while (i < keyLen && j < patternLen) {
+      let keyPartEnd = key.indexOf(".", i);
+      let patternPartEnd = pattern.indexOf(".", j);
+      if (keyPartEnd === -1)
+        keyPartEnd = keyLen;
+      if (patternPartEnd === -1)
+        patternPartEnd = patternLen;
+      const keyPart = key.slice(i, keyPartEnd);
+      const patternPart = pattern.slice(j, patternPartEnd);
+      if (patternPart !== "*" && patternPart !== "**" && keyPart !== patternPart) {
+        isMatch = false;
+        break;
+      }
+      i = keyPartEnd + 1;
+      j = patternPartEnd + 1;
     }
-    const [keyParts, ruleKeyParts] = [key.split("."), ruleKey.split(".")];
-    const [keyPartsReversed, ruleKeyPartsReversed] = [[...keyParts].reverse(), [...ruleKeyParts].reverse()];
-    let wildcard = false;
-    let matchResult = true;
-    keyParts.forEach((keyPart, idx) => {
-      if (keyPart !== ruleKeyParts[idx] && !wildcard) {
-        if (ruleKeyParts[idx] === "**") {
-          wildcard = true;
-        } else if (ruleKeyParts[idx] === "*") {
-          wildcard = true;
-        } else {
-          matchResult = false;
+    if (isMatch) {
+      if (j < patternLen) {
+        const remaining = pattern.slice(j);
+        if (remaining !== "**" && remaining !== "*") {
+          isMatch = false;
         }
       }
-    });
-    wildcard = false;
-    keyPartsReversed.forEach((keyPart, idx) => {
-      if (keyPart !== ruleKeyPartsReversed[idx] && !wildcard) {
-        if (ruleKeyPartsReversed[idx] === "**") {
-          wildcard = true;
-        } else if (ruleKeyPartsReversed[idx] === "*") {
-          wildcard = true;
-        } else {
-          matchResult = false;
-        }
+      if (i < keyLen && pattern.slice(j - 1) !== "**") {
+        isMatch = false;
       }
-    });
-    return matchResult;
-  });
-  if (match) {
-    return Array.isArray(match) ? match : [match, defaultRuleConfig];
+    }
+    if (isMatch) {
+      const result = [pattern, config];
+      cache.set(key, result);
+      return result;
+    }
   }
+  cache.set(key, null);
   return null;
 }
+var potentialMatchForRoot = (pattern, key) => pattern.startsWith(key) || pattern.startsWith("*") || pattern.startsWith("**");
+var potentialMatch = (pattern, key) => pattern.startsWith(key) || pattern.includes("*") || pattern.includes("**");
+function partialMatch(key, keyPatterns) {
+  const keyPatternsLen = keyPatterns.length;
+  if (!key.includes(".")) {
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (potentialMatchForRoot(pattern, key))
+        return true;
+    }
+    return false;
+  }
+  let dotIndex = -1;
+  let currentKeyEnd = 0;
+  while ((dotIndex = key.indexOf(".", currentKeyEnd)) !== -1) {
+    const currentKey = key.slice(0, dotIndex);
+    const isRoot = !currentKey.includes(".");
+    for (let i = 0; i < keyPatternsLen; i++) {
+      const pattern = keyPatterns[i];
+      if (isRoot) {
+        if (potentialMatchForRoot(pattern, currentKey))
+          return true;
+      } else if (potentialMatch(pattern, currentKey))
+        return true;
+    }
+    currentKeyEnd = dotIndex + 1;
+  }
+  for (let i = 0; i < keyPatternsLen; i++) {
+    const pattern = keyPatterns[i];
+    if (potentialMatch(pattern, key))
+      return true;
+  }
+  return false;
+}
 var dateTimePattern = /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[+-]\d{2}:\d{2})?)$/i;
 function isDateLike(value) {
   if (typeof value === "string") {
@@ -149,37 +193,48 @@ function transformValue(value, rules, direction) {
   }
   return value;
 }
-function transform(direction, object, keys) {
-  function walk(obj, currentKey = "") {
-    if (Array.isArray(obj)) {
-      obj.forEach((item, idx) => {
-        const match = matchKey(currentKey, keys);
-        if (typeof item === "object" && item !== null) {
-          walk(item, currentKey);
-        } else if (match) {
-          obj[idx] = transformValue(obj[idx], match[1], direction);
-        }
-      });
-    }
-    if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
-      for (const key of Object.keys(obj)) {
-        const mergedKey = mergeKeys(currentKey, key);
-        const match = matchKey(mergedKey, keys);
-        if (match) {
-          obj[key] = transformValue(obj[key], match[1], direction);
-        }
-        walk(obj[key], mergedKey);
+function walk(obj, direction, rules, rulesCache, keyPatterns, currentKey = "") {
+  if (rules.length <= 0) {
+    return obj;
+  }
+  if (!partialMatch(currentKey, keyPatterns)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    const match = matchKey(currentKey, rules, rulesCache);
+    obj.forEach((item, idx) => {
+      if (typeof item === "object" && item !== null) {
+        walk(item, direction, rules, rulesCache, keyPatterns, currentKey);
+      } else if (match) {
+        obj[idx] = transformValue(obj[idx], match[1], direction);
+      }
+    });
+  }
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    for (const key of Object.keys(obj)) {
+      const mergedKey = mergeKeys(currentKey, key);
+      const match = matchKey(mergedKey, rules, rulesCache);
+      if (match) {
+        obj[key] = transformValue(obj[key], match[1], direction);
       }
+      walk(obj[key], direction, rules, rulesCache, keyPatterns, mergedKey);
     }
-    return obj;
   }
-  return walk(object);
+  return obj;
+}
+function flattenKeyPatterns(keyPatterns) {
+  return keyPatterns.map((k) => Array.isArray(k) ? k[0] : k);
+}
+function transform(direction, object, rules) {
+  const flatKeyPatterns = flattenKeyPatterns(rules);
+  const rulesCache = /* @__PURE__ */ new Map();
+  return walk(object, direction, rules, rulesCache, flatKeyPatterns);
 }
-function transformRequest(object, keys) {
-  return transform("from", object, keys);
+function transformRequest(object, rules) {
+  return transform("from", object, rules);
 }
-function transformResponse(object, keys) {
-  return transform("to", object, keys);
+function transformResponse(object, rules) {
+  return transform("to", object, rules);
 }
 
 // packages/client/query/src/lib/apis/query-assistance-api.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-sdk/client-query",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "description": "Exposes an API to fetch records stored in Grail.",
   "license": "Apache-2.0",
   "dependencies": {

package/types/packages/client/query/src/lib/utils/transformations.d.ts

@@ -2,6 +2,7 @@ type TransformRuleConfig = {
     force?: boolean;
     datetime?: boolean;
 };
-export declare function transformRequest<T = any>(object: T, keys: Array<string | [string, TransformRuleConfig]>): T;
-export declare function transformResponse<T = any>(object: T, keys: Array<string | [string, TransformRuleConfig]>): T;
+type TransformRulesParam = Array<string | [string, TransformRuleConfig]>;
+export declare function transformRequest<T = any>(object: T, rules: TransformRulesParam): T;
+export declare function transformResponse<T = any>(object: T, rules: TransformRulesParam): T;
 export {};