@tsed/schema 8.13.5 → 8.14.0

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

@@ -24,8 +24,6 @@ export declare class JsonParameterStore extends JsonEntityStore {
     readonly parameter: JsonParameter;
     readonly parent: JsonMethodStore;
     constructor(options: JsonParameterStoreOptions);
-    get nestedGenerics(): Type<any>[][];
-    set nestedGenerics(nestedGenerics: Type<any>[][]);
     /**
      * Return the required state.
      * @returns {boolean}

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

@@ -3,27 +3,8 @@ import type { JsonClassStore } from "./JsonClassStore.js";
 import { JsonEntityStore } from "./JsonEntityStore.js";
 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[];
-    discriminatorKey(): this;
-    isDiscriminatorKey(): boolean;
-    /**
-     * 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;
     static get(target: Type<any>, propertyKey: string | symbol): JsonPropertyStore;
+    protected build(): void;
 }
 /**
  * @alias JsonPropertyStore

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

@@ -1,68 +1,100 @@
 import { Type, ValueOf } from "@tsed/core";
 import { Hooks } from "@tsed/hooks";
-import type { JSONSchema6, JSONSchema6Definition, JSONSchema6Type, JSONSchema6TypeName, JSONSchema6Version } from "json-schema";
+import type { JSONSchema7, JSONSchema7Definition, JSONSchema7Type, JSONSchema7TypeName, JSONSchema7Version } from "json-schema";
+import { VendorKeys } from "../constants/VendorKeys.js";
 import { IgnoreCallback } from "../interfaces/IgnoreCallback.js";
 import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
-import { NestedGenerics } from "../utils/generics.js";
+import { type GenericsMap, GenericValue } from "../utils/generics.js";
 import { AliasMap, AliasType } from "./JsonAliasMap.js";
 import { Discriminator } from "./JsonDiscriminator.js";
 import { JsonFormatTypes } from "./JsonFormatTypes.js";
 import { JsonLazyRef } from "./JsonLazyRef.js";
-export interface JsonSchemaObject extends JSONSchema6, Record<string, any> {
-    type: (any | JSONSchema6TypeName) | (any | JSONSchema6TypeName)[];
-    additionalProperties?: boolean | JSONSchema6 | any;
-    propertyNames?: boolean | JSONSchema6 | any;
-    items?: (any | JSONSchema6Definition) | (any | JSONSchema6Definition)[];
+export interface JsonSchemaObject extends Omit<JSONSchema7, "type" | "additionalProperties" | "items"> {
+    type?: Type | JSONSchema7["type"] | null | (String | null | Date | Number | Object | Boolean)[];
+    additionalProperties?: boolean | JSONSchema7 | Type | JsonSchema;
+    items?: (Type | JSONSchema7Definition | JsonSchema) | (Type | JSONSchema7Definition | JsonSchema)[];
 }
-export type AnyJsonSchema = Partial<JsonSchemaObject> | JsonSchema | JsonLazyRef | any;
-export declare class JsonSchema extends Map<string, any> implements NestedGenerics {
+export type AnyJsonSchema = JsonSchemaObject | JSONSchema7 | JsonSchema | JsonLazyRef | {
+    label?: string;
+} | Type;
+export declare class JsonSchema extends Map<string, any> {
     #private;
     readonly $kind: string;
     readonly $isJsonDocument = true;
     readonly $hooks: Hooks;
-    readonly $required: Set<string>;
     readonly $allow: any[];
     $selfRequired: boolean;
-    $forwardGroups: boolean;
     $ignore: boolean | IgnoreCallback;
     isDiscriminatorKey: boolean;
     isDiscriminator: boolean;
     constructor(obj?: JsonSchema | Partial<JsonSchemaObject>);
     get alias(): AliasMap;
-    get nestedGenerics(): any[];
-    set nestedGenerics(value: any[]);
-    get genericLabels(): string[];
-    set genericLabels(value: string[]);
     get isClass(): boolean;
     /**
-     * Current schema is a collection
+     * The current schema is a collection
      */
     get isCollection(): boolean;
+    /**
+     * The current schema is a reference to another schema
+     * to link property/param to a class schema (if the reference exists).
+     */
+    get isLocalSchema(): boolean;
     /**
      * Current schema is a generic
      */
     get isGeneric(): boolean;
     get discriminatorAncestor(): any;
     /**
-     * Current schema has generics items
+     * Return the itemSchema computed type.
+     * If the type is a function used for a recursive model,
+     * the function will be called to get the right type.
+     */
+    get class(): Type<any>;
+    /**
+     * Return the itemSchema computed type.
      */
-    get hasGenerics(): boolean;
-    get genericType(): string;
-    get class(): any;
+    get collectionClass(): Type<any>;
     get canRef(): boolean;
     get isNullable(): boolean;
     get isReadOnly(): any;
     get isWriteOnly(): any;
     get hasDiscriminator(): boolean;
-    static from(obj?: Partial<JsonSchemaObject>): JsonSchema;
-    nullable(value: boolean): void;
+    static from(item?: Partial<JsonSchemaObject> | Type<any> | JsonSchema): JsonSchema;
+    /**
+     * Check if the schema as key, #key or x-key
+     * @param key
+     */
+    has(key: string): boolean;
+    /**
+     * Get the value of the schema by key, #key or x-key.
+     * @param key
+     * @param defaultValue
+     */
+    get<T = any>(key: string, defaultValue: T): T;
+    get<T = any>(key: string, defaultValue?: T): T | undefined;
+    forwardGroups(bool?: boolean): this;
+    groups(groups?: string[], isProperty?: boolean): this;
+    groupsName(groupsName?: string): this;
+    allowedGroups(groups?: string[]): this;
+    /**
+     * Assign the Generic Labels used over a class or a schema.
+     * @param genericLabels
+     */
+    genericLabels(genericLabels: string[]): this;
+    genericLabel(genericLabel: string): this;
+    /**
+     * Assign the types of the generics that must be used for the property
+     * @param generics
+     */
+    genericOf(...generics: GenericValue[][]): this;
+    nullable(value: boolean): this;
     itemSchema(obj?: AnyJsonSchema): JsonSchema;
     getAliasOf(property: AliasType): AliasType | undefined;
     addAlias(property: AliasType, alias: AliasType): this;
     removeAlias(property: AliasType): this;
     $id($id: string): this;
     $ref($ref: string): this;
-    $schema($schema: JSONSchema6Version): this;
+    $schema($schema: JSONSchema7Version): this;
     /**
      * Create a ref and use name to sharing schema
      * @param name
@@ -75,12 +107,12 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      * It is RECOMMENDED that a default value be valid against the associated schema.
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
      */
-    default(value: JSONSchema6Type | undefined | (() => JSONSchema6Type)): this;
+    default(value: JSONSchema7Type | undefined | (() => JSONSchema7Type)): this;
     /**
      * More readible form of a one-element "enum"
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
      */
-    const(value: JSONSchema6Type): this;
+    const(value: JSONSchema7Type): this;
     /**
      * This attribute is a string that provides a full description of the of purpose the instance property.
      *
@@ -104,17 +136,17 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
      */
-    contains(contains: JSONSchema6Definition): this;
+    contains(contains: JSONSchema7Definition): this;
     /**
      * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
      */
-    examples(examples: JSONSchema6Type[]): this;
+    examples(examples: JSONSchema7Type[]): this;
     /**
      * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
      */
-    example(...examples: JSONSchema6Type[]): this;
+    example(...examples: JSONSchema7Type[]): this;
     /**
      * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
      * Omitting this keyword has the same behavior as an empty schema.
@@ -167,6 +199,7 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
     addRequired(property: string): this;
     removeRequired(property: string): this;
     isRequired(property: string): boolean;
+    getRequiredFields(): string[];
     /**
      * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
      * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
@@ -211,7 +244,7 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
      */
     dependencies(dependencies: {
-        [p: string]: JSONSchema6Definition | JsonSchema | string[];
+        [p: string]: JSONSchema7Definition | JsonSchema | string[];
     }): this;
     /**
      * Takes a schema which validates the names of all properties rather than their values.
@@ -219,7 +252,7 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      * Omitting this keyword has the same behavior as an empty schema.
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
      */
-    propertyNames(propertyNames: JSONSchema6Definition | JsonSchema): this;
+    propertyNames(propertyNames: JSONSchema7Definition | JsonSchema): this;
     /**
      * This provides an enumeration of all possible values that are valid
      * for the instance property. This MUST be an array, and each item in
@@ -304,7 +337,7 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
      * A single type, or a union of simple types
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
      */
-    type(type: any | JSONSchema6TypeName | JSONSchema6TypeName[]): this;
+    type(type: any | JSONSchema7TypeName | JSONSchema7TypeName[]): this;
     any(...types: any[]): this;
     integer(): this;
     /**
@@ -316,26 +349,36 @@ export declare class JsonSchema extends Map<string, any> implements NestedGeneri
     readOnly(readOnly: boolean): this;
     writeOnly(readOnly: boolean): this;
     customKey(key: string, value: any): this;
+    vendorKey(key: VendorKeys, value: any): this;
     toObject(options?: JsonSchemaOptions): any;
     toJSON(options?: JsonSchemaOptions): any;
-    assign(obj?: JsonSchema | Partial<JsonSchemaObject>): this;
+    assign(obj?: AnyJsonSchema): this;
     set(key: string, value: any): this;
-    /**
-     * 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.
-     */
-    getComputedType(): any;
-    getComputedItemType(): any;
     /**
      * Return the Json type as string
      */
     getJsonType(): string | string[];
     getTarget(): Type<any>;
+    getAllowedGroups(): Set<string> | undefined;
+    getAllowedRequiredValues(): any[];
+    getGroups(): string[] | undefined;
+    getGroupsName(): string | undefined;
     /**
      * Get the symbolic name of the entity
      */
     getName(): any;
     clone(): JsonSchema;
+    getGenericLabels(): string[] | undefined;
+    getGenericOf(): GenericsMap | undefined;
+    /**
+     * Returns the reference schema for class-based schemas.
+     * Used to get the original schema definition when this schema is a local reference.
+     * @returns The reference schema or undefined if not applicable
+     */
+    getRefSchema(): JsonSchema | undefined;
+    propertyKey(s: string): this;
+    getPropertyKey(): string | symbol | undefined;
+    target(target: any): void;
+    isRequiredValue(property: string, value: any): boolean;
     protected setManyOf(keyword: "oneOf" | "anyOf" | "allOf", value: AnyJsonSchema[]): this | undefined;
 }

