@tsed/schema 8.11.1 → 8.11.2-rc.1

package/src/components/default/inheritedClassMapper.ts

@@ -1,41 +0,0 @@
-import {classOf, deepMerge} from "@tsed/core";
-
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {getInheritedStores} from "../../utils/getInheritedStores.js";
-
-function alterMerge(_: string, obj: any) {
-  if (obj?.type && obj?.$ref) {
-    const {$ref, ...schema} = obj;
-
-    obj = {
-      allOf: [
-        {
-          $ref
-        },
-        schema
-      ]
-    };
-  }
-
-  return obj;
-}
-
-/**
- * @ignore
- */
-export function inheritedClassMapper(obj: any, {target, ...options}: JsonSchemaOptions) {
-  const stores = Array.from(getInheritedStores(target).entries()).filter(([model]) => classOf(model) !== classOf(target));
-
-  if (stores.length) {
-    const schema = stores.reduce((obj, [, store]) => {
-      return deepMerge(obj, execMapper("schema", [store.schema], options), {alter: alterMerge});
-    }, {});
-
-    return deepMerge(schema, obj, {alter: alterMerge});
-  }
-
-  return obj;
-}
-
-registerJsonSchemaMapper("inheritedClass", inheritedClassMapper);

package/src/components/default/itemMapper.ts

@@ -1,8 +0,0 @@
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-export function itemMapper(value: any, options: JsonSchemaOptions) {
-  return value && value.isClass ? execMapper("class", [value], options) : execMapper("any", [value], options);
-}
-
-registerJsonSchemaMapper("item", itemMapper);

package/src/components/default/lazyRefMapper.ts

@@ -1,21 +0,0 @@
-import {JsonLazyRef} from "../../domain/JsonLazyRef.js";
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {mapGenericsOptions} from "../../utils/generics.js";
-import {createRef, toRef} from "../../utils/ref.js";
-
-export function lazyRefMapper(jsonLazyRef: JsonLazyRef, options: JsonSchemaOptions) {
-  const name = jsonLazyRef.name;
-
-  if (options.$refs?.find((t: any) => t === jsonLazyRef.target)) {
-    return createRef(name, jsonLazyRef.schema, options);
-  }
-
-  options.$refs = [...(options.$refs || []), jsonLazyRef.target];
-
-  const schema = jsonLazyRef.getType() && execMapper("schema", [jsonLazyRef.schema], mapGenericsOptions(options));
-
-  return toRef(jsonLazyRef.schema, schema, options);
-}
-
-registerJsonSchemaMapper("lazyRef", lazyRefMapper);

package/src/components/default/mapMapper.ts

@@ -1,25 +0,0 @@
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {mapGenericsOptions} from "../../utils/generics.js";
-
-/**
- * Serialize class which inherit from Map like JsonMap, JsonOperation, JsonParameter.
- * @param input
- * @param ignore
- * @param options
- * @ignore
- */
-export function mapMapper(input: Map<string, any>, {ignore = [], ...options}: JsonSchemaOptions = {}): any {
-  options = mapGenericsOptions(options);
-
-  return Array.from(input.entries()).reduce((obj: any, [key, value]) => {
-    if (ignore.includes(key)) {
-      return obj;
-    }
-
-    obj[key] = execMapper("item", [value], options);
-    return obj;
-  }, {});
-}
-
-registerJsonSchemaMapper("map", mapMapper);

package/src/components/default/nullableMapper.ts

@@ -1,55 +0,0 @@
-import {cleanObject} from "@tsed/core";
-
-import {MANY_OF_PROPERTIES} from "../../constants/jsonSchemaProperties.js";
-import type {JsonSchema} from "../../domain/JsonSchema.js";
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-export function nullableMapper(obj: any, schema: JsonSchema | null) {
-  if (!schema?.isNullable) {
-    return obj;
-  }
-
-  if (!obj.discriminator) {
-    if (obj.$ref) {
-      obj = cleanObject({
-        ...obj,
-        $ref: undefined,
-        anyOf: [
-          {type: "null"},
-          {
-            $ref: obj.$ref
-          }
-        ]
-      });
-    } else {
-      MANY_OF_PROPERTIES.some((keyword: string) => {
-        if (obj[keyword]) {
-          obj[keyword] = obj[keyword].filter((item: any) => item.type !== "null");
-
-          if (obj[keyword].length === 1) {
-            const base = obj[keyword];
-
-            obj = cleanObject({
-              ...obj,
-              ...base[0],
-              [keyword]: undefined,
-              type: ["null", Number.isInteger(obj.multipleOf) ? "integer" : base[0].type]
-            });
-          } else {
-            obj[keyword] = [{type: "null"}].concat(obj[keyword]).map((item: any) => {
-              if (Number.isInteger(item.multipleOf)) {
-                item.type = "integer";
-              }
-              return item;
-            });
-            delete obj.type;
-          }
-        }
-      });
-    }
-  }
-
-  return obj;
-}
-
-registerJsonSchemaMapper("nullable", nullableMapper);

