@tsed/schema 8.13.4 → 8.14.0-rc.1

package/lib/esm/decorators/common/forwardGroups.js

@@ -10,6 +10,6 @@ import { JsonEntityFn } from "./jsonEntityFn.js";
  */
 export function ForwardGroups(bool = true) {
     return JsonEntityFn((entity) => {
-        entity.schema.$forwardGroups = bool;
+        entity.schema.forwardGroups(bool);
     });
 }

package/lib/esm/decorators/common/groups.js

@@ -1,6 +1,4 @@
 import { DecoratorTypes, isArray } from "@tsed/core";
-import { matchGroups } from "../../utils/matchGroups.js";
-import { CustomKey } from "./customKey.js";
 import { JsonEntityFn } from "./jsonEntityFn.js";
 /**
  * @ignore
@@ -15,30 +13,21 @@ function groupsClass(groups, entity) {
 }
 export function Groups(...groups) {
     return JsonEntityFn((entity) => {
-        switch (entity.decoratorType) {
-            case DecoratorTypes.CLASS:
-                groupsClass(groups, entity);
-                break;
-            case DecoratorTypes.PROP:
-                CustomKey("x-groups", groups)(entity.target, entity.propertyKey);
-                entity.schema.$hooks.on("groups", (prev, givenGroups) => {
-                    if (!prev) {
-                        if (matchGroups(groups, givenGroups)) {
-                            return true;
-                        }
-                    }
-                    return prev;
-                });
-                break;
-            case DecoratorTypes.PARAM:
-                let groupsName = "";
-                if (groups.length == 2 && isArray(groups[1])) {
-                    groupsName = groups[0];
-                    groups = groups[1];
-                }
-                entity.parameter.groups = groups;
-                entity.parameter.groupsName = groupsName;
-                break;
+        if (entity.is(DecoratorTypes.CLASS)) {
+            groupsClass(groups, entity);
+            return;
+        }
+        if (entity.is(DecoratorTypes.PROP)) {
+            entity.schema.groups(groups, true);
+            return;
+        }
+        if (entity.is(DecoratorTypes.PARAM)) {
+            let groupsName = "";
+            if (groups.length == 2 && isArray(groups[1])) {
+                groupsName = groups[0];
+                groups = groups[1];
+            }
+            entity.parameter.schema().groups(groups).groupsName(groupsName);
         }
     });
 }

package/lib/esm/decorators/common/oneOf.js

@@ -16,6 +16,6 @@ import { JsonEntityFn } from "./jsonEntityFn.js";
  */
 export function OneOf(...oneOf) {
     return JsonEntityFn((entity) => {
-        entity.itemSchema.oneOf(oneOf);
+        entity.schema.oneOf(oneOf);
     });
 }

package/lib/esm/decorators/generics/genericOf.js

@@ -1,12 +1,5 @@
-import { isObject } from "@tsed/core";
+import { DecoratorTypes } from "@tsed/core";
 import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
