@tsed/schema 8.44.5 → 8.44.6

package/lib/esm/fn/compile.js

@@ -1,5 +1,5 @@
 import "../components/index.js";
-import { DecoratorTypes, getValue, isClass, isPlainObject, nameOf } from "@tsed/core";
+import { DecoratorTypes, getValue, isArray, isClass, isPlainObject, nameOf } from "@tsed/core";
 import { JsonSchema, SpecTypes } from "../domain/index.js";
 import { execMapper } from "../registries/JsonSchemaMapperContainer.js";
 import { getJsonEntityStore } from "../registries/JsonEntitiesContainer.js";
@@ -7,11 +7,49 @@ import { inlineRefs } from "../utils/inlineRefs.js";
 /**
  * @ignore
  */
-const CACHES = new Map();
+const CACHES = new WeakMap();
+/**
+ * Inline typeof on purpose: this runs for each option on every compile() call, and the
+ * `isPrimitive()`/`isNil()` helpers of @tsed/core made the cache hit ~50% slower.
+ * @ignore
+ */
+function isPrimitiveValue(value) {
+    return value === null || (typeof value !== "object" && typeof value !== "function");
+}
+/**
+ * Options holding only primitives and arrays of primitives (the usual `groups`, `customKeys`, `specType`...)
+ * give the same key with the native `JSON.stringify`, because the replacer below returns them unchanged.
+ * @ignore
+ */
+function hasOnlyPrimitiveValues(options) {
+    for (const key in options) {
+        // always set by compile() to an empty object
+        if (key === "components") {
+            continue;
+        }
+        const value = options[key];
+        if (isPrimitiveValue(value)) {
+            continue;
+        }
+        // an array with its own toJSON can return a class, that only the replacer turns into a name
+        if (!isArray(value) || value.toJSON !== undefined) {
+            return false;
+        }
+        for (let i = 0; i < value.length; i++) {
+            if (!isPrimitiveValue(value[i])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 /**
  * @ignore
  */
 function getKey(options) {
+    if (hasOnlyPrimitiveValues(options)) {
+        return JSON.stringify(options);
+    }
     return JSON.stringify(options, (key, value) => {
         if (value && !isPlainObject(value) && isClass(value)) {
             return nameOf(value);
@@ -23,32 +61,39 @@ function getKey(options) {
  * @ignore
  */
 function get(model, options) {
-    const cache = CACHES.get(model) || new Map();
-    CACHES.set(model, cache);
+    let cache = CACHES.get(model);
     const key = getKey(options);
-    if (!cache.has(key)) {
-        let schema;
-        if (model instanceof JsonSchema) {
-            schema = model.toJSON(options);
-        }
-        else {
-            const entity = getJsonEntityStore(model);
-            let mapper = "schema";
-            if (entity.is(DecoratorTypes.PARAM)) {
-                options = {
-                    ...options,
-                    root: true,
-                    groups: entity.schema.getGroups()
-                };
-                mapper = "item";
-            }
-            schema = execMapper(mapper, [entity.schema], options);
-        }
-        if (Object.keys(getValue(options, "components.schemas", {})).length) {
-            schema.definitions = options.components.schemas;
+    // compiled schemas are objects, never undefined
+    const cached = cache?.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    let schema;
+    if (model instanceof JsonSchema) {
+        schema = model.toJSON(options);
+    }
+    else {
+        const entity = getJsonEntityStore(model);
+        let mapper = "schema";
+        if (entity.is(DecoratorTypes.PARAM)) {
+            options = {
+                ...options,
+                root: true,
+                groups: entity.schema.getGroups()
+            };
+            mapper = "item";
         }
-        cache.set(key, options.inlineRefs ? inlineRefs(schema) : schema);
+        schema = execMapper(mapper, [entity.schema], options);
+    }
+    if (Object.keys(getValue(options, "components.schemas", {})).length) {
+        schema.definitions = options.components.schemas;
+    }
+    if (!cache) {
+        // a nested compile() of the same model may have created it in the meantime
+        cache = CACHES.get(model) ?? new Map();
+        CACHES.set(model, cache);
     }
+    cache.set(key, options.inlineRefs ? inlineRefs(schema) : schema);
     return cache.get(key);
 }
 /**

package/lib/esm/utils/matchGroups.js

@@ -1,4 +1,26 @@
 import picomatch from "picomatch";
+/**
+ * Compiled matchers per pattern. Patterns can come from the request (`includes`), so the cache is bounded
+ * in number of entries, and oversized patterns are compiled on each call instead of being kept.
+ * @ignore
+ */
+const MATCHERS = new Map();
+const MAX_MATCHERS = 1000;
+const MAX_CACHED_PATTERN_LENGTH = 256;
+function getMatcher(pattern) {
+    if (pattern.length > MAX_CACHED_PATTERN_LENGTH) {
+        return picomatch(pattern, {}, true);
+    }
+    let isMatch = MATCHERS.get(pattern);
+    if (!isMatch) {
+        isMatch = picomatch(pattern, {}, true);
+        if (MATCHERS.size >= MAX_MATCHERS) {
+            MATCHERS.clear();
+        }
+        MATCHERS.set(pattern, isMatch);
+    }
+    return isMatch;
+}
 function micromatch(list, patterns) {
     patterns = [].concat(patterns);
     list = [].concat(list);
@@ -6,17 +28,16 @@ function micromatch(list, patterns) {
     let keep = new Set();
     let items = new Set();
     let negatives = 0;
-    let onResult = (state) => {
-        items.add(state.output);
-    };
     for (let i = 0; i < patterns.length; i++) {
-        let isMatch = picomatch(String(patterns[i]), { onResult }, true);
+        const isMatch = getMatcher(String(patterns[i]));
         let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
         if (negated) {
             negatives++;
         }
         for (let item of list) {
             let matched = isMatch(item, true);
+            // same as the picomatch onResult option: collect the output of every tested item
+            items.add(matched.output);
             let match = negated ? !matched.isMatch : matched.isMatch;
             if (!match)
                 continue;
@@ -44,7 +65,7 @@ export function matchGroups(groups, compareWith = []) {
         }
     }
     if (groupsIncludes.length) {
-        return !micromatch(groups.filter((group) => !group.startsWith("!")), compareWith);
+        return !micromatch(groupsIncludes, compareWith);
     }
     return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/schema",
-  "version": "8.44.5",
+  "version": "8.44.6",
   "description": "JsonSchema module for Ts.ED Framework",
   "keywords": [
     "JsonSchema",
@@ -34,7 +34,7 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/openspec": "8.44.5",
+    "@tsed/openspec": "8.44.6",
     "change-case": "^5.4.4",
     "json-schema": "0.4.0",
     "picomatch": "4.0.4",
@@ -43,11 +43,11 @@
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "10.1.0",
-    "@tsed/barrels": "8.44.5",
-    "@tsed/core": "8.44.5",
-    "@tsed/hooks": "8.44.5",
-    "@tsed/openspec": "8.44.5",
-    "@tsed/typescript": "8.44.5",
+    "@tsed/barrels": "8.44.6",
+    "@tsed/core": "8.44.6",
+    "@tsed/hooks": "8.44.6",
+    "@tsed/openspec": "8.44.6",
+    "@tsed/typescript": "8.44.6",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.2",