package/src/components/default/objectMapper.ts

@@ -1,36 +0,0 @@
-import {isArray} from "@tsed/core";
-
-import {JsonSchema} from "../../domain/JsonSchema.js";
-import {alterIgnore} from "../../hooks/alterIgnore.js";
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-/**
- * Serialize Any object to a json schema
- * @param input
- * @param options
- * @ignore
- */
-export function objectMapper(input: any, options: JsonSchemaOptions) {
-  const {specType, operationIdFormatter, root, components, genericTypes, nestedGenerics, useAlias, genericLabels, ...ctx} = options;
-
-  return Object.entries(input).reduce<any>(
-    (obj, [key, value]: [string, any | JsonSchema]) => {
-      if (options.withIgnoredProps !== false && !alterIgnore(value, ctx)) {
-        const opts = {
-          ...options,
-          groups: input?.$forwardGroups || value?.$forwardGroups ? options.groups : undefined
-        };
-
-        // remove groups to avoid bad schema generation over children models
-        obj[key] = execMapper("item", [value], opts);
-        obj[key] = execMapper("nullable", [obj[key], value], opts);
-      }
-
-      return obj;
-    },
-    isArray(input) ? [] : {}
-  );
-}
-
-registerJsonSchemaMapper("object", objectMapper);

package/src/components/default/ofMapper.ts