package/lib/types/index.d.ts

@@ -1,24 +1,18 @@
 /**
  * @file Automatically generated by @tsed/barrels.
  */
-export * from "./components/async-api/channelsMapper.js";
-export * from "./components/async-api/generate.js";
-export * from "./components/async-api/messageMapper.js";
-export * from "./components/async-api/payloadMapper.js";
-export * from "./components/async-api/responseMapper.js";
 export * from "./components/default/anyMapper.js";
 export * from "./components/default/classMapper.js";
 export * from "./components/default/discriminatorMappingMapper.js";
 export * from "./components/default/enumsMapper.js";
 export * from "./components/default/genericsMapper.js";
 export * from "./components/default/inheritedClassMapper.js";
-export * from "./components/default/itemMapper.js";
 export * from "./components/default/lazyRefMapper.js";
 export * from "./components/default/mapMapper.js";
+export * from "./components/default/nextMapper.js";
 export * from "./components/default/nullableMapper.js";
 export * from "./components/default/objectMapper.js";
 export * from "./components/default/ofMapper.js";
-export * from "./components/default/propertiesMapper.js";
 export * from "./components/default/requiredMapper.js";
 export * from "./components/default/schemaMapper.js";
 export * from "./components/index.js";
@@ -38,6 +32,7 @@ export * from "./components/open-spec/pathsMapper.js";
 export * from "./constants/httpStatusMessages.js";
 export * from "./constants/jsonSchemaProperties.js";
 export * from "./constants/OperationVerbs.js";
