@tsed/schema 8.0.0-alpha.5 → 8.0.0-alpha.6

package/lib/types-esm/decorators/operations/status.d.ts

@@ -1,127 +0,0 @@
-import { Type } from "@tsed/core";
-import { ReturnsChainedDecorators } from "./returns.js";
-/**
- * Add responses documentation for a specific status code.
- *
- * ## Usage
- *
- * Ts.ED v6 API introducing the chaining decorator concept.
- * Now a decorator like Returns can be used with another decorators like Description.
- *
- * ```typescript
- * import {Returns} from "@tsed/schema";
- *
- * @Controller("/")
- * class MyController {
- *   @Status(404, String).Description("Not Found")
- *   @Status(200, Model).Description("Success")
- *   async myMethod(): Promise<Model> {}
- * }
- * ```
- *
- * ::: tip
- * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know
- * what chained decorators are available under Returns decorator.
- * :::
- *
- * This example will produce this documentation in swagger:
- *
- * ```json
- * {
- *   "responses": {
- *     "404": {
- *       "description": "Description",
- *       "schema": {"type": "string"}
- *     },
- *     "2OO": {
- *       "description": "Description",
- *       "schema": {"$ref": "..."}
- *     }
- *   }
- * }
- * ```
- *
- * ### Declaring a generic model
- *
- * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to
- * declare explicitly the generic models with the decorators.
- *
- * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.
- *
- * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:
- *
- * ```typescript
- * @Generics("T")
- * class Pagination<T> {
- *  @CollectionOf("T")
- *  data: T[];
- *
- *  @Property()
- *  totalCount: number;
- * }
- * ```
- *
- * Now, we need a model to be used with the generic Pagination model:
- *
- * ```typescript
- * class Product {
- *  @Property()
- *  id: string;
- *
- *  @Property()
- *  title: string;
- * }
- * ```
- *
- * Finally, we can use our models on a method as following:
- *
- * ```typescript
- * class Controller {
- *   @OperationPath("POST", "/")
- *   @Status(200, Pagination).Of(Product).Description("description")
- *   async method(): Promise<Pagination<Product> | null> {
- *     return null;
- *   }
- * }
- * ```
- *
- * ### Declaring a nested generics models <Badge text="6+"/>
- *
- * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:
- *
- * ```typescript
- * import {Generics, Property, Returns} from "@tsed/schema";
- * import {Post} from "@tsed/common";
- *
- * class Controller {
- *   @Post("/")
- *   @Status(200, Pagination).Of(Submission).Nested(Product).Description("description")
- *   async method(): Promise<Pagination<Submission<Product>> | null> {
- *     return null;
- *   }
- * }
- * ```
- *
- * And here is the Submission model:
- *
- * ```typescript
- * import {Generics, Property} from "@tsed/schema";
- *
- * @Generics("T")
- * class Submission<T> {
- *   @Property()
- *   _id: string;
- *   @Property("T")
- *   data: T;
- * }
- * ```
- *
- * @param status
- * @param model
- * @decorator
- * @swagger
- * @schema
- * @response
- * @operation
- */
-export declare function Status(status: string | number, model?: Type<any> | any): ReturnsChainedDecorators;

package/lib/types-esm/decorators/operations/subscribe.d.ts

@@ -1 +0,0 @@
-export declare function Subscribe(event: string): import("./operation.js").RouteChainedDecorators;

package/lib/types-esm/decorators/operations/summary.d.ts

@@ -1,20 +0,0 @@
-/**
- * Add summary metadata on the decorated element.
- *
- * ## Examples
- * ### On method
- *
- * ```typescript
- * class Model {
- *    @Summary("summary")
- *    id: string;
- * }
- * ```
- *
- * @param summary
- * @decorator
- * @swagger
- * @schema
- * @operation
- */
-export declare function Summary(summary: string): (...args: any[]) => any;

package/lib/types-esm/decorators/operations/tags.d.ts

@@ -1,23 +0,0 @@
-import { OpenSpecTag } from "@tsed/openspec";
-/**
- * Add tags metadata on the decorated element.
- *
- * ## Examples
- * ### On method
- *
- * ```typescript
- * @Controller("/")
- * class MyController {
- *  @Tags("api")
- *  get() {}
- * }
- * ```
- *
- * @param tags
- * @decorator
- * @swagger
- * @schema
- * @classDecorator
- * @operation
- */
-export declare function Tags(...tags: (string | OpenSpecTag)[]): (...args: any[]) => any;

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