@@ -1,16 +0,0 @@
-import type {JsonSchema} from "../../domain/JsonSchema.js";
-import type {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-export function ofMapper(input: (any | JsonSchema)[], options: JsonSchemaOptions, parent: JsonSchema) {
-  return input.map((value: any | JsonSchema) => {
-    return execMapper("item", [value], {
-      ...options,
-      genericLabels: parent.genericLabels
-    });
-  });
-}
-
-registerJsonSchemaMapper("anyOf", ofMapper);
-registerJsonSchemaMapper("allOf", ofMapper);
-registerJsonSchemaMapper("oneOf", ofMapper);

package/src/components/default/propertiesMapper.ts

@@ -1,25 +0,0 @@
-import type {JsonSchema} from "../../domain/JsonSchema.js";
-import type {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-export function propertiesMapper(input: any | JsonSchema, options: JsonSchemaOptions, parent: JsonSchema) {
-  if (input.isClass) {
-    return execMapper("class", [input], options);
-  }
-
-  return execMapper("any", [input], {
-    ...options,
-    genericLabels: parent.genericLabels
-  });
-}
-
-registerJsonSchemaMapper("properties", propertiesMapper);
-registerJsonSchemaMapper("items", propertiesMapper);
-registerJsonSchemaMapper("additionalProperties", propertiesMapper);
-registerJsonSchemaMapper("propertyNames", propertiesMapper);
-registerJsonSchemaMapper("contains", propertiesMapper);
-registerJsonSchemaMapper("dependencies", propertiesMapper);
-registerJsonSchemaMapper("patternProperties", propertiesMapper);
-registerJsonSchemaMapper("additionalItems", propertiesMapper);
-registerJsonSchemaMapper("not", propertiesMapper);
-registerJsonSchemaMapper("definitions", propertiesMapper);

package/src/components/default/requiredMapper.ts

@@ -1,69 +0,0 @@
-import {uniq} from "@tsed/core";
-
-import type {JsonSchema} from "../../domain/JsonSchema.js";
-import {alterRequiredGroups} from "../../hooks/alterRequiredGroups.js";
-import type {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {createRef, createRefName, toRef} from "../../utils/ref.js";
-
-function mapRequiredProps(obj: any, schema: JsonSchema, options: JsonSchemaOptions = {}) {
-  const {useAlias} = options;
-  const props = Object.keys(obj.properties || {});
-
-  return (keys: string[], key: string) => {
-    const aliasedKey = useAlias ? (schema.alias.get(key) as string) || key : key;
-
-    if (props.includes(aliasedKey)) {
-      return keys.concat(aliasedKey);
-    }
-
-    return keys;
-  };
-}
-
-function extractRequiredProps(obj: any, schema: JsonSchema, options: JsonSchemaOptions): string[] {
-  let required: string[] = obj.required || [];
-
-  required = [...required, ...schema.$required];
-
-  if (schema.get("properties")) {
-    required = Object.entries(schema.get("properties")).reduce((required, [key, prop]: [string, any]) => {
-      if (prop && prop.$selfRequired !== undefined) {
-        return prop.$selfRequired ? required.concat(key) : required.filter((k) => k === key);
-      }
-
-      return required;
-    }, required);
-  }
-
-  return alterRequiredGroups(uniq(required), schema, options);
-}
-
-export function requiredMapper(obj: any, schema: JsonSchema, options: JsonSchemaOptions) {
-  if (options.groups && options.groups.includes("partial")) {
-    if (obj.discriminator) {
-      return {
-        ...obj,
-        required: [obj.discriminator.propertyName]
-      };
-    }
-
-    return obj;
-  }
-
-  let required = extractRequiredProps(obj, schema, options);
-
-  required = uniq(required).reduce(mapRequiredProps(obj, schema, options), []);
-
-  if (obj.discriminator) {
-    required.push(obj.discriminator.propertyName);
-  }
-
-  if (required.length) {
-    obj.required = required;
-  }
-
-  return obj;
-}
-
-registerJsonSchemaMapper("required", requiredMapper);

package/src/components/default/schemaMapper.ts

@@ -1,155 +0,0 @@
-import {getValue, isFunction, isObject} from "@tsed/core";
-
-import {mapAliasedProperties} from "../../domain/JsonAliasMap.js";
-import {JsonSchema} from "../../domain/JsonSchema.js";
-import {SpecTypes} from "../../domain/SpecTypes.js";
-import {alterOneOf} from "../../hooks/alterOneOf.js";
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {execMapper, hasMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-/**
- * @ignore
- */
-const IGNORES = ["name", "$required", "$hooks", "_nestedGenerics", SpecTypes.OPENAPI, SpecTypes.SWAGGER, SpecTypes.JSON];
-/**
- * @ignore
- */
-const IGNORES_OPENSPEC: string[] = [];
-
-/**
- * @ignore
- */
-function isEmptyProperties(key: string, value: any) {
-  return typeof value === "object" && ["items", "properties", "additionalProperties"].includes(key) && Object.keys(value).length === 0;
-}
-
-/**
- * @ignore
- */
-function shouldMapAlias(key: string, value: any, useAlias: boolean) {
-  return typeof value === "object" && useAlias && ["properties", "additionalProperties"].includes(key);
-}
-
-/**
- * @ignore
- */
-function shouldSkipKey(key: string, {specType = SpecTypes.JSON, customKeys = false}: JsonSchemaOptions) {
-  return (
-    IGNORES.includes(key) ||
-    (key.startsWith("#") && (customKeys === false || specType !== SpecTypes.JSON)) ||
-    (specType !== SpecTypes.JSON && IGNORES_OPENSPEC.includes(key))
-  );
-}
-
-function isExample(key: string, value: any, options: JsonSchemaOptions) {
-  return key === "examples" && isObject(value) && [SpecTypes.OPENAPI, SpecTypes.ASYNCAPI].includes(options.specType!)!;
-}
-
-function mapOptions(options: JsonSchemaOptions) {
-  let addDef = false;
-
-  if (!options) {
-    addDef = true;
-    options = {components: {schemas: {}}, inlineEnums: true};
-  }
-
-  const {useAlias = true, components = {schemas: {}}} = options;
-  options = {
-    ...options,
-    useAlias,
-    components
-  };
-
-  return {
-    addDef,
-    options
-  };
-}
-
-function mapKeys(schema: JsonSchema, options: JsonSchemaOptions) {
-  const {useAlias} = options;
-
-  return [...schema.keys()]
-    .filter((key) => !shouldSkipKey(key, options))
-    .reduce((item: any, key) => {
-      let value = schema.get(key);
-
-      key = key.replace(/^#/, "");
-
-      if (key === "type") {
-        item[key] = schema.getJsonType();
-        return item;
-      }
-
-      if (isExample(key, value, options)) {
-        key = "example";
-        value = Object.values(value)[0];
-      }
-
-      if (value && typeof value === "object" && hasMapper(key)) {
-        value = execMapper(key, [value], options, schema);
-
-        if (isEmptyProperties(key, value)) {
-          return item;
-        }
-
-        if (shouldMapAlias(key, value, useAlias!)) {
-          value = mapAliasedProperties(value, schema.alias);
-        }
-      }
-
-      item[key] = value;
-
-      return item;
-    }, {});
-}
-
-function serializeSchema(schema: JsonSchema, options: JsonSchemaOptions) {
-  let obj: any = mapKeys(schema, options);
-
-  if (schema.isClass) {
-    obj = execMapper("inheritedClass", [obj], {
-      ...options,
-      root: false,
-      target: schema.getComputedType()
-    });
-  }
-
-  obj = execMapper("generics", [obj], {
-    ...options,
-    root: false
-  } as any);
-
-  if (schema.has(options.specType as string)) {
-    obj = {
-      ...obj,
-      ...schema.get(options.specType as string).toJSON(options)
-    };
-  }
-
-  if (isFunction(obj.default)) {
-    obj.default = obj.default();
-  }
-
-  obj = execMapper("required", [obj, schema], options);
-  obj = execMapper("nullable", [obj, schema], options);
-  obj = alterOneOf(obj, schema, options);
-  obj = execMapper("enums", [obj, schema], options);
-  obj = execMapper("discriminatorMapping", [obj, schema], options);
-
-  return obj;
-}
-
-export function schemaMapper(schema: JsonSchema, opts: JsonSchemaOptions): any {
-  const {options, addDef} = mapOptions(opts);
-
-  const obj = serializeSchema(schema, options);
-
-  if (addDef && Object.keys(getValue(options, "components.schemas", {})).length) {
-    obj.definitions = options.components!.schemas;
-  }
-
-  return obj;
-}
-
-registerJsonSchemaMapper("schema", schemaMapper);

package/src/components/index.ts

@@ -1,36 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./async-api/channelsMapper.js";
-export * from "./async-api/generate.js";
-export * from "./async-api/messageMapper.js";
-export * from "./async-api/payloadMapper.js";
-export * from "./async-api/responseMapper.js";
-export * from "./default/anyMapper.js";
-export * from "./default/classMapper.js";
-export * from "./default/discriminatorMappingMapper.js";
-export * from "./default/enumsMapper.js";
-export * from "./default/genericsMapper.js";
-export * from "./default/inheritedClassMapper.js";
-export * from "./default/itemMapper.js";
-export * from "./default/lazyRefMapper.js";
-export * from "./default/mapMapper.js";
-export * from "./default/nullableMapper.js";
-export * from "./default/objectMapper.js";
-export * from "./default/ofMapper.js";
-export * from "./default/propertiesMapper.js";
-export * from "./default/requiredMapper.js";
-export * from "./default/schemaMapper.js";
-export * from "./open-spec/discriminatorMappingMapper.js";
-export * from "./open-spec/enumsMapper.js";
-export * from "./open-spec/generate.js";
-export * from "./open-spec/nullableMapper.js";
-export * from "./open-spec/operationInFilesMapper.js";
-export * from "./open-spec/operationInParameterMapper.js";
-export * from "./open-spec/operationInParametersMapper.js";
-export * from "./open-spec/operationInQueryMapper.js";
-export * from "./open-spec/operationMapper.js";
-export * from "./open-spec/operationMediaMapper.js";
-export * from "./open-spec/operationRequestBodyMapper.js";
-export * from "./open-spec/operationResponseMapper.js";
-export * from "./open-spec/pathsMapper.js";

package/src/components/open-spec/discriminatorMappingMapper.ts

@@ -1,7 +0,0 @@
-import {SpecTypes} from "../../domain/SpecTypes.js";
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {discriminatorMappingMapper} from "../default/discriminatorMappingMapper.js";
-
-registerJsonSchemaMapper("discriminatorMapping", discriminatorMappingMapper, SpecTypes.OPENAPI);
-registerJsonSchemaMapper("discriminatorMapping", discriminatorMappingMapper, SpecTypes.SWAGGER);
-registerJsonSchemaMapper("discriminatorMapping", discriminatorMappingMapper, SpecTypes.ASYNCAPI);

package/src/components/open-spec/enumsMapper.ts

@@ -1,20 +0,0 @@
-import {JsonSchema} from "../../domain/JsonSchema.js";
-import {SpecTypes} from "../../domain/SpecTypes.js";
-import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {enumsMapper} from "../default/enumsMapper.js";
-
-export function wrapEnumsMapper(obj: any, schema: JsonSchema, options: JsonSchemaOptions) {
-  obj = enumsMapper(obj, schema, options);
-
-  if (obj.const) {
-    obj.enum = [obj.const];
-    delete obj.const;
-  }
-
-  return obj;
-}
-
-registerJsonSchemaMapper("enums", wrapEnumsMapper, SpecTypes.OPENAPI);
-registerJsonSchemaMapper("enums", wrapEnumsMapper, SpecTypes.SWAGGER);
-registerJsonSchemaMapper("enums", wrapEnumsMapper, SpecTypes.ASYNCAPI);

package/src/components/open-spec/generate.ts

@@ -1,29 +0,0 @@
-import {getValue, Type, uniqBy} from "@tsed/core";
-
-import {SpecTypes} from "../../domain/SpecTypes.js";
-import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import {SpecSerializerOptions} from "../../utils/getSpec.js";
-
-function generate(model: Type<any>, options: SpecSerializerOptions) {
-  options = {
-    ...options,
-    specType: SpecTypes.OPENAPI
-  };
-
-  const specJson: any = {
-    paths: execMapper("paths", [model], options)
-  };
-
-  specJson.tags = uniqBy(options.tags, "name");
-
-  if (Object.keys(getValue(options, "components.schemas", {})).length) {
-    specJson.components = {
-      schemas: options.components!.schemas
-    };
-  }
-
-  return specJson;
-}
-
-registerJsonSchemaMapper("generate", generate, SpecTypes.OPENAPI);
-registerJsonSchemaMapper("generate", generate, SpecTypes.SWAGGER);

package/src/components/open-spec/nullableMapper.ts

@@ -1,51 +0,0 @@
-import {cleanObject} from "@tsed/core";
-
-import type {JsonSchema} from "../../domain/JsonSchema.js";
-import {SpecTypes} from "../../domain/SpecTypes.js";
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-
-export function nullableMapperOpenApi(obj: any, schema: JsonSchema | null) {
-  if (!schema?.isNullable) {
-    return obj;
-  }
-
-  if (obj.$ref) {
-    return cleanObject({
-      ...obj,
-      ...(obj.$ref && {
-        anyOf: [
-          {
-            $ref: obj.$ref
-          }
-        ],
-        type: undefined
-      }),
-      nullable: true,
-      $ref: undefined
-    });
-  }
-
-  return cleanObject({
-    ...obj,
-    ...(obj.anyOf?.length === 1
-      ? {
-          ...obj.anyOf[0],
-          anyOf: undefined,
-          type: Number.isInteger(obj.multipleOf) ? "integer" : obj.anyOf[0]?.type
-        }
-      : {
-          type: obj.anyOf?.length > 1 ? undefined : obj.type,
-          anyOf: obj.anyOf?.map((item: any) => {
-            if (Number.isInteger(item.multipleOf)) {
-              item.type = "integer";
-            }
-
-            return item;
-          })
-        }),
-    nullable: true
-  });
-}
-
-registerJsonSchemaMapper("nullable", nullableMapperOpenApi, SpecTypes.OPENAPI);
-registerJsonSchemaMapper("nullable", nullableMapperOpenApi, SpecTypes.SWAGGER);

package/src/components/open-spec/operationInFilesMapper.ts

@@ -1,32 +0,0 @@
-import {cleanObject} from "@tsed/core";
-
-import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
-import type {JsonParameterOptions} from "./operationInParameterMapper.js";
-
-export function operationInFilesMapper(parameter: any, {jsonSchema}: JsonParameterOptions) {
-  const schema = {
-    type: "string",
-    format: "binary",
-    oneOf: undefined
-  };
-
-  if (jsonSchema.type === "array") {
-    jsonSchema.items = cleanObject({
-      ...(jsonSchema.items as Object),
-      ...schema
-    });
-
-    parameter.schema = jsonSchema;
-
-    return parameter;
-  }
-
-  parameter.schema = cleanObject({
-    ...jsonSchema,
-    ...schema
-  });
-
-  return parameter;
-}
-
-registerJsonSchemaMapper("operationInFiles", operationInFilesMapper);