+export * from "./constants/VendorKeys.js";
 export * from "./decorators/class/children.js";
 export * from "./decorators/class/discriminatorValue.js";
 export * from "./decorators/collections/collectionContains.js";
@@ -190,12 +185,12 @@ export * from "./utils/mapOpenSpec3.js";
 export * from "./utils/mapOpenSpecInfo.js";
 export * from "./utils/mapOperationOptions.js";
 export * from "./utils/matchGroups.js";
+export * from "./utils/mergeSchema.js";
 export * from "./utils/mergeSpec.js";
 export * from "./utils/operationIdFormatter.js";
 export * from "./utils/ref.js";
 export * from "./utils/removeHiddenOperation.js";
 export * from "./utils/serializeEnumValues.js";
-export * from "./utils/somethingOf.js";
 export * from "./utils/toJsonMapCollection.js";
 export * from "./utils/toJsonRegex.js";
 export * from "./utils/transformToOS2.js";

package/lib/types/interfaces/JsonSchemaOptions.d.ts

@@ -1,4 +1,5 @@
 import { SpecTypes } from "../domain/SpecTypes.js";
+import type { GenericsMap } from "../utils/generics.js";
 export interface JsonSchemaOptions {
     /**
      * Map properties with the alias name. By default, false
@@ -13,12 +14,16 @@ export interface JsonSchemaOptions {
      */
     specType?: SpecTypes;
     /**
-     * Define a groups restriction to generate the JsonSchema.
+     * Define the spec version for OPENAPI (3.1.0, 3.0.3, 3.0.2, 3.0.1, 3.0.0)
+     */
+    specVersion?: string;
+    /**
+     * Define a group restriction to generate the JsonSchema.
      * Set false to disable groups.
      */
     groups?: string[] | false;
     /**
-     * Set the postfix groups name for generated model and ref.
+     * Set the postfix groups name for a generated model and ref.
      */
     groupsName?: string;
     /**
@@ -29,5 +34,14 @@ export interface JsonSchemaOptions {
      * Inline enums when enum instead of using $ref.
      */
     inlineEnums?: boolean;
+    /**
+     * Represents optional generic definitions that adhere to the JSON Schema standard.
+     *
+     * This property allows the specification of generics when constructing or representing a JSON schema.
+     * It can be used to define reusable and parameterized components within the schema structure.
+     *
+     * @type {GenericsMap|undefined}
+     */
+    generics?: GenericsMap;
     [key: string]: any;
 }

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

