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

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/types/domain/JsonMethodStore.d.ts

@@ -0,0 +1,40 @@
+import { JsonEntityStore, JsonEntityStoreOptions } 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;
+    middlewares: any[];
+    beforeMiddlewares: any[];
+    afterMiddlewares: any[];
+    constructor(options: JsonEntityStoreOptions);
+    /**
+     * 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;
+    /**
+     * 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;
+}

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

@@ -7,6 +7,7 @@ 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>> {

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/{domain → types/domain}/JsonParameter.d.ts

@@ -1,5 +1,5 @@
 import { Type } from "@tsed/core";
-import { OS3Parameter } from "@tsed/openspec";
+import { OpenSpecHash, OpenSpecRef, OS3Example, OS3Parameter } from "@tsed/openspec";
 import { JsonSchemaOptions } from "../interfaces";
 import { NestedGenerics } from "../utils/generics";
 import { JsonMap } from "./JsonMap";
@@ -8,8 +8,10 @@ export declare class JsonParameter extends JsonMap<OS3Parameter<JsonSchema>> imp
     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;

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/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/{domain → types/domain}/JsonSchema.d.ts

@@ -1,5 +1,5 @@
 import { Hooks, Type, ValueOf } from "@tsed/core";
-import { JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version } from "json-schema";
+import type { JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version } from "json-schema";
 import { JsonSchemaOptions } from "../interfaces";
 import { IgnoreCallback } from "../interfaces/IgnoreCallback";
 import { NestedGenerics } from "../utils/generics";
@@ -14,29 +14,19 @@ export interface JsonSchemaObject extends JSONSchema6, Record<string, any> {
 }
 export declare type AnyJsonSchema = Partial<JsonSchemaObject> | JsonSchema | JsonLazyRef | any;
 export declare class JsonSchema extends Map<string, any> implements NestedGenerics {
+    #private;
     readonly isJsonSchema = true;
     readonly $hooks: Hooks;
     readonly $required: Set<string>;
     readonly $allow: any[];
     $selfRequired: boolean;
     $forwardGroups: boolean;
-    protected _nullable: boolean;
-    protected _genericLabels: string[];
-    protected _nestedGenerics: Type<any>[][];
-    protected _alias: AliasMap;
-    protected _itemSchema: JsonSchema;
-    protected _target: Type<any>;
-    protected _isGeneric: boolean;
-    protected _isCollection: boolean;
-    protected _ref: boolean;
     constructor(obj?: JsonSchema | Partial<JsonSchemaObject>);
     get alias(): AliasMap;
     get nestedGenerics(): any[];
     set nestedGenerics(value: any[]);
     get genericLabels(): string[];
     set genericLabels(value: string[]);
-    get nullable(): boolean;
-    set nullable(value: boolean);
     get isClass(): boolean;
     /**
      * Current schema is a collection
@@ -53,7 +43,11 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
     get genericType(): string;
     get class(): any;
     get canRef(): boolean;
+    get isNullable(): boolean;
+    get isReadOnly(): any;
+    get isWriteOnly(): any;
     static from(obj?: Partial<JsonSchemaObject>): JsonSchema;
+    nullable(value: boolean): void;
     itemSchema(obj?: AnyJsonSchema): JsonSchema;
     getAliasOf(property: AliasType): AliasType | undefined;
     addAlias(property: AliasType, alias: AliasType): this;

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

@@ -1,5 +1,8 @@
 export declare enum SpecTypes {
     JSON = "jsonschema",
+    /**
+     * @deprecated
+     */
     SWAGGER = "swagger2",
     OPENAPI = "openapi3"
 }

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

@@ -7,5 +7,10 @@ export * from "./JsonSchema";
 export * from "./JsonFormatTypes";
 export * from "./SpecTypes";
 export * from "./JsonEntityStore";
+export * from "./JsonClassStore";
+export * from "./JsonMethodStore";
+export * from "./JsonParameterStore";
+export * from "./JsonPropertyStore";
+export * from "./JsonOperationRoute";
 export * from "./JsonParameterTypes";
 export * from "./JsonLazyRef";