@@ -1,23 +0,0 @@
-/**
- * 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-esm/domain/DecoratorContext.d.ts

@@ -1,28 +0,0 @@
-import { DecoratorParameters, DecoratorTypes } from "@tsed/core";
-import { JsonEntityStore } from "./JsonEntityStore.js";
-/**
- * @ignore
- */
-export interface DecoratorActionHandler {
-    (ctx: Map<string, any>): void;
-}
-/**
- * @ignore
- */
-export declare abstract class DecoratorContext<T = any> extends Map<string, any> {
-    readonly methods: string[];
-    protected decoratorType: DecoratorTypes;
-    protected entity: JsonEntityStore;
-    protected actions: DecoratorActionHandler[];
-    constructor(opts?: any);
-    addAction(cb: DecoratorActionHandler): this;
-    build(): T;
-    toObject(): any;
-    getMergedKey(key: string, defaultValue: any): any;
-    protected bind(args: DecoratorParameters, decorator: any): void;
-    protected onInit(args: DecoratorParameters, decorator: any): void;
-    protected onMapKey(key: string, value: any): void;
-    protected runActions(): this;
-    protected beforeInit(): void;
-    protected afterInit(): void;
-}

package/lib/types-esm/domain/JsonAliasMap.d.ts

@@ -1,12 +0,0 @@
-/**
- * @ignore
- */
-export type AliasType = string | number | symbol;
-/**
- * @ignore
- */
-export type AliasMap = Map<AliasType, AliasType>;
-/**
- * @ignore
- */
-export declare function mapAliasedProperties(value: any, alias: AliasMap): any;

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

@@ -1,12 +0,0 @@
-import type { JsonMethodStore } from "./JsonMethodStore.js";
-import type { JsonPropertyStore } from "./JsonPropertyStore.js";
-import { JsonEntityStore } from "./JsonEntityStore.js";
-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-esm/domain/JsonDiscriminator.d.ts

@@ -1,18 +0,0 @@
-import { Type } from "@tsed/core";
-export declare class Discriminator {
-    propertyName: string;
-    base: Type<any>;
-    values: Map<string, Type>;
-    types: Map<Type, string[]>;
-    constructor({ base, propertyName, types, values }?: Partial<{
-        base: Type<any>;
-        propertyName: string;
-        values: Map<string, Type<any>>;
-        types: Map<Type, string[]>;
-    }>);
-    add(type: Type<string>, values: string[]): this;
-    getType(discriminatorValue: string): Type<any>;
-    getValues(type: Type): string[] | undefined;
-    getDefaultValue(type: Type<any>): string | undefined;
-    children(): Type<any>[];
-}

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

@@ -1,110 +0,0 @@
-import { DecoratorTypes, Store, Type } from "@tsed/core";
-import type { JsonClassStore } from "./JsonClassStore.js";
-import type { JsonMethodStore } from "./JsonMethodStore.js";
-import type { JsonParameterStore } from "./JsonParameterStore.js";
-import type { JsonPropertyStore } from "./JsonPropertyStore.js";
-import type { JsonSchema } from "./JsonSchema.js";
-/**
- * @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: PropertyDescriptor;
-    /**
-     * 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;
-    get isCollection(): boolean;
-    get isArray(): boolean;
-    get discriminatorAncestor(): JsonEntityStore | undefined;
-    get isPrimitive(): boolean;
-    get isDate(): boolean;
-    get isObject(): boolean;
-    get isClass(): boolean;
-    /**
-     * Return the JsonSchema
-     */
-    get schema(): JsonSchema;
-    get nestedGenerics(): Type<any>[][];
-    set nestedGenerics(nestedGenerics: 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;
-    get isDiscriminatorChild(): boolean;
-    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;
-    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: any): JsonEntityStore;
-    isGetterOnly(): boolean | undefined;
-    get<T = any>(key: string, defaultValue?: any): T;
-    set(key: string, value?: any): Store;
-    toString(): string;
-    protected abstract build(): void;
-    protected buildType(type: any): void;
-    getBestType(): any;
-}

package/lib/types-esm/domain/JsonFormatTypes.d.ts

@@ -1,17 +0,0 @@
-export declare enum JsonFormatTypes {
-    DATE_TIME = "date-time",
-    DATE = "date",
-    TIME = "time",
-    EMAIL = "email",
-    HOSTNAME = "hostname",
-    IPV4 = "ipv4",
-    IPV6 = "ipv6",
-    URI = "uri",
-    URL = "url",
-    URI_REF = "uri-reference",
-    URI_TEMPLATE = "uri-template",
-    JSON_POINTER = "json-pointer",
-    RELATIVE_JSON_POINTER = "relative-json-pointer",
-    UUID = "uuid",
-    REGEX = "regex"
-}

package/lib/types-esm/domain/JsonLazyRef.d.ts