@@ -1,50 +1,9 @@
 import { Type } from "@tsed/core";
 import { JsonSchema } from "../domain/JsonSchema.js";
-export type GenericValue = Type<any> | JsonSchema | any;
-/**
- * @ignore
- */
-export type GenericsMap = Map<string, GenericValue>;
-/**
- * @ignore
- */
-export interface GenericTypes {
-    genericTypes: Type<any>[];
-    [key: string]: any;
-}
-/**
- * @ignore
- */
-export interface GenericLabels {
-    genericLabels: string[];
-    [key: string]: any;
-}
-/**
- * @ignore
- */
-export interface NestedGenerics {
-    nestedGenerics: GenericValue[][];
-    [key: string]: any;
-}
-/**
- * @ignore
- */
-export interface GenericsContext extends GenericTypes, GenericLabels, NestedGenerics {
-    generics: GenericsMap;
-}
-/**
- * @ignore
- * @param genericLabels
- * @param genericTypes
- */
-export declare function getGenericsMap(genericLabels: string[], genericTypes: GenericValue[]): GenericsMap;
-/**
- * @ignore
- * @param options
- */
-export declare function mapGenericsOptions(options: Partial<GenericTypes & GenericLabels>): Partial<GenericTypes & GenericLabels>;
-/**
- * @ignore
- * @param value
- */
-export declare function popGenerics(value: NestedGenerics): NestedGenerics & GenericTypes;
+import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
+export type GenericValue = Type<any> | JsonSchema | String | Number | Boolean | Object | Date;
+export type GenericsMap = Record<string, [GenericValue] | [GenericValue, GenericsMap]>;
+export declare function getGenericsOptions(value: JsonSchema, options: JsonSchemaOptions): {
+    generics: GenericsMap | undefined;
+    mapper: string;
+};

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

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

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

@@ -0,0 +1,2 @@
+import type { JSONSchema7 } from "json-schema";
+export declare function mergeSchema(schema1: JSONSchema7, schema2: JSONSchema7): JSONSchema7;

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

@@ -1,5 +1,7 @@
+import type { JSONSchema7 } from "json-schema";
 import type { JsonSchema } from "../domain/JsonSchema.js";
 import { JsonSchemaOptions } from "../interfaces/JsonSchemaOptions.js";
