@tsed/schema 8.0.1 → 8.0.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/schema",
   "description": "JsonSchema module for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -10,6 +10,7 @@
   "browser": "./lib/browser/schema.umd.min.js",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "browser": "./lib/browser/schema.umd.min.js",
       "import": "./lib/esm/index.js",
@@ -36,7 +37,7 @@
     "tsed"
   ],
   "dependencies": {
-    "@tsed/openspec": "8.0.1",
+    "@tsed/openspec": "8.0.2",
     "change-case": "^5.4.4",
     "fs-extra": "^11.2.0",
     "json-schema": "0.4.0",
@@ -46,11 +47,11 @@
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "10.1.0",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/hooks": "8.0.1",
-    "@tsed/openspec": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/hooks": "8.0.2",
+    "@tsed/openspec": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.1",
@@ -63,9 +64,9 @@
     "webpack": "^5.75.0"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/hooks": "8.0.1",
-    "@tsed/openspec": "8.0.1"
+    "@tsed/core": "8.0.2",
+    "@tsed/hooks": "8.0.2",
+    "@tsed/openspec": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/src/components/async-api/channelsMapper.ts

@@ -0,0 +1,81 @@
+import {camelCase} from "change-case";
+
+import {OperationVerbs} from "../../constants/OperationVerbs.js";
+import {JsonMethodStore} from "../../domain/JsonMethodStore.js";
+import {JsonMethodPath} from "../../domain/JsonOperation.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.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: JsonSchemaOptions) {
+  return (
+    channels: any,
+    {
+      operationPath,
+      operationStore
+    }: {
+      operationPath: JsonMethodPath;
+      operationStore: JsonMethodStore;
+    }
+  ) => {
+    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 as any)[path],
+        [method]: {
+          ...(channels as any)[path]?.[method],
+          operationId,
+          message: {
+            oneOf: [...((channels as any)[path]?.[method]?.message?.oneOf || []), message]
+          }
+        }
+      }
+    };
+  };
+}
+
+function expandOperationPaths(options: JsonSchemaOptions) {
+  return (operationStore: JsonMethodStore) => {
+    const operationPaths = operationStore.operation.getAllowedOperationPath(ALLOWED_VERBS);
+
+    if (operationPaths.length === 0) {
+      return [];
+    }
+
+    return operationPaths.map((operationPath) => {
+      return {
+        operationPath,
+        operationStore
+      };
+    });
+  };
+}
+
+export function channelsMapper(model: any, {channels, rootPath, ...options}: JsonSchemaOptions) {
+  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/src/components/async-api/generate.ts

@@ -0,0 +1,24 @@
+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) {
+  const specJson: any = {
+    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/src/components/async-api/messageMapper.ts

@@ -0,0 +1,62 @@
+import {cleanObject, getValue} from "@tsed/core";
+
+import {OperationVerbs} from "../../constants/OperationVerbs.js";
+import {JsonMethodStore} from "../../domain/JsonMethodStore.js";
+import {JsonMethodPath} from "../../domain/JsonOperation.js";
+import {SpecTypes} from "../../domain/SpecTypes.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {makeOf} from "../../utils/somethingOf.js";
+
+export function messageMapper(
+  jsonOperationStore: JsonMethodStore,
+  operationPath: JsonMethodPath,
+  {tags = [], defaultTags = [], ...options}: JsonSchemaOptions = {}
+) {
+  const {path: event, method} = operationPath;
+
+  const messageKey = String(event);
+
+  let message: any = 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/src/components/async-api/payloadMapper.ts

@@ -0,0 +1,61 @@
+import {setValue} from "@tsed/core";
+import {pascalCase} from "change-case";
+
+import {JsonMethodStore} from "../../domain/JsonMethodStore.js";
+import {JsonMethodPath, JsonOperation} from "../../domain/JsonOperation.js";
+import {JsonParameter} from "../../domain/JsonParameter.js";
+import {isParameterType, JsonParameterTypes} from "../../domain/JsonParameterTypes.js";
+import {SpecTypes} from "../../domain/SpecTypes.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {popGenerics} from "../../utils/generics.js";
+import {makeOf} from "../../utils/somethingOf.js";
+
+function mapOptions(parameter: JsonParameter, options: JsonSchemaOptions = {}) {
+  return {
+    ...options,
+    groups: parameter.groups,
+    groupsName: parameter.groupsName
+  };
+}
+
+function getParameters(jsonOperation: JsonOperation, options: JsonSchemaOptions): JsonParameter[] {
+  return jsonOperation.get("parameters").filter((parameter: JsonParameter) => isParameterType(parameter.get("in")));
+}
+
+export function payloadMapper(jsonOperationStore: JsonMethodStore, operationPath: JsonMethodPath, options: JsonSchemaOptions) {
+  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);

package/src/components/async-api/responseMapper.ts

@@ -0,0 +1,70 @@
+import {setValue} from "@tsed/core";
+import {pascalCase} from "change-case";
+
+import {JsonMethodStore} from "../../domain/JsonMethodStore.js";
+import {JsonMethodPath} from "../../domain/JsonOperation.js";
+import {SpecTypes} from "../../domain/SpecTypes.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {makeOf} from "../../utils/somethingOf.js";
+
+export function responsePayloadMapper(jsonOperationStore: JsonMethodStore, operationPath: JsonMethodPath, options: JsonSchemaOptions) {
+  const responses = jsonOperationStore.operation.getResponses();
+  const statuses: number[] = [];
+  const statusesTexts: string[] = [];
+  const successSchemes: unknown[] = [];
+  const errorSchemes: unknown[] = [];
+
+  [...responses.entries()].forEach(([status, jsonResponse]) => {
+    const response = execMapper("map", [jsonResponse], options);
+
+    statuses.push(+status);
+
+    statusesTexts.push(response.description);
+
+    if (+status !== 204) {
+      const {content} = response;
+      const schema = content[Object.keys(content)[0]];
+
+      if (+status >= 200 && +status < 400) {
+        successSchemes.push(schema);
+      } else {
+        successSchemes.push(schema);
+      }
+    }
+  });
+
+  const responsePayloadName = pascalCase([operationPath.path, operationPath.method, "Response"].join(" "));
+  const responsePayload = {
+    type: "object",
+    properties: {
+      status: {
+        type: "number",
+        enum: statuses
+      },
+      statusText: {
+        type: "string",
+        enum: statusesTexts
+      }
+    },
+    required: ["status"]
+  };
+
+  const dataSchema = makeOf("oneOf", successSchemes);
+
+  if (dataSchema) {
+    setValue(responsePayload, "properties.data", dataSchema);
+  }
+
+  const errorSchema = makeOf("oneOf", errorSchemes);
+
+  if (errorSchemes.length) {
+    setValue(responsePayload, "properties.error", errorSchema);
+  }
+
+  setValue(options, `components.schemas.${responsePayloadName}`, responsePayload);
+
+  return {$ref: `#/components/schemas/${responsePayloadName}`};
+}
+
+registerJsonSchemaMapper("response", responsePayloadMapper, SpecTypes.ASYNCAPI);

package/src/components/default/anyMapper.spec.ts

@@ -0,0 +1,7 @@
+import {anyMapper} from "./anyMapper.js";
+
+describe("anyMapper()", () => {
+  it("should not generate schema is the value is null", () => {
+    expect(anyMapper(null)).toEqual(null);
+  });
+});

package/src/components/default/anyMapper.ts

@@ -0,0 +1,33 @@
+import {JsonLazyRef} from "../../domain/JsonLazyRef.js";
+import {JsonSchema} from "../../domain/JsonSchema.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, oneOfMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {mapGenericsOptions} from "../../utils/generics.js";
+import {toRef} from "../../utils/ref.js";
+
+export function anyMapper(input: any, options: JsonSchemaOptions = {}): any {
+  if (typeof input !== "object" || input === null) {
+    return input;
+  }
+
+  if (input instanceof JsonLazyRef) {
+    return execMapper("lazyRef", [input], options);
+  }
+
+  if (input instanceof JsonSchema && input.get("enum") instanceof JsonSchema) {
+    const enumSchema: JsonSchema = input.get("enum");
+
+    return toRef(enumSchema, enumSchema.toJSON(options), options);
+  }
+
+  if (input.$kind && input.$isJsonDocument) {
+    const kind = oneOfMapper([input.$kind, "map"], options);
+    const schema = execMapper(kind, [input], mapGenericsOptions(options));
+
+    return input.canRef ? toRef(input, schema, options) : schema;
+  }
+
+  return execMapper("object", [input], options);
+}
+
+registerJsonSchemaMapper("any", anyMapper);

package/src/components/default/classMapper.ts

@@ -0,0 +1,55 @@
+import {getValue, setValue} from "@tsed/core";
+
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {JsonSchema} from "../../domain/JsonSchema.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {mapGenericsOptions, popGenerics} from "../../utils/generics.js";
+import {createRef, createRefName} from "../../utils/ref.js";
+
+export function classMapper(value: JsonSchema, options: JsonSchemaOptions) {
+  const store = JsonEntityStore.from(value.class);
+  const name = createRefName(store.schema.getName() || value.getName(), options);
+
+  if (value.hasGenerics) {
+    // Inline generic
+    const {type, properties, additionalProperties, items, ...props} = value.toJSON(options);
+    const schema = {
+      ...execMapper("any", [store.schema], {
+        ...options,
+        ...popGenerics(value),
+        root: false
+      }),
+      ...props
+    };
+
+    if (schema.title) {
+      const name = createRefName(schema.title, options);
+      setValue(options.components, `schemas.${name}`, schema);
+
+      delete schema.title;
+
+      return createRef(name, value, options);
+    }
+
+    return schema;
+  }
+
+  if (!getValue(options, `components.schemas.${name}`)) {
+    // avoid infinite calls
+    setValue(options, `components.schemas.${name}`, {});
+
+    options.components!.schemas[name] = execMapper(
+      "any",
+      [store.schema],
+      mapGenericsOptions({
+        ...options,
+        root: false
+      })
+    );
+  }
+
+  return createRef(name, value, options);
+}
+
+registerJsonSchemaMapper("class", classMapper);

package/src/components/default/discriminatorMappingMapper.ts

@@ -0,0 +1,36 @@
+import {isString} from "@tsed/core";
+
+import {JsonSchema} from "../../domain/JsonSchema.js";
+import {SpecTypes} from "../../domain/SpecTypes.js";
+import type {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {toRef} from "../../utils/ref.js";
+
+interface SchemaWithDiscriminator {
+  discriminator?: {mapping?: Record<string, JsonSchema | string>};
+}
+
+export function discriminatorMappingMapper(obj: SchemaWithDiscriminator, _: JsonSchema, options: JsonSchemaOptions) {
+  if (obj.discriminator?.mapping) {
+    const entries = Object.entries(obj.discriminator.mapping);
+    const newMapping: Record<string, string> = {};
+
+    for (const [key, value] of entries) {
+      newMapping[key] = isString(value) ? value : toRef(value, null, options).$ref;
+    }
+
+    obj.discriminator.mapping = newMapping;
+  }
+
+  return obj;
+}
+
+function defaultDiscriminatorMappingMapper(obj: SchemaWithDiscriminator) {
+  if (obj.discriminator?.mapping) {
+    delete obj.discriminator.mapping;
+  }
+
+  return obj;
+}
+
+registerJsonSchemaMapper("discriminatorMapping", defaultDiscriminatorMappingMapper);

package/src/components/default/enumsMapper.spec.ts

@@ -0,0 +1,64 @@
+import {enumsMapper} from "./enumsMapper.js";
+
+describe("enumsMapper()", () => {
+  it("should inline enums", () => {
+    const result = enumsMapper(
+      {
+        enum: {
+          $isJsonDocument: true,
+          toJSON() {
+            return {enum: ["type"]};
+          }
+        }
+      },
+      {} as any,
+      {inlineEnums: true}
+    );
+
+    expect(result).toEqual({
+      enum: ["type"],
+      type: "string"
+    });
+  });
+
+  it("should inline enums and set type (object to string)", () => {
+    const result = enumsMapper(
+      {
+        type: "object",
+        enum: {
+          $isJsonDocument: true,
+          toJSON() {
+            return {enum: ["type"]};
+          }
+        }
+      },
+      {} as any,
+      {inlineEnums: true}
+    );
+
+    expect(result).toEqual({
+      type: "string",
+      enum: ["type"]
+    });
+  });
+  it("should inline enums and keep the type", () => {
+    const result = enumsMapper(
+      {
+        type: "string",
+        enum: {
+          $isJsonDocument: true,
+          toJSON() {
+            return {enum: ["type"]};
+          }
+        }
+      },
+      {} as any,
+      {inlineEnums: true}
+    );
+
+    expect(result).toEqual({
+      type: "string",
+      enum: ["type"]
+    });
+  });
+});

package/src/components/default/enumsMapper.ts

@@ -0,0 +1,17 @@
+import {JsonSchema} from "../../domain/JsonSchema.js";
+import {JsonSchemaOptions} from "../../interfaces/JsonSchemaOptions.js";
+import {registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+
+export function enumsMapper(obj: any, schema: JsonSchema, options: JsonSchemaOptions) {
+  if (options.inlineEnums && obj.enum?.$isJsonDocument) {
+    obj.enum = obj.enum.toJSON().enum;
+  }
+
+  if (obj.enum) {
+    obj.type = obj.type === "object" || obj.type === undefined ? "string" : obj.type;
+  }
+
+  return obj;
+}
+
+registerJsonSchemaMapper("enums", enumsMapper);

package/src/components/default/genericsMapper.ts

@@ -0,0 +1,70 @@
+import {isClass, isPrimitiveClass} from "@tsed/core";
+
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {execMapper, registerJsonSchemaMapper} from "../../registries/JsonSchemaMapperContainer.js";
+import {GenericsContext, popGenerics} from "../../utils/generics.js";
+import {getJsonType} from "../../utils/getJsonType.js";
+
+/**
+ * @ignore
+ */
+export function genericsMapper(obj: any, options: GenericsContext) {
+  const {generics} = options;
+
+  if (generics && obj.$ref) {
+    if (generics.has(obj.$ref)) {
+      let type = generics.get(obj.$ref);
+
+      if (isPrimitiveClass(type)) {
+        return {
+          type: getJsonType(type)
+        };
+      }
+
+      if (type === Date) {
+        return {
+          type: "string",
+          format: "date-time"
+        };
+      }
+
+      if (type.toJSON) {
+        return type.toJSON({
+          ...options,
+          generics: undefined
+        });
+      }
+
+      if (type === Object) {
+        return {
+          type: "object"
+        };
+      }
+
+      if (isClass(type)) {
+        const model = {
+          class: type
+        };
+
+        if (options.nestedGenerics.length === 0) {
+          return execMapper("class", [model as any], {
+            ...options,
+            generics: undefined
+          });
+        }
+
+        const store = JsonEntityStore.from(model.class);
+
+        return execMapper("schema", [store.schema], {
+          ...options,
+          ...popGenerics(options),
+          root: false
+        });
+      }
+    }
+  }
+
+  return obj;
+}
+
+registerJsonSchemaMapper("generics", genericsMapper);

package/src/components/default/inheritedClassMapper.ts

@@ -0,0 +1,24 @@
+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";
+
+/**
+ * @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));
+    }, {});
+
+    obj = deepMerge(schema, obj);
+  }
+
+  return obj;
+}
+
+registerJsonSchemaMapper("inheritedClass", inheritedClassMapper);

package/src/components/default/itemMapper.ts

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