@tsed/schema 8.16.0-rc.4 → 8.16.0

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

@@ -195,8 +195,7 @@ class ReturnDecoratorContext extends DecoratorContext {
         }
     }
     map() {
-        const model = this.get("model");
-        const { entity, decoratorType } = this;
+        const { decoratorType } = this;
         const operation = this.entity.operation;
         const currentStatus = this.getStatus();
         const response = operation.ensureResponseOf(currentStatus);
@@ -211,12 +210,6 @@ 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,6 +17,12 @@ 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;
     }
@@ -44,10 +50,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);
@@ -55,7 +61,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);
@@ -145,7 +151,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,6 +1,7 @@
 import { __decorate, __metadata } from "tslib";
-import { DecoratorTypes, deepMerge, descriptorOf, isClass, isCollection, isFunction, isPromise, Metadata, prototypeOf, Store } from "@tsed/core";
+import { DecoratorTypes, deepMerge, descriptorOf, isFunction, 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";
@@ -49,6 +50,34 @@ 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
@@ -75,7 +104,7 @@ let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
             }
             return { type: media.schema().collectionClass, groups };
         }
-        return { type: this.type };
+        return { type: this.type || Object };
     }
     /**
      * Append middlewares to the beforeMiddlewares list.
@@ -120,38 +149,7 @@ 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,4 +1,6 @@
-import { isObject, uniq } from "@tsed/core";
+import { cleanObject } from "@tsed/core/utils/cleanObject.js";
+import { isObject } from "@tsed/core/utils/isObject.js";
+import { uniq } from "@tsed/core/utils/uniq.js";
 function mergeProps(properties1, properties2) {
     if (!properties1 || !properties2) {
         return properties1 || properties2 || {};
@@ -17,40 +19,58 @@ 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 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 { [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;
         }
-        return Object.keys(schema).length > 0;
-    });
-    if (of.length > 2) {
-        of = of.reduce((current, item, index) => {
-            if (item.$ref) {
-                return current.concat(item);
+        if (schema.type === "object" && Object.keys(schema).length === 2) {
+            if ("writeOnly" in schema || "readOnly" in schema || "deprecated" in schema) {
+                schema = { ...schema, type: undefined };
             }
-            if (current.at(-1)?.type === item.type && item.type !== "array") {
-                current[current.length - 1] = mergeSchema(current.at(-1), item);
-                return current;
+        }
+        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 current.concat(item);
-        }, []);
-    }
-    return of.length > 1
+            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)
         ? {
-            [kind]: of,
-            ...(schema1.nullable || schema2.nullable ? { nullable: true } : {})
+            ...rest,
+            [kind]: of
         }
-        : of[0];
+        : {
+            ...rest,
+            ...of[0]
+        });
 }
 export function mergeSchema(schema1, schema2) {
     if (schema1.$ref && schema2.$ref && schema1.$ref === schema2.$ref) {

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

@@ -42,21 +42,23 @@ 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<OS3MediaType<JsonSchema>> {
+export declare class JsonMedia extends JsonMap<any> {
     $kind: string;
     constructor(obj?: Partial<OS3MediaType<JsonSchema>>);
     schema(schema?: JsonSchema): JsonSchema;

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

@@ -1,8 +1,9 @@
 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 { type JsonParameterStore } from "./JsonParameterStore.js";
+import { JsonSchema } from "./JsonSchema.js";
 export interface JsonViewOptions {
     path: string;
     options: any;
@@ -32,6 +33,10 @@ 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,7 +1,8 @@
+import type { Type } from "@tsed/core";
 import { JsonMap } from "../domain/JsonMap.js";
 /**
  * @ignore
  */
 export declare function toJsonMapCollection(content: {
     [key: string]: any;
-}, klass?: typeof JsonMap): JsonMap<any>;
+}, klass?: Type<JsonMap<any>>): JsonMap<any>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/schema",
   "description": "JsonSchema module for Ts.ED Framework",
   "type": "module",
-  "version": "8.16.0-rc.4",
+  "version": "8.16.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -34,7 +34,7 @@
     "tsed"
   ],
   "dependencies": {
-    "@tsed/openspec": "8.16.0-rc.4",
+    "@tsed/openspec": "8.16.0",
     "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.16.0-rc.4",
-    "@tsed/core": "8.16.0-rc.4",
-    "@tsed/hooks": "8.16.0-rc.4",
-    "@tsed/openspec": "8.16.0-rc.4",
-    "@tsed/typescript": "8.16.0-rc.4",
+    "@tsed/barrels": "8.16.0",
+    "@tsed/core": "8.16.0",
+    "@tsed/hooks": "8.16.0",
+    "@tsed/openspec": "8.16.0",
+    "@tsed/typescript": "8.16.0",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.2",
@@ -76,8 +76,5 @@
   },
   "homepage": "https://github.com/tsedio/tsed/tree/production/packages/specs/schema",
   "author": "Romain Lenzotti",
-  "license": "MIT",
-  "publishConfig": {
-    "tag": "rc"
-  }
+  "license": "MIT"
 }