+export declare function getSchemaFromRef($ref: string | undefined, options: JsonSchemaOptions): JSONSchema7 | undefined;
 /**
  * @ignore
  */
@@ -7,8 +9,8 @@ export declare function createRefName(name: string, options: JsonSchemaOptions):
 /**
  * @ignore
  */
-export declare function createRef(name: string, schema: JsonSchema, options: JsonSchemaOptions): any;
+export declare function createRef(name: string, schema: JsonSchema, options: JsonSchemaOptions): JSONSchema7;
 /**
  * @ignore
  */
-export declare function toRef(value: JsonSchema, schema: unknown | undefined, options: JsonSchemaOptions): any;
+export declare function toRef(value: JsonSchema, schema: JSONSchema7 | undefined | null, options: JsonSchemaOptions): JSONSchema7;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/schema",
   "description": "JsonSchema module for Ts.ED Framework",
   "type": "module",
-  "version": "8.13.5",
+  "version": "8.14.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -34,7 +34,7 @@
     "tsed"
   ],
   "dependencies": {
-    "@tsed/openspec": "8.13.5",
+    "@tsed/openspec": "8.14.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.13.5",
-    "@tsed/core": "8.13.5",
-    "@tsed/hooks": "8.13.5",
-    "@tsed/openspec": "8.13.5",
-    "@tsed/typescript": "8.13.5",
+    "@tsed/barrels": "8.14.0",
+    "@tsed/core": "8.14.0",
+    "@tsed/hooks": "8.14.0",
+    "@tsed/openspec": "8.14.0",
+    "@tsed/typescript": "8.14.0",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.2",

package/lib/esm/components/async-api/channelsMapper.js

@@ -1,57 +0,0 @@
-import { camelCase } from "change-case";
-import { OperationVerbs } from "../../constants/OperationVerbs.js";
-import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { buildPath } from "../../utils/buildPath.js";
-import { getJsonEntityStore } from "../../utils/getJsonEntityStore.js";
-import { getOperationsStores } from "../../utils/getOperationsStores.js";
-import { removeHiddenOperation } from "../../utils/removeHiddenOperation.js";
-const ALLOWED_VERBS = [OperationVerbs.PUBLISH, OperationVerbs.SUBSCRIBE];
-function pushToChannels(options) {
-    return (channels, { operationPath, operationStore }) => {
-        const path = options.ctrlRootPath || "/";
-        const method = operationPath.method.toLowerCase();
-        const operationId = camelCase(`${method.toLowerCase()} ${operationStore.parent.schema.getName()}`);
-        const message = execMapper("message", [operationStore, operationPath], options);
-        return {
-            ...channels,
-            [path]: {
-                ...channels[path],
-                [method]: {
-                    ...channels[path]?.[method],
-                    operationId,
-                    message: {
-                        oneOf: [...(channels[path]?.[method]?.message?.oneOf || []), message]
-                    }
-                }
-            }
-        };
-    };
-}
-function expandOperationPaths(options) {
-    return (operationStore) => {
-        const operationPaths = operationStore.operation.getAllowedOperationPath(ALLOWED_VERBS);
-        if (operationPaths.length === 0) {
-            return [];
-        }
-        return operationPaths.map((operationPath) => {
-            return {
-                operationPath,
-                operationStore
-            };
-        });
-    };
-}
-export function channelsMapper(model, { channels, rootPath, ...options }) {
-    const store = getJsonEntityStore(model);
-    const ctrlPath = store.path;
-    const ctrlRootPath = buildPath(rootPath + ctrlPath);
-    options = {
-        ...options,
-        ctrlRootPath
-    };
-    return [...getOperationsStores(model).values()]
-        .filter(removeHiddenOperation)
-        .flatMap(expandOperationPaths(options))
-        .reduce(pushToChannels(options), channels);
-}
-registerJsonSchemaMapper("channels", channelsMapper);

package/lib/esm/components/async-api/generate.js

@@ -1,17 +0,0 @@
-import { uniqBy } from "@tsed/core";
-import { SpecTypes } from "../../domain/SpecTypes.js";
-import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-function generate(model, options) {
-    const specJson = {
-        channels: execMapper("channels", [model], options)
-    };
-    specJson.tags = uniqBy(options.tags, "name");
-    if (options.components?.schemas && Object.keys(options.components.schemas).length) {
-        specJson.components = {
-            ...options.components,
-            schemas: options.components.schemas
-        };
-    }
-    return specJson;
-}
-registerJsonSchemaMapper("generate", generate, SpecTypes.ASYNCAPI);

package/lib/esm/components/async-api/messageMapper.js

@@ -1,39 +0,0 @@
-import { cleanObject, getValue } from "@tsed/core";
-import { OperationVerbs } from "../../constants/OperationVerbs.js";
-import { SpecTypes } from "../../domain/SpecTypes.js";
-import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { makeOf } from "../../utils/somethingOf.js";
-export function messageMapper(jsonOperationStore, operationPath, { tags = [], defaultTags = [], ...options } = {}) {
-    const { path: event, method } = operationPath;
-    const messageKey = String(event);
-    let message = getValue(options.components, "messages." + event, cleanObject({
-        description: jsonOperationStore.operation.get("description"),
-        summary: jsonOperationStore.operation.get("summary")
-    }));
-    if (method.toUpperCase() === OperationVerbs.PUBLISH) {
-        const payload = execMapper("payload", [jsonOperationStore, operationPath], options);
-        if (payload) {
-            message.payload = payload;
-        }
-        const responses = jsonOperationStore.operation
-            .getAllowedOperationPath([OperationVerbs.SUBSCRIBE])
-            .map((operationPath) => {
-            return execMapper("message", [jsonOperationStore, operationPath], options);
-        })
-            .filter(Boolean);
-        const responsesSchema = makeOf("oneOf", responses);
-        if (responsesSchema) {
-            message["x-response"] = responsesSchema;
-        }
-    }
-    else {
-        const response = execMapper("response", [jsonOperationStore, operationPath], options);
-        if (response) {
-            message["x-response"] = response;
-        }
-    }
-    options.components.messages = options.components.messages || {};
-    options.components.messages[messageKey] = message;
-    return { $ref: `#/components/messages/${messageKey}` };
-}
-registerJsonSchemaMapper("message", messageMapper, SpecTypes.ASYNCAPI);

package/lib/esm/components/async-api/payloadMapper.js

@@ -1,47 +0,0 @@
-import { setValue } from "@tsed/core";
-import { pascalCase } from "change-case";
-import { isParameterType, JsonParameterTypes } from "../../domain/JsonParameterTypes.js";
-import { SpecTypes } from "../../domain/SpecTypes.js";
-import { execMapper, registerJsonSchemaMapper } from "../../registries/JsonSchemaMapperContainer.js";
-import { popGenerics } from "../../utils/generics.js";
-import { makeOf } from "../../utils/somethingOf.js";
-function mapOptions(parameter, options = {}) {
-    return {
-        ...options,
-        groups: parameter.groups,
-        groupsName: parameter.groupsName
-    };
-}
-function getParameters(jsonOperation, options) {
-    return jsonOperation.get("parameters").filter((parameter) => isParameterType(parameter.get("in")));
-}
-export function payloadMapper(jsonOperationStore, operationPath, options) {
-    const parameters = getParameters(jsonOperationStore.operation, options);
-    const payloadName = pascalCase([operationPath.path, operationPath.method, "Payload"].join(" "));
-    setValue(options, `components.schemas.${payloadName}`, {});
-    const allOf = parameters
-        .map((parameter) => {
-        const opts = mapOptions(parameter, options);
-        const jsonSchema = execMapper("item", [parameter.$schema], {
-            ...opts,
-            ...popGenerics(parameter)
-        });
-        switch (parameter.get("in")) {
-            case JsonParameterTypes.BODY:
-                return jsonSchema;
-            case JsonParameterTypes.QUERY:
-            case JsonParameterTypes.PATH:
-            case JsonParameterTypes.HEADER:
-                return {
-                    type: "object",
-                    properties: {
-                        [parameter.get("name")]: jsonSchema
-                    }
-                };
-        }
-        return jsonSchema;
-    }, {})
-        .filter(Boolean);
-    return makeOf("allOf", allOf);
-}
-registerJsonSchemaMapper("payload", payloadMapper, SpecTypes.ASYNCAPI);