@tsed/schema 7.0.0-alpha.2 → 7.0.0-beta.11

package/lib/types/decorators/class/children.d.ts

@@ -0,0 +1,11 @@
+import { Type } from "@tsed/core";
+/**
+ * Add Children class to compose routes
+ *
+ * @decorator
+ * @swagger
+ * @schema
+ * @classDecorator
+ * @param children
+ */
+export declare function Children(...children: Type<any>[]): ClassDecorator;

package/lib/{decorators → types/decorators}/collections/collectionOf.d.ts

@@ -31,7 +31,7 @@ export interface ArrayOfChainedDecorators {
     /**
      * If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique.
      */
-    UniqueItems(uniqueItems: boolean): this;
+    UniqueItems(uniqueItems?: boolean): this;
 }
 export interface MapOfChainedDecorators {
     (...args: any): any;

package/lib/{decorators → types/decorators}/common/any.d.ts

@@ -1,5 +1,5 @@
 import { Type } from "@tsed/core";
-import { JSONSchema6TypeName } from "json-schema";
+import type { JSONSchema6TypeName } from "json-schema";
 /**
  * Set the type of the array items.
  *

package/lib/{decorators → types/decorators}/common/const.d.ts

@@ -1,4 +1,4 @@
-import { JSONSchema6Type } from "json-schema";
+import type { JSONSchema6Type } from "json-schema";
 /**
  * The const keyword is used to restrict a value to a fixed value.
  *

package/lib/{decorators → types/decorators}/common/enum.d.ts

@@ -1,4 +1,4 @@
-import { JSONSchema6Type } from "json-schema";
+import type { JSONSchema6Type } from "json-schema";
 /**
  * The enum keyword is used to restrict a value to a fixed set of values.
  * It must be an array with at least one element, where each element is unique.

package/lib/types/decorators/common/examples.d.ts

@@ -0,0 +1,12 @@
+import { OpenSpecHash, OpenSpecRef, OS3Example } from "@tsed/openspec";
+/**
+ * Add a examples metadata on the decorated element.
+ *
+ * @decorator
+ * @swagger
+ * @schema
+ * @input
+ * @methodDecorator
+ * @classDecorator
+ */
+export declare function Examples(examples: OpenSpecHash<OS3Example | OpenSpecRef>): ParameterDecorator;

package/lib/{decorators → types/decorators}/common/ignore.d.ts

@@ -1,4 +1,4 @@
-import { IgnoreCallback } from "../../interfaces";
+import { IgnoreCallback } from "../../interfaces/IgnoreCallback";
 /**
  * Ignore the property when JsonMapper serialize the class to a Plain Object JavaScript.
  *

package/lib/{decorators → types/decorators}/common/jsonEntityFn.d.ts

@@ -1,5 +1,5 @@
 import { DecoratorParameters } from "@tsed/core";
-import { JsonEntityStore } from "../../domain";
+import type { JsonEntityStore } from "../../domain/JsonEntityStore";
 /**
  * Decorator util to compose another decorator. See @@Description@@ decorator implementation for more details.
  *
@@ -18,4 +18,4 @@ import { JsonEntityStore } from "../../domain";
  * @utils
  * @model
  */
-export declare function JsonEntityFn<T extends JsonEntityStore>(fn: (entity: T, parameters: DecoratorParameters) => void): (...args: any[]) => any;
+export declare function JsonEntityFn<T extends JsonEntityStore = JsonEntityStore>(fn: (entity: T, parameters: DecoratorParameters) => any): (...args: any[]) => any;

package/lib/{decorators → types/decorators}/common/nullable.d.ts

@@ -1,5 +1,5 @@
 import { Type } from "@tsed/core";
-import { JSONSchema6TypeName } from "json-schema";
+import type { JSONSchema6TypeName } from "json-schema";
 /**
  * Set field as nullable.
  *

package/lib/{decorators → types/decorators}/common/property.d.ts

@@ -6,5 +6,6 @@
  * @validation
  * @swagger
  * @schema
+ * @input
  */
 export declare function Property(type?: any): (...args: any[]) => any;

package/lib/types/decorators/common/recordOf.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Constructs a json schema object type whose property keys are keys and whose property values are type.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * type keys = 'one' | 'two';
+ *
+ * class Part {
+ *   prop: string;
+ * }
+ *
+ * type Parts = Record<keys, Part>;
+ *
+ * class Test {
+ *   @RecordOf(Part, 'one', 'two')
+ *   parts: Parts;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *     "type": "object",
+ *     "properties": {
+ *         "one": {
+ *             "$ref": "#/components/schemas/Part"
+ *         },
+ *         "two": {
+ *             "$ref": "#/components/schemas/Part"
+ *         },
+ *     },
+ * }
+ * ```
+ *
+ * @param model
+ * @param keys
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @classDecorator
+ * @input
+ */
+export declare function RecordOf(model: any, ...keys: string[]): (...args: any[]) => any;

package/lib/{decorators → types/decorators}/common/requiredGroups.d.ts

@@ -7,4 +7,4 @@
  * @schema
  * @input
  */
-export declare function RequiredGroups(...groups: string[]): Function;
+export declare function RequiredGroups(...groups: string[]): PropertyDecorator;

package/lib/types/decorators/operations/acceptMime.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Set a mime list which are acceptable and checks if the specified content types are acceptable, based on the request’s Accept HTTP header field.
+ *
+ * ```typescript
+ *  @Controller('/mypath')
+ *  export class MyCtrl {
+ *
+ *    @Get('/')
+ *    @AcceptMime('application/json')
+ *    public getResource(){}
+ *  }
+ * ```
+ *
+ * @param mimes
+ * @decorator
+ * @operation
+ * @response
+ */
+export declare function AcceptMime(...mimes: string[]): Function;

package/lib/{decorators → types/decorators}/operations/in.d.ts

@@ -1,6 +1,6 @@
 import { Type } from "@tsed/core";
-import { JsonSchemaObject } from "../../domain";
 import { JsonParameterTypes } from "../../domain/JsonParameterTypes";
+import { JsonSchemaObject } from "../../domain/JsonSchema";
 export interface InChainedDecorators {
     <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
     (target: Object, propertyKey: string | symbol, parameterIndex: number): void;

package/lib/types/decorators/operations/inFile.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Add a input file parameter.
+ *
+ * ::: warning
+ * Don't use decorator with Ts.ED application to decorate parameters. Use @@BodyParams@@, @@PathParams@@, etc... instead.
+ * But you can use this decorator on Method, to add extra in parameters like Authorization header.
+ *
+ * ```typescript
+ * @Controller("/")
+ * class MyController {
+ *    @Post("/")
+ *    method(@InFile("file1") file: any) {
+ *    }
+ *  }
+ * ```
+ * :::
+ *
+ * @decorator
+ * @swagger
+ * @schema
+ * @input
+ * @operation
+ * @param name
+ */
+export declare function InFile(name: string): ParameterDecorator;

package/lib/{decorators → types/decorators}/operations/returns.d.ts

@@ -40,6 +40,21 @@ export interface ReturnsChainedDecorators {
      * @param types
      */
     Of(...types: GenericValue[]): this;
+    /**
+     * Add the nested types
+     * @param types
+     */
+    OneOf(...types: GenericValue[]): this;
+    /**
+     * Add the nested types
+     * @param types
+     */
+    AllOf(...types: GenericValue[]): this;
+    /**
+     * Add the nested types
+     * @param types
+     */
+    AnyOf(...types: GenericValue[]): this;
     /**
      * Declare a nested generic models
      * @param generics
@@ -235,4 +250,4 @@ export interface ReturnsChainedDecorators {
  * @response
  * @operation
  */
-export declare function Returns(status?: string | number, model?: Type<any>): ReturnsChainedDecorators;
+export declare function Returns(status?: string | number, model?: Type<any> | Type<any>[]): ReturnsChainedDecorators;

package/lib/{decorators → types/decorators}/operations/route.d.ts

@@ -32,6 +32,9 @@ export interface RouteChainedDecorators {
      * @param Summary
      */
     Summary(Summary: string): this;
+    Use(...args: any[]): this;
+    UseAfter(...args: any[]): this;
+    UseBefore(...args: any[]): this;
 }
 /**
  * Describe a new route with a method and path.

package/lib/types/decorators/operations/view.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Use a view and sends the rendered HTML string to the client. Optional parameter:
+ *
+ * * viewOptions, an object whose properties define local variables for the view.
+ *
+ * The view argument is a string that is the file path of the view file to render.
+ * This can be an absolute path, or a path relative to the views setting.
+ * If the path does not contain a file extension, then the view engine setting determines the file extension.
+ * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())
+ * and render it using the loaded module’s __express function.
+ *
+ * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).
+ *
+ * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,
+ * and as so for security reasons should not contain input from the end-user.
+ *
+ * @param path Relative path to the view file.
+ * @param options Additional options
+ * @decorator
+ * @operation
+ * @response
+ */
+export declare function View(path: string, options?: Object): MethodDecorator;

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

@@ -0,0 +1,12 @@
+import type { JsonMethodStore } from "./JsonMethodStore";
+import type { JsonPropertyStore } from "./JsonPropertyStore";
+import { JsonEntityStore } from "./JsonEntityStore";
+export declare class JsonClassStore extends JsonEntityStore {
+    /**
+     * List of children JsonEntityStore (properties or methods or params)
+     */
+    readonly children: Map<string | number, JsonMethodStore | JsonPropertyStore>;
+    get path(): string;
+    set path(path: string);
+    protected build(): void;
+}

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

@@ -0,0 +1,136 @@
+import { DecoratorTypes, Store, Type } from "@tsed/core";
+import type { JsonSchema } from "./JsonSchema";
+import type { JsonMethodStore } from "./JsonMethodStore";
+import type { JsonClassStore } from "./JsonClassStore";
+import type { JsonPropertyStore } from "./JsonPropertyStore";
+import type { JsonParameterStore } from "./JsonParameterStore";
+/**
+ * @ignore
+ */
+export declare const JsonEntitiesContainer: Map<DecoratorTypes, Type<JsonEntityStore>>;
+export interface JsonEntityStoreOptions {
+    decoratorType: DecoratorTypes;
+    target: Type<any>;
+    propertyKey?: string | symbol;
+    index?: number;
+    descriptor?: any;
+    type?: Type<any>;
+    collectionType?: Type<any>;
+    beforeMiddlewares?: Function[];
+    middlewares?: Function[];
+    afterMiddlewares?: Function[];
+    [key: string]: any;
+}
+export declare abstract class JsonEntityStore implements JsonEntityStoreOptions {
+    /**
+     * Original property key decorated by the decorator
+     */
+    readonly propertyKey: string | symbol;
+    /**
+     * Alias of the property
+     */
+    readonly propertyName: string;
+    /**
+     * Parameter index
+     */
+    readonly index: number;
+    /**
+     * Method's descriptor
+     */
+    readonly descriptor: number;
+    /**
+     * 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>;
+    /**
+     *
+     */
+    protected _type: Type<any>;
+    /**
+     * Ref to JsonSchema
+     */
+    protected _schema: JsonSchema;
+    [key: string]: any;
+    constructor(options: JsonEntityStoreOptions);
+    /**
+     * Return the class name of the entity.
+     * @returns {string}
+     */
+    get targetName(): string;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isCollection(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isArray(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isPrimitive(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isDate(): boolean;
+    /**
+     *
+     * @returns {boolean}
+     */
+    get isObject(): boolean;
+    /**
+     *
+     */
+    get isClass(): boolean;
+    /**
+     * Return the JsonSchema
+     */
+    get schema(): JsonSchema;
+    get nestedGenerics(): Type<any>[][];
+    set nestedGenerics(nestedGenerics: Type<any>[][]);
+    /**
+     *
+     * @returns {Type<any>}
+     */
+    get type(): Type<any> | any;
+    /**
+     * Get original type without transformation
+     * @param value
+     */
+    set type(value: Type<any> | any);
+    /**
+     * 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(): any;
+    get itemSchema(): JsonSchema;
+    get parentSchema(): JsonSchema;
+    /**
+     *
+     * @param target
+     */
+    static from<T extends JsonClassStore = JsonClassStore>(target: Type<any>): T;
+    static from<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any, propertyKey: string | symbol): T;
+    static from<T extends JsonParameterStore = JsonParameterStore>(target: Type<any> | any, propertyKey: string | symbol, index: number): T;
+    static from<T extends JsonMethodStore = JsonMethodStore>(target: Type<any> | any, propertyKey: string | symbol, descriptor: PropertyDescriptor): T;
+    static from<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T;
+    static fromMethod<T extends JsonMethodStore = JsonMethodStore>(target: any, propertyKey: string | symbol): T;
+    get<T = any>(key: string, defaultValue?: any): T;
+    set(key: string, value?: any): Store;
+    protected abstract build(): void;
+    protected buildType(type: any): void;
+    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: any): JsonEntityStore;
+}

package/lib/{domain → types/domain}/JsonMap.d.ts

@@ -1,4 +1,4 @@
-import { JsonSchemaOptions } from "../interfaces";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
 export declare class JsonMap<T> extends Map<string, any> {
     [key: string]: any;
     constructor(obj?: Partial<T>);