@@ -1,9 +0,0 @@
-import { Type } from "@tsed/core";
-export declare class JsonLazyRef {
-    readonly getType: () => Type<any>;
-    readonly isLazyRef = true;
-    constructor(getType: () => Type<any>);
-    get target(): Type<any>;
-    get schema(): import("./JsonSchema.js").JsonSchema;
-    get name(): string;
-}

package/lib/types-esm/domain/JsonMap.d.ts

@@ -1,9 +0,0 @@
-import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
-export declare class JsonMap<T> extends Map<string, any> {
-    [key: string]: any;
-    $kind: string;
-    readonly $isJsonDocument = true;
-    constructor(obj?: Partial<T>);
-    assign(obj?: Partial<T> & any): this;
-    toJSON(options?: JsonSchemaOptions): any;
-}

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

@@ -1,11 +0,0 @@
-import { OS3MediaType } from "@tsed/openspec";
-import { JsonMap } from "./JsonMap.js";
-import { JsonSchema } from "./JsonSchema.js";
-export declare class JsonMedia extends JsonMap<OS3MediaType<JsonSchema>> {
-    $kind: string;
-    groups: string[];
-    groupsName: string;
-    allowedGroups?: Set<string>;
-    schema(schema: JsonSchema): this;
-    examples(examples: any): this;
-}

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

@@ -1,92 +0,0 @@
-import { Type } from "@tsed/core";
-import type { JsonClassStore } from "./JsonClassStore.js";
-import { JsonEntityStore, JsonEntityStoreOptions } from "./JsonEntityStore.js";
-import { JsonOperation } from "./JsonOperation.js";
-import type { JsonParameterStore } from "./JsonParameterStore.js";
-export interface JsonViewOptions {
-    path: string;
-    options: any;
-}
-export interface JsonRedirectOptions {
-    status: number | undefined;
-    url: string;
-}
-export declare class JsonMethodStore extends JsonEntityStore {
-    readonly parent: JsonClassStore;
-    middlewares: any[];
-    beforeMiddlewares: any[];
-    afterMiddlewares: any[];
-    /**
-     * Ref to JsonOperation when the decorated object is a method.
-     */
-    readonly operation: JsonOperation;
-    /**
-     * List of children JsonEntityStore (properties or methods or params)
-     */
-    readonly children: Map<string | number, JsonParameterStore>;
-    constructor(options: JsonEntityStoreOptions);
-    get params(): JsonParameterStore[];
-    get view(): JsonViewOptions;
-    set view(view: JsonViewOptions);
-    get acceptMimes(): string[];
-    set acceptMimes(mimes: string[]);
-    get parameters(): JsonParameterStore[];
-    get operationPaths(): Map<string, import("./JsonOperation.js").JsonMethodPath>;
-    /**
-     * Get an endpoint.
-     * @param target
-     * @param propertyKey
-     * @param descriptor
-     */
-    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: PropertyDescriptor): JsonMethodStore;
-    getResponseOptions(status: number, { contentType, includes }?: {
-        contentType?: string;
-        includes?: string[];
-    }): undefined | any;
-    /**
-     * Append middlewares to the beforeMiddlewares list.
-     * @param args
-     * @returns {EndpointMetadata}
-     */
-    before(args: Function[]): this;
-    /**
-     * Append middlewares to the afterMiddlewares list.
-     * @param args
-     * @returns {EndpointMetadata}
-     */
-    after(args: Function[]): this;
-    /**
-     * Store all arguments collected via Annotation.
-     * @param args
-     */
-    use(args: Function[]): this;
-    /**
-     * Find the value at the controller level. Let this value be extended or overridden by the endpoint itself.
-     *
-     * @param key
-     * @returns {any}
-     */
-    get<T = any>(key: any): T;
-    getParamTypes(): Record<string, boolean>;
-    protected build(): void;
-}
-/**
- * EndpointMetadata contains metadata about a controller and his method.
- * Each annotation (@Get, @Body...) attached to a method are stored into endpoint.
- * EndpointMetadata convert this metadata to an array which contain arguments to call an Express method.
- *
- * Example :
- *```typescript
- * @Controller("/my-path")
- * provide MyClass {
- *
- *     @Get("/")
- *     @Authenticated()
- *     public myMethod(){}
- * }
- *```
- *
- * @alias JsonMethodStore
- */
-export type EndpointMetadata = JsonMethodStore;
-export declare const EndpointMetadata: typeof JsonMethodStore;

package/lib/types-esm/domain/JsonOperation.d.ts