package/lib/types/hooks/alterOneOf.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../domain/JsonSchema";
+import type { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
+export declare function alterOneOf(obj: any, schema: JsonSchema, options: JsonSchemaOptions): any;

package/lib/{index.d.ts → types/index.d.ts}

@@ -4,12 +4,15 @@ export * from "./utils/getJsonSchema";
 export * from "./utils/getJsonType";
 export * from "./utils/getPropertiesStores";
 export * from "./utils/getOperationsStores";
+export * from "./utils/getOperationsRoutes";
 export * from "./utils/getSpec";
 export * from "./utils/mergeSpec";
 export * from "./utils/generics";
 export * from "./utils/mapHeaders";
+export * from "./utils/matchGroups";
 export * from "./utils/isSuccessStatus";
 export * from "./utils/from";
+export * from "./utils/concatPath";
 export * from "./utils/defineStatusModel";
 export * from "./domain";
 export * from "./hooks/alterIgnore";

package/lib/{registries → types/registries}/JsonSchemaMapperContainer.d.ts

@@ -2,7 +2,7 @@
  * @ignore
  */
 export interface JsonSchemaMapper {
-    (schema: any, options: any): any;
+    (schema: any, options: any, parent?: any): any;
 }
 /**
  * @ignore
@@ -15,4 +15,5 @@ export declare function getJsonSchemaMapper(type: string): JsonSchemaMapper;
 /**
  * @ignore
  */
-export declare function execMapper(type: string, schema: any, options: any): any;
+export declare function execMapper(type: string, schema: any, options: any, parent?: any): any;
+export declare function hasMapper(type: string): boolean;

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

@@ -0,0 +1 @@
+export declare function concatPath(basePath: string | undefined, path: string | undefined): string;

package/lib/{utils → types/utils}/getInheritedStores.d.ts

@@ -1,8 +1,8 @@
 import { Type } from "@tsed/core";
-import { JsonEntityStore } from "../domain/JsonEntityStore";
+import type { JsonClassStore } from "../domain/JsonClassStore";
 /**
  * Return store and his inherited stores
  * @param target
  * @ignore
  */
-export declare function getInheritedStores(target: Type<any> | any): Map<Type<any>, JsonEntityStore>;
+export declare function getInheritedStores(target: Type<any> | any): Map<Type<any>, JsonClassStore>;

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

@@ -0,0 +1,15 @@
+import { Type } from "@tsed/core";
+import { JsonEntityStore } from "../domain/JsonEntityStore";
+import { JsonClassStore } from "../domain/JsonClassStore";
+import { JsonPropertyStore } from "../domain/JsonPropertyStore";
+import { JsonParameterStore } from "../domain/JsonParameterStore";
+import { JsonMethodStore } from "../domain/JsonMethodStore";
+/**
+ * Get entity store from decorator args
+ * @param target
+ */
+export declare function getJsonEntityStore<T extends JsonClassStore = JsonClassStore>(target: Type<any>): T;
+export declare function getJsonEntityStore<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any, propertyKey: string | symbol): T;
+export declare function getJsonEntityStore<T extends JsonParameterStore = JsonParameterStore>(target: Type<any> | any, propertyKey: string | symbol, index: number): T;
+export declare function getJsonEntityStore<T extends JsonMethodStore = JsonMethodStore>(target: Type<any> | any, propertyKey: string | symbol, descriptor: PropertyDescriptor): T;
+export declare function getJsonEntityStore<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T;

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

@@ -0,0 +1,4 @@
+import { Type } from "@tsed/core";
+import "../components";
+import { JsonSchemaOptions } from "../interfaces";
+export declare function getJsonSchema(model: Type<any> | any, options?: JsonSchemaOptions): any;

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

@@ -0,0 +1,8 @@
+import { Type } from "@tsed/core";
+import { JsonOperationRoute } from "../domain/JsonOperationRoute";
+import { JsonEntityStore } from "../domain/JsonEntityStore";
+export interface GetOperationsRoutesOptions {
+    withChildren?: boolean;
+    basePath?: string;
+}
+export declare function getOperationsRoutes<Entity extends JsonEntityStore = JsonEntityStore>(token: Type<any> | any, options?: GetOperationsRoutesOptions): JsonOperationRoute<Entity>[];

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

@@ -0,0 +1,6 @@
+import { Type } from "@tsed/core";
+import { JsonMethodStore } from "../domain/JsonMethodStore";
+/**
+ * @ignore
+ */
+export declare function getOperationsStores<T extends JsonMethodStore = JsonMethodStore>(target: Type<any> | any): Map<string, T>;

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

@@ -0,0 +1,20 @@
+import { Type } from "@tsed/core";
+import type { JsonPropertyStore } from "../domain/JsonPropertyStore";
+/**
+ * Return the list of properties including properties from inherited classes
+ * @param target
+ * @ignore
+ */
+export declare function getPropertiesStores<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any): Map<string | symbol | number, T>;
+/**
+ * @ignore
+ */
+export interface GetPropertiesOptions {
+    withIgnoredProps?: boolean;
+    groups?: string[] | false;
+    [type: string]: any;
+}
+/**
+ * @ignore
+ */
+export declare function getProperties<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any, options?: GetPropertiesOptions): Map<string | number | symbol, T>;

package/lib/{utils → types/utils}/mapRouteOptions.d.ts

@@ -1,5 +1,5 @@
 export declare function mapRouteOptions(args: any[]): {
     path: undefined;
     method: undefined;
-    handlers: any[];
+    use: any[];
 };

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

@@ -0,0 +1,14 @@
+import type { JsonSchema } from "../domain/JsonSchema";
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions";
+/**
+ * @ignore
+ */
+export declare function createRefName(name: string, options: JsonSchemaOptions): string;
+/**
+ * @ignore
+ */
+export declare function createRef(name: string, schema: JsonSchema, options: JsonSchemaOptions): any;
+/**
+ * @ignore
+ */
+export declare function toRef(value: JsonSchema, schema: any, options: JsonSchemaOptions): any;