@tsed/schema 8.15.4 → 8.16.0-rc.2

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

@@ -195,7 +195,8 @@ class ReturnDecoratorContext extends DecoratorContext {
         }
     }
     map() {
-        const { decoratorType } = this;
+        const model = this.get("model");
+        const { entity, decoratorType } = this;
         const operation = this.entity.operation;
         const currentStatus = this.getStatus();
         const response = operation.ensureResponseOf(currentStatus);
@@ -210,6 +211,12 @@ class ReturnDecoratorContext extends DecoratorContext {
             response.headers(headers);
         }
         this.mapMedia(response);
+        // 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

package/lib/esm/domain/JsonEntityStore.js

@@ -17,12 +17,6 @@ export class JsonEntityStore {
         this.store = options.store;
         this.parent = this;
     }
-    get collectionType() {
-        return this._collectionType;
-    }
-    set collectionType(value) {
-        this._collectionType = value;
-    }
     get type() {
         return this._type;
     }
@@ -50,10 +44,10 @@ export class JsonEntityStore {
         return nameOf(this.token);
     }
     get isCollection() {
-        return !!this._collectionType;
+        return !!this.collectionType;
     }
     get isArray() {
-        return isArrayOrArrayClass(this._collectionType);
+        return isArrayOrArrayClass(this.collectionType);
     }
     get discriminatorAncestor() {
         const ancestors = ancestorsOf(this.target);
@@ -61,7 +55,7 @@ export class JsonEntityStore {
         return ancestor && JsonEntityStore.from(ancestor);
     }
     get isPrimitive() {
-        return isPrimitiveOrPrimitiveClass(this.type);
+        return isPrimitiveOrPrimitiveClass(this._type);
     }
     get isDate() {
         return isDate(this.computedType);
@@ -151,7 +145,7 @@ export class JsonEntityStore {
     }
     buildType(type) {
         if (isCollection(type)) {
-            this._collectionType = type;
+            this.collectionType = type;
         }
         else if (!(type && "$schema" in type && type.$schema.skip)) {
             this._type = type;

package/lib/esm/domain/JsonMethodStore.js

@@ -1,7 +1,6 @@
 import { __decorate, __metadata } from "tslib";
-import { DecoratorTypes, deepMerge, descriptorOf, isFunction, 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 { isSuccessStatus } from "../utils/isSuccessStatus.js";
 import { JsonEntityStore } from "./JsonEntityStore.js";
 import { JsonOperation } from "./JsonOperation.js";
 import { JsonSchema } from "./JsonSchema.js";
@@ -50,34 +49,6 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
     get operationPaths() {
         return this.operation.operationPaths;
     }
-    get collectionType() {
-        return this.schema.getTarget();
-    }
-    set collectionType(type) {
-        console.trace("collectionType is deprecated, use schema.collectionClass instead");
-    }
-    get isCollection() {
-        return this.schema.isCollection;
-    }
-    get schema() {
-        if (this._schema) {
-            return this._schema;
-        }
-        const responses = this.operation.getResponses();
-        const [, response] = [...responses.entries()].find(([key, response]) => {
-            return isSuccessStatus(key);
-        }) || [];
-        if (response) {
-            const firstMediaType = response.getContent().values().next().value;
-            if (firstMediaType) {
-                this._schema = firstMediaType.schema();
-            }
-        }
-        else {
-            this._schema = new JsonSchema();
-        }
-        return this._schema;
-    }
     /**
      * Get an endpoint.
      * @param target
@@ -104,7 +75,7 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
             }
             return { type: media.schema().collectionClass, groups };
         }
-        return { type: this.type || Object };
+        return { type: this.type };
     }
     /**
      * Append middlewares to the beforeMiddlewares list.
@@ -149,7 +120,38 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
         }), {});
     }
     build() {
+        if (!this._type) {
+            let type = Metadata.getReturnType(this.target, this.propertyKey);
+            type = isPromise(type) ? undefined : type;
+            this.buildType(type);
+        }
+        this._type = this._type || Object;
         this.parent.children.set(this.propertyName, this);
+        if (isCollection(this._type)) {
+            this.collectionType = this._type;
+            // @ts-ignore
+            delete 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);
     }
 };
 JsonMethodStore = __decorate([

package/lib/esm/utils/mergeSchema.js

@@ -1,6 +1,4 @@
-import { cleanObject } from "@tsed/core/utils/cleanObject.js";
-import { isObject } from "@tsed/core/utils/isObject.js";
-import { uniq } from "@tsed/core/utils/uniq.js";
+import { isObject, uniq } from "@tsed/core";
 function mergeProps(properties1, properties2) {
     if (!properties1 || !properties2) {
         return properties1 || properties2 || {};
@@ -19,58 +17,40 @@ function mergeProps(properties1, properties2) {
         return acc;
     }, {});
 }
-function getSchemaType(schema) {
-    return schema.type || (schema.items && "array") || ((schema.properties || schema.additionalProperties) && "object") || "$any";
-}
 function mergeManyOf(kind, schema1, schema2) {
-    const { [kind]: kind1, ...$rest1 } = schema1;
-    const { [kind]: kind2, ...$rest2 } = schema2;
-    let hasRef = false;
-    const map = [kind1, $rest1, kind2, $rest2]
-        .flat()
-        .filter(Boolean)
-        .reduce((map, schema, index) => {
-        schema = cleanObject(schema);
-        if (schema.$ref) {
-            hasRef = true;
-            return map.set(schema.$ref, schema);
-        }
-        if (Object.keys(schema).length === 0) {
-            return map;
-        }
-        if (schema.type === "object" && Object.keys(schema).length === 2) {
-            if ("writeOnly" in schema || "readOnly" in schema || "deprecated" in schema) {
-                schema = { ...schema, type: undefined };
+    const refs = new Set();
+    if (schema1.$ref && schema2.type && (schema2.readOnly || schema2.writeOnly) && kind === "allOf") {
+        const { type, ...rest } = schema2;
+        schema2 = rest;
+    }
+    let of = [...(schema1[kind] || [schema1]), ...(schema2[kind] || [schema2])].filter((schema) => {
+        if ("$ref" in schema) {
+            if (refs.has(schema.$ref)) {
+                return false;
             }
+            refs.add(schema.$ref);
+            return true;
         }
-        const type = getSchemaType(schema);
-        if (type === "array") {
-            map.set("array_" + index, schema);
-            return map;
-        }
-        if (map.has(type)) {
-            if (kind === "allOf") {
-                // we can merge allOf schemas to optimize the schema
-                map.set(type, mergeSchema(map.get(type), schema));
-                return map;
+        return Object.keys(schema).length > 0;
+    });
+    if (of.length > 2) {
+        of = of.reduce((current, item, index) => {
+            if (item.$ref) {
+                return current.concat(item);
             }
-            map.set(type + "_" + index, schema);
-            return map;
-        }
-        return map.set(type, schema);
-    }, new Map());
-    const rest = map.get("$any");
-    map.delete("$any");
-    const of = Array.from(map.values());
-    return cleanObject(of.length > 1 || (hasRef && rest)
+            if (current.at(-1)?.type === item.type && item.type !== "array") {
+                current[current.length - 1] = mergeSchema(current.at(-1), item);
+                return current;
+            }
+            return current.concat(item);
+        }, []);
+    }
+    return of.length > 1
         ? {
-            ...rest,
-            [kind]: of
+            [kind]: of,
+            ...(schema1.nullable || schema2.nullable ? { nullable: true } : {})
         }
-        : {
-            ...rest,
-            ...of[0]
-        });
+        : of[0];
 }
 export function mergeSchema(schema1, schema2) {
     if (schema1.$ref && schema2.$ref && schema1.$ref === schema2.$ref) {

package/lib/types/domain/JsonEntityStore.d.ts

@@ -42,23 +42,21 @@ export declare abstract class JsonEntityStore implements JsonEntityStoreOptions
      * Decorator type used to declare the JsonSchemaStore.
      */
     readonly decoratorType: DecoratorTypes;
+    /**
+     * Type of the collection (Array, Map, Set, etc...)
+     */
+    collectionType: Type<any>;
     token: Type<any>;
     readonly store: Store;
     readonly isStore = true;
     readonly parent: JsonEntityStore;
     readonly target: Type<any>;
-    [key: string]: any;
     constructor(options: JsonEntityStoreOptions);
-    /**
-     * Type of the collection (Array, Map, Set, etc...)
-     */
-    private _collectionType;
-    get collectionType(): Type<any> | undefined;
-    set collectionType(value: Type<any>);
     /**
      *
      */
     protected _type: Type<any>;
+    [key: string]: any;
     get type(): Type<any> | any;
     /**
      * Get original type without transformation

package/lib/types/domain/JsonMedia.d.ts

@@ -1,7 +1,7 @@
 import { OS3MediaType } from "@tsed/openspec";
 import { JsonMap } from "./JsonMap.js";
 import { JsonSchema } from "./JsonSchema.js";
-export declare class JsonMedia extends JsonMap<any> {
+export declare class JsonMedia extends JsonMap<OS3MediaType<JsonSchema>> {
     $kind: string;
     constructor(obj?: Partial<OS3MediaType<JsonSchema>>);
     schema(schema?: JsonSchema): JsonSchema;

package/lib/types/domain/JsonMethodStore.d.ts

@@ -1,9 +1,8 @@
 import { Type } from "@tsed/core";
-import { type JsonClassStore } from "./JsonClassStore.js";
+import type { JsonClassStore } from "./JsonClassStore.js";
 import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore.js";
 import { JsonOperation } from "./JsonOperation.js";
-import { type JsonParameterStore } from "./JsonParameterStore.js";
-import { JsonSchema } from "./JsonSchema.js";
+import type { JsonParameterStore } from "./JsonParameterStore.js";
 export interface JsonViewOptions {
     path: string;
     options: any;
@@ -33,10 +32,6 @@ export declare class JsonMethodStore extends JsonEntityStore {
     set acceptMimes(mimes: string[]);
     get parameters(): JsonParameterStore[];
     get operationPaths(): Map<string, import("./JsonOperation.js").JsonMethodPath>;
-    get collectionType(): Type<any>;
-    set collectionType(type: Type<any>);
-    get isCollection(): boolean;
-    get schema(): JsonSchema;
     /**
      * Get an endpoint.
      * @param target

package/lib/types/utils/toJsonMapCollection.d.ts

@@ -1,8 +1,7 @@
-import type { Type } from "@tsed/core";
 import { JsonMap } from "../domain/JsonMap.js";
 /**
  * @ignore
  */
 export declare function toJsonMapCollection(content: {
     [key: string]: any;
-}, klass?: Type<JsonMap<any>>): JsonMap<any>;
+}, klass?: typeof JsonMap): JsonMap<any>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/schema",
   "description": "JsonSchema module for Ts.ED Framework",
   "type": "module",
-  "version": "8.15.4",
+  "version": "8.16.0-rc.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -34,7 +34,7 @@
     "tsed"
   ],
   "dependencies": {
-    "@tsed/openspec": "8.15.4",
+    "@tsed/openspec": "8.16.0-rc.2",
     "change-case": "^5.4.4",
     "json-schema": "0.4.0",
     "picomatch": "4.0.2",
@@ -43,11 +43,11 @@
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "10.1.0",
-    "@tsed/barrels": "8.15.4",
-    "@tsed/core": "8.15.4",
-    "@tsed/hooks": "8.15.4",
-    "@tsed/openspec": "8.15.4",
-    "@tsed/typescript": "8.15.4",
+    "@tsed/barrels": "8.16.0-rc.2",
+    "@tsed/core": "8.16.0-rc.2",
+    "@tsed/hooks": "8.16.0-rc.2",
+    "@tsed/openspec": "8.16.0-rc.2",
+    "@tsed/typescript": "8.16.0-rc.2",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.2",
@@ -76,5 +76,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed/tree/production/packages/specs/schema",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "rc"
+  }
 }