@tsed/schema 8.0.1 → 8.0.2

package/src/components/default/lazyRefMapper.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,151 @@
+import {getValue, 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)
+    };
+  }
+
+  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

@@ -0,0 +1,36 @@
+/**
+ * @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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,32 @@
+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);

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

@@ -0,0 +1,56 @@
+import {OS3Schema} from "@tsed/openspec";
+import {camelCase} from "change-case";
+import type {JSONSchema6} from "json-schema";
+
+import {JsonParameter} from "../../domain/JsonParameter.js";
+import {JsonParameterTypes} from "../../domain/JsonParameterTypes.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, hasMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {popGenerics} from "../../utils/generics.js";
+
+export type JsonParameterOptions = JsonSchemaOptions & {
+  jsonParameter: JsonParameter;
+  jsonSchema: JSONSchema6;
+  oldSchemas: Record<string, OS3Schema>;
+};
+
+function mapOptions(parameter: JsonParameter, options: JsonSchemaOptions = {}) {
+  return {
+    ...options,
+    groups: parameter.groups,
+    groupsName: parameter.groupsName
+  };
+}
+
+export function operationInParameterMapper(jsonParameter: JsonParameter, opts?: JsonSchemaOptions) {
+  const options = mapOptions(jsonParameter, opts);
+  const schemas = {...(options.components?.schemas || {})};
+
+  const {type, schema, ...parameter} = execMapper("map", [jsonParameter], options);
+
+  const jsonSchema = execMapper("item", [jsonParameter.$schema], {
+    ...options,
+    ...popGenerics(jsonParameter)
+  });
+
+  parameter.required = parameter.required || jsonParameter.get("in") === JsonParameterTypes.PATH;
+
+  const paramOpts = {
+    ...options,
+    jsonSchema,
+    jsonParameter,
+    oldSchemas: schemas
+  };
+
+  const mapperName = camelCase(`operationIn ${jsonParameter.get("in")}`);
+
+  if (hasMapper(mapperName)) {
+    return execMapper(mapperName, [parameter], paramOpts);
+  }
+
+  parameter.schema = jsonSchema;
+
+  return parameter;
+}
+
+registerJsonSchemaMapper("operationInParameter", operationInParameterMapper);

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

@@ -0,0 +1,9 @@
+import {JsonParameter} from "../../domain/JsonParameter.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+
+export function operationInParametersMapper(parameters: JsonParameter[], options: JsonSchemaOptions) {
+  return parameters.flatMap((parameter) => execMapper("operationInParameter", [parameter], options)).filter(Boolean);
+}
+
+registerJsonSchemaMapper("operationInParameters", operationInParametersMapper);