@dynatrace-sdk/client-classic-environment-v2 3.7.1 → 3.7.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 @dynatrace-sdk/client-classic-environment-v2
 
+## 3.7.2
+
+### Patch Changes
+
+- Improve performance of date transformations. (APPDEV-12840)
+
 ## 3.7.1
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @dynatrace-sdk/client-classic-environment-v2
 
-[![npm](https://img.shields.io/badge/npm-v3.7.1-blue)](https://www.npmjs.com/package/@dynatrace-sdk/client-classic-environment-v2/v/3.7.1)
+[![npm](https://img.shields.io/badge/npm-v3.7.2-blue)](https://www.npmjs.com/package/@dynatrace-sdk/client-classic-environment-v2/v/3.7.2)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 

package/cjs/index.js

@@ -389,65 +389,92 @@ 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;
-    }
-    if (!key || !ruleKey) {
-      return false;
+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;
+    }
+    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) {
-  if (key.includes(".")) {
-    const keyParts = key.split(".");
-    let currentKey = "";
-    return !!keyParts.find((keyPart) => {
-      currentKey = mergeKeys(currentKey, keyPart);
-      const isRoot = !currentKey.includes(".");
+  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) {
-        return !!keyPatterns.find((k) => potentialMatchForRoot(k, currentKey));
-      }
-      return !!keyPatterns.find((k) => potentialMatch(k, currentKey));
-    });
+        if (potentialMatchForRoot(pattern, currentKey))
+          return true;
+      } else if (potentialMatch(pattern, currentKey))
+        return true;
+    }
+    currentKeyEnd = dotIndex + 1;
   }
-  return !!keyPatterns.find((k) => potentialMatchForRoot(k, key));
+  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) {
@@ -467,49 +494,48 @@ function transformValue(value, rules, direction) {
   }
   return value;
 }
-function walk(obj, direction, keyPatterns, flatKeyPatterns, currentKey = "") {
-  if (keyPatterns.length <= 0) {
+function walk(obj, direction, rules, rulesCache, keyPatterns, currentKey = "") {
+  if (rules.length <= 0) {
     return obj;
   }
-  if (!partialMatch(currentKey, flatKeyPatterns)) {
+  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, keyPatterns, flatKeyPatterns, currentKey);
-      } else {
-        const match = matchKey(currentKey, keyPatterns);
-        if (match) {
-          obj[idx] = transformValue(obj[idx], match[1], direction);
-        }
+        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, keyPatterns);
+      const match = matchKey(mergedKey, rules, rulesCache);
       if (match) {
         obj[key] = transformValue(obj[key], match[1], direction);
       }
-      walk(obj[key], direction, keyPatterns, flatKeyPatterns, mergedKey);
+      walk(obj[key], direction, rules, rulesCache, keyPatterns, mergedKey);
     }
   }
   return obj;
 }
-function flattenKeys(keys) {
-  return keys.map((k) => Array.isArray(k) ? k[0] : k);
+function flattenKeyPatterns(keyPatterns) {
+  return keyPatterns.map((k) => Array.isArray(k) ? k[0] : k);
 }
-function transform(direction, object, keys) {
-  const flatKeys = flattenKeys(keys);
-  return walk(object, direction, keys, flatKeys);
+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/classic-environment-v2/src/lib/utils/url-helpers.ts

package/dynatrace-metadata.json

@@ -1,9 +1,9 @@
 {
   "dynagen": {
-    "version": "0.18.1",
+    "version": "0.19.2",
     "template": {
       "name": "@dynatrace-sdk/template-typescript-client",
-      "version": "0.33.6"
+      "version": "0.33.7"
     },
     "featureFlags": {}
   },

package/esm/index.js

@@ -88,65 +88,92 @@ 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;
-    }
-    if (!key || !ruleKey) {
-      return false;
+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;
+    }
+    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) {
-  if (key.includes(".")) {
-    const keyParts = key.split(".");
-    let currentKey = "";
-    return !!keyParts.find((keyPart) => {
-      currentKey = mergeKeys(currentKey, keyPart);
-      const isRoot = !currentKey.includes(".");
+  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) {
-        return !!keyPatterns.find((k) => potentialMatchForRoot(k, currentKey));
-      }
-      return !!keyPatterns.find((k) => potentialMatch(k, currentKey));
-    });
+        if (potentialMatchForRoot(pattern, currentKey))
+          return true;
+      } else if (potentialMatch(pattern, currentKey))
+        return true;
+    }
+    currentKeyEnd = dotIndex + 1;
   }
-  return !!keyPatterns.find((k) => potentialMatchForRoot(k, key));
+  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) {
@@ -166,49 +193,48 @@ function transformValue(value, rules, direction) {
   }
   return value;
 }
-function walk(obj, direction, keyPatterns, flatKeyPatterns, currentKey = "") {
-  if (keyPatterns.length <= 0) {
+function walk(obj, direction, rules, rulesCache, keyPatterns, currentKey = "") {
+  if (rules.length <= 0) {
     return obj;
   }
-  if (!partialMatch(currentKey, flatKeyPatterns)) {
+  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, keyPatterns, flatKeyPatterns, currentKey);
-      } else {
-        const match = matchKey(currentKey, keyPatterns);
-        if (match) {
-          obj[idx] = transformValue(obj[idx], match[1], direction);
-        }
+        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, keyPatterns);
+      const match = matchKey(mergedKey, rules, rulesCache);
       if (match) {
         obj[key] = transformValue(obj[key], match[1], direction);
       }
-      walk(obj[key], direction, keyPatterns, flatKeyPatterns, mergedKey);
+      walk(obj[key], direction, rules, rulesCache, keyPatterns, mergedKey);
     }
   }
   return obj;
 }
-function flattenKeys(keys) {
-  return keys.map((k) => Array.isArray(k) ? k[0] : k);
+function flattenKeyPatterns(keyPatterns) {
+  return keyPatterns.map((k) => Array.isArray(k) ? k[0] : k);
 }
-function transform(direction, object, keys) {
-  const flatKeys = flattenKeys(keys);
-  return walk(object, direction, keys, flatKeys);
+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/classic-environment-v2/src/lib/utils/url-helpers.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-sdk/client-classic-environment-v2",
-  "version": "3.7.1",
+  "version": "3.7.2",
   "description": "Client for the Dynatrace Environment API v2",
   "license": "Apache-2.0",
   "dependencies": {

package/types/packages/client/classic-environment-v2/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 {};