-import { string } from "../../fn/string.js";
-/**
- * @ignore
- */
-function isEnum(type) {
-    return isObject(type) && !("toJSON" in type);
-}
 /**
  * Set the types of a Generic class.
  *
@@ -74,17 +67,15 @@ function isEnum(type) {
  * @generics
  */
 export function GenericOf(...generics) {
-    const nestedGenerics = [
-        generics.map((type) => {
-            if (isEnum(type)) {
-                return string().enum(Object.values(type));
-            }
-            return type;
-        })
-    ];
+    const nestedGenerics = [generics];
     const decorator = (...args) => {
         const store = JsonEntityStore.from(...args);
-        store.nestedGenerics = nestedGenerics;
+        if (store.is(DecoratorTypes.PARAM)) {
+            store.parameter.schema().genericOf(...nestedGenerics);
+        }
+        else {
+            store.schema.genericOf(...nestedGenerics);
+        }
     };
     decorator.Nested = (...generics) => {
         nestedGenerics.push(generics);

package/lib/esm/decorators/generics/generics.js

@@ -4,17 +4,17 @@ import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
  *
  * See @@GenericOf@@ decorator for more details.
  *
- * @param generics
  * @decorator
  * @validation
  * @swagger
  * @schema
  * @input
  * @generics
+ * @param genericLabels
  */
-export function Generics(...generics) {
+export function Generics(...genericLabels) {
     return (target) => {
         const storedSchema = JsonEntityStore.from(target);
-        storedSchema.schema.genericLabels = generics;
+        storedSchema.schema.genericLabels(genericLabels);
     };
 }

package/lib/esm/decorators/operations/redirect.js

@@ -14,7 +14,7 @@ export function Redirect(...args) {
         options.meta = value;
         return options;
     }, { status: 302, url: "", meta: {} });
-    return useDecorators(Returns(status).Location(url, meta), JsonEntityFn((entity) => {
+    return useDecorators(Returns(status, String).Location(url, meta), JsonEntityFn((entity) => {
         entity.operation?.setRedirection(status);
     }));
 }

package/lib/esm/decorators/operations/returns.js

@@ -1,27 +1,9 @@
-import { decorateMethodsOf, decoratorTypeOf, DecoratorTypes, isArray, isCollection, isObject, isPlainObject, isPrimitiveOrPrimitiveClass, isString } from "@tsed/core";
+import { decorateMethodsOf, decoratorTypeOf, DecoratorTypes, isArray, isCollection, isPlainObject, isPrimitiveOrPrimitiveClass, isString } from "@tsed/core";
 import { getStatusMessage } from "../../constants/httpStatusMessages.js";
 import { DecoratorContext } from "../../domain/DecoratorContext.js";
 import { JsonEntityStore } from "../../domain/JsonEntityStore.js";
-import { JsonParameter } from "../../domain/JsonParameter.js";
-import { JsonSchema } from "../../domain/JsonSchema.js";
-import { string } from "../../fn/string.js";
 import { getStatusModel } from "../../utils/defineStatusModel.js";
-import { isSuccessStatus } from "../../utils/isSuccessStatus.js";
 import { mapHeaders } from "../../utils/mapHeaders.js";
-/**
- * @ignore
- */
-function isEnum(type) {
-    return isObject(type) && !("toJSON" in type);
-}
-function mapGenerics(types) {
-    return types.map((type) => {
-        if (isEnum(type)) {
-            return string().enum(Object.values(type));
-        }
-        return type;
-    });
-}
 /**
  * @ignore
  */
@@ -44,6 +26,7 @@ class ReturnDecoratorContext extends DecoratorContext {
             "headers",
             "schema",
             "title",
+            "label",
             "groups",
             "allowedGroups",
             "location",
@@ -83,6 +66,9 @@ class ReturnDecoratorContext extends DecoratorContext {
         return this.headers({ [key]: value });
     }
     location(path, meta = {}) {
+        if (!this.get("model")) {
+            this.model(String);
+        }
         this.headers({
             Location: {
                 ...meta,
@@ -110,7 +96,9 @@ class ReturnDecoratorContext extends DecoratorContext {
         this.checkPrimitive(model);
         this.checkCollection(model);
         this.addAction((ctx) => {
-            this.get("schema").nestedGenerics.push(mapGenerics(generics));
+            const currentGenerics = ctx.get("generics") || [];
+            currentGenerics.push(generics);
+            ctx.get("schema").genericOf(...currentGenerics);
         });
         return this;
     }
@@ -119,11 +107,14 @@ class ReturnDecoratorContext extends DecoratorContext {
         this.checkPrimitive(model);
         this.addAction(() => {
             const schema = this.get("schema");
-            if (isCollection(model)) {
-                schema?.itemSchema({ type: types[0] });
-            }
-            else {
-                schema?.nestedGenerics.push(mapGenerics(types));
+            if (schema) {
+                if (isCollection(model)) {
+                    schema.itemSchema({ type: types[0] });
+                }
+                else {
+                    this.set("generics", [types]);
+                    schema.genericOf(types);
+                }
             }
         });
         return this;
@@ -151,8 +142,15 @@ class ReturnDecoratorContext extends DecoratorContext {
         this.set("examples", isString(examples) ? [examples] : examples);
         return this;
     }
+    /**
+     * @deprecated
+     * @param title
+     */
     title(title) {
-        return this.schema({ title });
+        return this.schema({ label: title });
+    }
+    label(label) {
+        return this.schema({ label });
     }
     binary() {
         this.type(String);
@@ -213,11 +211,12 @@ class ReturnDecoratorContext extends DecoratorContext {
             response.headers(headers);
         }
         this.mapMedia(response);
-        if (isSuccessStatus(this.get("status")) || currentStatus === "default") {
-            if (model) {
-                entity.type = model;
-            }
-        }
+        // if (isSuccessStatus(this.get("status")) || currentStatus === "default") {
+        //   if (model) {
+        //     // TODO Check why we need that ?
+        //     // entity.type = model;
+        //   }
+        // }
         // additional info for OS2
         contentType && operation.addProduce(contentType);
         // run additional actions
@@ -225,41 +224,19 @@ class ReturnDecoratorContext extends DecoratorContext {
     }
     mapMedia(response) {
         const contentType = this.getContentType();
-        const model = this.get("model");
-        const media = response.getMedia(contentType || "*/*");
-        const schema = media.get("schema") || new JsonSchema({ type: model });
-        const groups = this.get("groups");
-        const groupsName = this.get("groupsName");
         const allowedGroups = this.get("allowedGroups");
-        const operation = this.entity.operation;
-        if (model) {
-            if (isArray(model)) {
-                schema.oneOf(model.map((type) => ({ type })));
-            }
-            else {
-                schema.type(model);
-            }
-        }
+        const { operation } = this.entity;
+        const media = response.getMedia(contentType || "*/*");
+        const schema = media
+            .type(this.get("model"))
+            .examples(this.get("examples"))
+            .schema()
+            .groups(this.get("groups"))
+            .groupsName(this.get("groupsName"))
+            .allowedGroups(allowedGroups);
         this.set("schema", schema);
-        media.schema(schema);
-        media.groups = groups;
-        media.groupsName = groupsName;
         if (allowedGroups) {
-            media.allowedGroups = allowedGroups;
-            const jsonParameter = new JsonParameter();
-            jsonParameter.in("query").name("includes");
-            jsonParameter.schema(JsonSchema.from({
-                type: "array",
-                items: {
-                    type: "string",
-                    enum: [...allowedGroups]
-                }
-            }));
-            operation.addParameter(-1, jsonParameter);
-        }
-        const examples = this.get("examples");
-        if (examples) {
-            media.examples(examples);
+            operation.addAllowedGroupsParameter(allowedGroups);
         }
         return media;
     }

package/lib/esm/domain/JsonEntityStore.js

@@ -9,7 +9,7 @@ export class JsonEntityStore {
         const { target, propertyKey, descriptor, index, decoratorType } = options;
         this.target = target;
         this.propertyKey = propertyKey;
-        this.propertyName = String(propertyKey);
+        this.propertyName = propertyKey ? String(propertyKey) : propertyKey || "";
         this.descriptor = descriptor;
         this.index = index;
         this.decoratorType = decoratorType;
@@ -17,6 +17,25 @@ export class JsonEntityStore {
         this.store = options.store;
         this.parent = this;
     }
+    get type() {
+        return this._type;
+    }
+    /**
+     * Get original type without transformation
+     * @param value
+     */
+    set type(value) {
+        if (!value?.$schema?.skip) {
+            this._type = value;
+        }
+        this.build();
+    }
+    /**
+     * Return the JsonSchema
+     */
+    get schema() {
+        return this._schema;
+    }
     /**
      * Return the class name of the entity.
      * @returns {string}
@@ -47,35 +66,12 @@ export class JsonEntityStore {
     get isClass() {
         return isClass(this.computedType);
     }
-    /**
-     * Return the JsonSchema
-     */
-    get schema() {
-        return this._schema;
-    }
-    get nestedGenerics() {
-        return this.schema.nestedGenerics;
-    }
-    set nestedGenerics(nestedGenerics) {
-        this.schema.nestedGenerics = nestedGenerics;
-    }
-    get type() {
-        return this._type;
-    }
-    /**
-     * Get original type without transformation
-     * @param value
-     */
-    set type(value) {
-        this._type = value;
-        this.build();
-    }
     /**
      * Return the itemSchema computed type. if the type is a function used for recursive model, the function will be called to
      * get the right type.
      */
     get computedType() {
-        return this.itemSchema.getComputedType();
+        return this.itemSchema.class;
     }
     get itemSchema() {
         return this.isCollection ? this.schema.itemSchema() : this.schema;
@@ -86,6 +82,12 @@ export class JsonEntityStore {
     get isDiscriminatorChild() {
         return this.schema.isDiscriminator && this.discriminatorAncestor?.schema.discriminator().base !== this.target;
     }
+    get path() {
+        return this.store.get("path");
+    }
+    set path(path) {
+        this.store.set("path", path);
+    }
     static from(...args) {
         if (args[0].isStore) {
             return args[0];
@@ -129,11 +131,23 @@ export class JsonEntityStore {
     toString() {
         return [this.targetName, this.propertyName, this.index].filter((o) => o !== undefined).join(":");
     }
+    getBestType() {
+        return this.itemSchema.hasDiscriminator
+            ? this.itemSchema.discriminator().base
+            : isClassObject(this.type)
+                ? this.itemSchema.getTarget()
+                : isArrowFn(this.type)
+                    ? this.type()
+                    : this.type;
+    }
+    is(input) {
+        return this.decoratorType === input;
+    }
     buildType(type) {
         if (isCollection(type)) {
             this.collectionType = type;
         }
-        else {
+        else if (!(type && "$schema" in type && type.$schema.skip)) {
             this._type = type;
             // issue #1534: Enum metadata stored as plain object instead of String (see: https://github.com/tsedio/tsed/issues/1534)
             if (this._type && isPlainObject(this._type)) {
@@ -141,19 +155,4 @@ export class JsonEntityStore {
             }
         }
     }
-    set path(path) {
-        this.store.set("path", path);
-    }
-    get path() {
-        return this.store.get("path");
-    }
-    getBestType() {
-        return this.itemSchema.hasDiscriminator
-            ? this.itemSchema.discriminator().base
-            : isClassObject(this.type)
-                ? this.itemSchema.getTarget()
-                : isArrowFn(this.type)
-                    ? this.type()
-                    : this.type;
-    }
 }

package/lib/esm/domain/JsonMedia.js

@@ -1,16 +1,37 @@
+import { isArray, isClass } from "@tsed/core";
 import { JsonMap } from "./JsonMap.js";
+import { JsonSchema } from "./JsonSchema.js";
 export class JsonMedia extends JsonMap {
-    constructor() {
-        super(...arguments);
+    constructor(obj = {}) {
+        super(obj);
         this.$kind = "operationMedia";
-        this.groups = [];
+        if (!this.has("schema")) {
+            this.set("schema", new JsonSchema());
+        }
     }
     schema(schema) {
-        this.set("schema", schema);
-        return this;
+        schema && this.set("schema", schema);
+        return this.get("schema");
     }
     examples(examples) {
-        this.set("examples", examples);
+        examples && this.set("examples", examples);
+        return this;
+    }
+    type(type) {
+        if (type) {
+            if (isArray(type)) {
+                this.schema().oneOf(type.map((type) => ({ type })));
+            }
+            else {
+                if (isClass(type)) {
+                    this.schema().type("object");
+                    this.schema().itemSchema(type);
+                }
+                else {
+                    this.schema().type(type);
+                }
+            }
+        }
         return this;
     }
 }

package/lib/esm/domain/JsonMethodStore.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { DecoratorTypes, deepMerge, descriptorOf, isCollection, isFunction, isPromise, Metadata, prototypeOf, Store } from "@tsed/core";
+import { DecoratorTypes, deepMerge, descriptorOf, isClass, isCollection, isFunction, isPromise, Metadata, prototypeOf, Store } from "@tsed/core";
 import { JsonEntityComponent } from "../decorators/config/jsonEntityComponent.js";
 import { JsonEntityStore } from "./JsonEntityStore.js";
 import { JsonOperation } from "./JsonOperation.js";
@@ -59,15 +59,21 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
         descriptor = descriptor || descriptorOf(prototypeOf(target), propertyKey);
         return JsonEntityStore.from(prototypeOf(target), propertyKey, descriptor);
     }
+    /**
+     * TODO must be located on JsonOperation level directly
+     * @param status
+     * @param contentType
+     * @param includes
+     */
     getResponseOptions(status, { contentType = "application/json", includes } = {}) {
         const media = this.operation.getResponseOf(status).getMedia(contentType, false);
         if (media && media.has("schema")) {
-            const schema = media.get("schema");
-            let groups = media.groups;
-            if (includes && media.allowedGroups?.size) {
-                groups = [...(groups || []), ...includes.filter((include) => media.allowedGroups.has(include))];
+            const allowedGroups = media.schema().getAllowedGroups();
+            let groups = media.schema().getGroups();
+            if (includes && allowedGroups?.size) {
+                groups = [...(groups || []), ...includes.filter((include) => allowedGroups.has(include))];
             }
-            return { type: schema.getComputedItemType(), groups };
+            return { type: media.schema().collectionClass, groups };
         }
         return { type: this.type };
     }
@@ -126,12 +132,25 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
             // @ts-ignore
             delete this._type;
         }
-        this._schema = JsonSchema.from({
-            type: this.collectionType || this.type
-        });
+        // TODO est-ce que c'est tjrs d'actualité car on doit utiliser le decorator @Returns pour affecter correctement les data
+        // peut etre que c'est pour les get/setter ou méthod n'étant pas un endpoint?
         if (this.collectionType) {
+            this._schema = JsonSchema.from({
+                type: this.collectionType
+            });
             this._schema.itemSchema(this.type);
         }
+        else if (isClass(this.type)) {
+            this._schema = JsonSchema.from({
+                type: "object"
+            });
+            this._schema.itemSchema(this.type);
+        }
+        else {
+            this._schema = JsonSchema.from({
+                type: this.type
+            });
+        }
         this.parent.schema.addProperty(this.propertyName, this.schema);
     }
 };

package/lib/esm/domain/JsonOperation.js

@@ -1,7 +1,9 @@
 import { deepMerge, uniq, uniqBy } from "@tsed/core";
 import { isRedirectionStatus, isSuccessStatus } from "../utils/isSuccessStatus.js";
 import { JsonMap } from "./JsonMap.js";
+import { JsonParameter } from "./JsonParameter.js";
 import { JsonResponse } from "./JsonResponse.js";
+import { JsonSchema } from "./JsonSchema.js";
 export class JsonMethodPath extends JsonMap {
     constructor(method, path) {
         super();
@@ -127,6 +129,19 @@ export class JsonOperation extends JsonMap {
         super.set("deprecated", deprecated);
         return this;
     }
+    addAllowedGroupsParameter(allowedGroups) {
+        const jsonParameter = new JsonParameter();
+        jsonParameter.in("query").name("includes");
+        jsonParameter.schema(JsonSchema.from({
+            type: "array",
+            items: {
+                type: "string",
+                enum: [...allowedGroups]
+            }
+        }));
+        this.addParameter(-1, jsonParameter);
+        return this;
+    }
     parameters(parameters) {
         super.set("parameters", parameters);
         return this;

package/lib/esm/domain/JsonParameter.js

@@ -3,11 +3,12 @@ import { JsonMap } from "./JsonMap.js";
 import { formatParameterType } from "./JsonParameterTypes.js";
 import { JsonSchema } from "./JsonSchema.js";
 export class JsonParameter extends JsonMap {
-    constructor() {
-        super(...arguments);
+    constructor(obj = {}) {
+        super(obj);
         this.$kind = "operationInParameter";
-        this.nestedGenerics = [];
-        this.$schema = new JsonSchema();
+        if (!this.has("schema")) {
+            this.set("schema", new JsonSchema());
+        }
     }
     getName() {
         const name = this.get("name");
@@ -39,18 +40,18 @@ export class JsonParameter extends JsonMap {
     }
     schema(schema) {
         if (schema) {
-            this.$schema = schema;
+            this.set("schema", schema);
             return this;
         }
-        return this.$schema;
+        return this.get("schema");
     }
     itemSchema(schema) {
-        if (this.$schema.isCollection) {
-            schema && this.$schema.itemSchema(schema);
-            return this.$schema.itemSchema();
+        if (this.schema().isCollection) {
+            schema && this.schema().itemSchema(schema);
+            return this.schema().itemSchema();
         }
         schema && this.schema(schema);
-        // non-collection: delegate to main schema would
+        // non-collection: delegate to the main schema
         return this.schema();
     }
     toJSON(options) {

package/lib/esm/domain/JsonParameterStore.js

@@ -16,12 +16,6 @@ let JsonParameterStore = class JsonParameterStore extends JsonEntityStore {
         this.expression = options.expression || this.expression;
         this.dataPath = options.dataPath || this.dataPath;
     }
-    get nestedGenerics() {
-        return this.parameter.nestedGenerics;
-    }
-    set nestedGenerics(nestedGenerics) {
-        this.parameter.nestedGenerics = nestedGenerics;
-    }
     /**
      * Return the required state.
      * @returns {boolean}
@@ -33,10 +27,10 @@ let JsonParameterStore = class JsonParameterStore extends JsonEntityStore {
         this.parameter.required(value);
     }
     get allowedRequiredValues() {
-        return this.schema.$allow;
+        return this.schema.getAllowedRequiredValues();
     }
     get schema() {
-        return this.parameter.$schema;
+        return this.parameter.schema();
     }
     static getParams(target, propertyKey) {
         const params = [];
@@ -76,7 +70,7 @@ let JsonParameterStore = class JsonParameterStore extends JsonEntityStore {
             this.parameter.schema().type(this.collectionType);
         }
         if (isClass(this._type)) {
-            this.parameter.itemSchema(JsonEntityStore.from(this._type).schema);
+            this.parameter.schema().itemSchema(this._type);
         }
         else {
             this.parameter.itemSchema().type(this._type);