@tsed/schema 6.88.0 → 6.91.0

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

@@ -0,0 +1,132 @@
+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>;
+    [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;
+}

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

@@ -0,0 +1,17 @@
+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/domain/JsonLazyRef.d.ts

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

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

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

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

@@ -0,0 +1,19 @@
+import { JsonEntityStore } from "./JsonEntityStore";
+import { JsonOperation } from "./JsonOperation";
+import type { JsonParameterStore } from "./JsonParameterStore";
+import type { JsonClassStore } from "./JsonClassStore";
+export declare class JsonMethodStore extends JsonEntityStore {
+    readonly parent: JsonClassStore;
+    /**
+     * 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>;
+    get parameters(): JsonParameterStore[];
+    get operationPaths(): Map<string, import("./JsonOperation").JsonMethodPath>;
+    getResponseOptions(status: number, contentType?: string): undefined | any;
+    protected build(): void;
+}

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

@@ -0,0 +1,51 @@
+import { OpenSpecSecurity, OpenSpecTag, OS3Operation } from "@tsed/openspec";
+import { JsonHeader, JsonSchemaOptions } from "../interfaces";
+import { JsonMap } from "./JsonMap";
+import { JsonParameter } from "./JsonParameter";
+import { JsonResponse } from "./JsonResponse";
+import { JsonSchema } from "./JsonSchema";
+export interface JsonMethodPath {
+    path: string | RegExp;
+    method: string;
+    isFinal?: boolean;
+    [key: string]: any;
+}
+export interface JsonOperationOptions extends OS3Operation<JsonSchema, JsonParameter, JsonMap<JsonResponse>> {
+    consumes: string[];
+    produces: string[];
+}
+export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
+    #private;
+    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;
+    toJSON(options?: JsonSchemaOptions): any;
+}

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { Type } from "@tsed/core";
+import { OpenSpecHash, OpenSpecRef, OS3Example, OS3Parameter } from "@tsed/openspec";
+import { JsonSchemaOptions } from "../interfaces";
+import { NestedGenerics } from "../utils/generics";
+import { JsonMap } from "./JsonMap";
+import { JsonSchema } from "./JsonSchema";
+export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> implements NestedGenerics {
+    nestedGenerics: Type<any>[][];
+    groups: 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;
+    private build;
+    private refToParameters;
+}

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

@@ -0,0 +1,30 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore } from "./JsonEntityStore";
+import type { JsonMethodStore } from "./JsonMethodStore";
+import { JsonParameter } from "./JsonParameter";
+import { JsonSchema } from "./JsonSchema";
+export declare class JsonParameterStore extends JsonEntityStore {
+    /**
+     * Ref to JsonParameter when the decorated object is a parameter.
+     */
+    readonly parameter: JsonParameter;
+    readonly parent: JsonMethodStore;
+    get nestedGenerics(): Type<any>[][];
+    set nestedGenerics(nestedGenerics: Type<any>[][]);
+    /**
+     * Return the required state.
+     * @returns {boolean}
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    get allowedRequiredValues(): any[];
+    static getParams<T extends JsonParameterStore = JsonParameterStore>(target: Type<any>, propertyKey: string | symbol): T[];
+    /**
+     * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
+     * @param value
+     * @returns {boolean}
+     */
+    isRequired(value: any): boolean;
+    protected getSchema(type: any): JsonSchema;
+    protected build(): void;
+}

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

@@ -0,0 +1,16 @@
+export declare enum JsonParameterTypes {
+    BODY = "body",
+    PATH = "path",
+    QUERY = "query",
+    HEADER = "header",
+    COOKIES = "cookie",
+    FILES = "files"
+}
+/**
+ * @ignore
+ */
+export declare function formatParameterType(type: any): any;
+/**
+ * @ignore
+ */
+export declare function isParameterType(type: string): boolean;

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

@@ -0,0 +1,23 @@
+import { JsonEntityStore } from "./JsonEntityStore";
+import type { JsonClassStore } from "./JsonClassStore";
+export declare class JsonPropertyStore extends JsonEntityStore {
+    readonly parent: JsonClassStore;
+    /**
+     * Return the required state.
+     * @returns {boolean}
+     */
+    get required(): boolean;
+    /**
+     * Change the state of the required data.
+     * @param value
+     */
+    set required(value: boolean);
+    get allowedRequiredValues(): any[];
+    /**
+     * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
+     * @param value
+     * @returns {boolean}
+     */
+    isRequired(value: any): boolean;
+    protected build(): void;
+}

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

@@ -0,0 +1,11 @@
+import { OpenSpecHash, OS3MediaType, OS3RequestBody } from "@tsed/openspec";
+import { JsonMap } from "./JsonMap";
+import { JsonSchema } from "./JsonSchema";
+export declare type JsonRequestBodyOptions = OS3RequestBody<JsonSchema>;
+export declare class JsonRequestBody extends JsonMap<JsonRequestBodyOptions> {
+    constructor(obj?: Partial<JsonRequestBodyOptions>);
+    description(description: string): this;
+    content(content: OpenSpecHash<OS3MediaType<JsonSchema>>): this;
+    addContent(mediaType: string, schema: JsonSchema): this;
+    required(required: boolean): this;
+}

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

@@ -0,0 +1,22 @@
+import { OS3MediaType, OS3Response } from "@tsed/openspec";
+import { JsonHeader, JsonSchemaOptions } from "../interfaces";
+import { JsonMap } from "./JsonMap";
+import { JsonSchema } from "./JsonSchema";
+export declare type JsonResponseOptions = OS3Response<JsonSchema, string | JsonHeader>;
+export declare class JsonMedia extends JsonMap<OS3MediaType<JsonSchema>> {
+    groups: string[];
+    schema(schema: JsonSchema): this;
+    examples(examples: any): this;
+    toJSON(options?: JsonSchemaOptions): any;
+}
+export declare class JsonResponse extends JsonMap<JsonResponseOptions> {
+    status: number;
+    constructor(obj?: Partial<JsonResponseOptions>);
+    description(description: string): this;
+    headers(headers: Record<string, string | JsonHeader>): this;
+    content(content: Record<string, OS3MediaType<JsonSchema>>): this;
+    getContent(): JsonMap<JsonMedia>;
+    getMedia(mediaType: string, create?: boolean): JsonMedia;
+    addMedia(mediaType: string): this;
+    toJSON(options?: JsonSchemaOptions): any;
+}