@@ -1,51 +0,0 @@
-import { OpenSpecSecurity, OpenSpecTag, OS3Operation } from "@tsed/openspec";
-import { JsonHeader } from "../interfaces/JsonOpenSpec.js";
-import { JsonMap } from "./JsonMap.js";
-import { JsonParameter } from "./JsonParameter.js";
-import { JsonResponse } from "./JsonResponse.js";
-import { JsonSchema } from "./JsonSchema.js";
-export interface JsonMethodPath {
-    path: string | RegExp;
-    method: string;
-    [key: string]: any;
-}
-export interface JsonOperationOptions extends OS3Operation<JsonSchema, JsonParameter, JsonMap<JsonResponse>> {
-    consumes: string[];
-    produces: string[];
-}
-export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
-    #private;
-    $kind: string;
-    readonly operationPaths: Map<string, JsonMethodPath>;
-    constructor(obj?: Partial<JsonOperationOptions>);
-    get response(): JsonResponse | undefined;
-    get status(): number;
-    tags(tags: OpenSpecTag[]): this;
-    addTags(tags: OpenSpecTag[]): this;
-    summary(summary: string): this;
-    operationId(operationId: string): this;
-    responses(responses: JsonMap<any>): this;
-    defaultStatus(status: number): this;
-    getStatus(): number;
-    setRedirection(status?: number): this;
-    isRedirection(status?: number): boolean | 0;
-    addResponse(statusCode: string | number, response: JsonResponse): this;
-    getResponses(): JsonMap<JsonResponse>;
-    getResponseOf(status: number | string): JsonResponse;
-    ensureResponseOf(status: number | string): JsonResponse;
-    getHeadersOf(status: number): Record<string, JsonHeader & {
-        example: string;
-    }>;
-    getContentTypeOf(status: number): any;
-    security(security: OpenSpecSecurity): this;
-    addSecurityScopes(name: string, scopes: string[]): this;
-    description(description: string): this;
-    deprecated(deprecated: boolean): this;
-    parameters(parameters: JsonParameter[]): this;
-    addParameter(index: number, parameter: JsonParameter): void;
-    consumes(consumes: string[]): this;
-    produces(produces: string[]): this;
-    addProduce(produce: string): void;
-    addOperationPath(method: string, path: string | RegExp, options?: any): this;
-    getAllowedOperationPath(allowedVerbs?: string[]): JsonMethodPath[];
-}

package/lib/types-esm/domain/JsonOperationPathsMap.d.ts

@@ -1,7 +0,0 @@
-import { JsonMethodPath } from "./JsonOperation.js";
-export declare class JsonOperationPathsMap extends Map<string, JsonMethodPath> {
-    $kind: string;
-    readonly $isJsonDocument = true;
-    setOperationPath(operationPath: JsonMethodPath): void;
-    protected getKey: (method: string, path: any) => string;
-}

package/lib/types-esm/domain/JsonOperationRoute.d.ts

@@ -1,25 +0,0 @@
-import { Type } from "@tsed/core";
-import { JsonMethodStore } from "./JsonMethodStore.js";
-import { JsonMethodPath, JsonOperation } from "./JsonOperation.js";
-export declare class JsonOperationRoute<Entity extends JsonMethodStore = JsonMethodStore> {
-    readonly token: Type<any>;
-    readonly endpoint: Entity;
-    readonly operationPath?: JsonMethodPath;
-    readonly basePath?: string;
-    readonly paramsTypes: Record<string, boolean>;
-    constructor(options: Partial<JsonOperationRoute>);
-    get url(): any;
-    get path(): string | RegExp | undefined;
-    get fullPath(): any;
-    get method(): string;
-    get name(): string;
-    get className(): string;
-    get methodClassName(): string;
-    get parameters(): import("./JsonParameterStore.js").JsonParameterStore[];
-    get propertyKey(): string;
-    get propertyName(): string;
-    get store(): import("@tsed/core").Store;
-    get operation(): JsonOperation;
-    get operationId(): any;
-    has(key: string): boolean;
-}

package/lib/types-esm/domain/JsonParameter.d.ts

@@ -1,22 +0,0 @@
-import { Type } from "@tsed/core";
-import { OpenSpecHash, OpenSpecRef, OS3Example, OS3Parameter } from "@tsed/openspec";
-import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
-import { NestedGenerics } from "../utils/generics.js";
-import { JsonMap } from "./JsonMap.js";
-import { JsonSchema } from "./JsonSchema.js";
-export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> implements NestedGenerics {
-    $kind: string;
-    nestedGenerics: Type<any>[][];
-    groups: string[];
-    groupsName: string;
-    $schema: JsonSchema;
-    expression: string;
-    getName(): any;
-    name(name: string): this;
-    examples(examples: OpenSpecHash<OS3Example | OpenSpecRef>): this;
-    description(description: string): this;
-    in(inType: string, expression?: string | any): this;
-    required(required: boolean): this;
-    schema(schema: JsonSchema): this;
-    toJSON(options?: JsonSchemaOptions): any;
-}