fix(schema): Avoid circular ref

.mocharc.js

@@ -10,5 +10,6 @@ module.exports = {
   reporter: "dot",
   spec: [
     "packages/**/*.spec.ts"
-  ]
+  ],
+  timeout: 3000
 };

packages/formio/test/app/controllers/pages/IndexCtrl.ts

@@ -1,5 +1,5 @@
 import {Constant, Controller, Get, HeaderParams, View} from "@tsed/common";
-import {Returns} from "@tsed/schema/src";
+import {Returns} from "@tsed/schema";
 import {Hidden, SwaggerSettings} from "@tsed/swagger";
 
 @Hidden()

packages/mongoose/test/discriminators.integration.spec.ts

@@ -3,7 +3,7 @@ import {TestMongooseContext} from "@tsed/testing-mongoose";
 import {expect} from "chai";
 import {Server} from "./helpers/Server";
 import {MongooseModel} from "../src/interfaces/MongooseModel";
-import {Required} from "@tsed/schema/src";
+import {Required} from "@tsed/schema";
 import {ObjectID, DiscriminatorKey, Model} from "../src";
 
 describe("Mongoose", () => {

packages/mongoose/test/versioning.integration.spec.ts

@@ -3,7 +3,7 @@ import {TestMongooseContext} from "@tsed/testing-mongoose";
 import {expect} from "chai";
 import {Server} from "./helpers/Server";
 import {MongooseModel} from "../src/interfaces/MongooseModel";
-import {CollectionOf, Integer, Required} from "@tsed/schema/src";
+import {Integer, Required} from "@tsed/schema";
 import {Model, ObjectID, VersionKey} from "../src";
 
 describe("Mongoose", () => {

packages/platform-express/test/response-filter.spec.ts

@@ -1,6 +1,6 @@
 import {Context, Controller, Get, PlatformTest, Res, ResponseFilter} from "@tsed/common";
 import {PlatformTestUtils} from "@tsed/platform-test-utils";
-import {Returns} from "@tsed/schema/src";
+import {Returns} from "@tsed/schema";
 import {expect} from "chai";
 import * as Sinon from "sinon";
 import SuperTest from "supertest";

packages/schema-formio/src/registries/FormioMappersContainer.ts

@@ -9,10 +9,11 @@ export function registerFormioMapper(type: string, mapper: FormioMapper) {
 }
 
 export function getFormioMapper(type: string): FormioMapper {
+  // istanbul ignore next
   if (!FormioMappersContainer.has(type)) {
-    throw new Error("Formio " + type + " mapper doesn't exists");
+    throw new Error(`Formio ${type} mapper doesn't exists`);
   }
-  return FormioMappersContainer.get(type)!; // || ((schema: string) => schema);
+  return FormioMappersContainer.get(type)!;
 }
 
 export function execMapper(type: string, schema: any, options: any): any {

packages/schema-formio/test/datamap.integration.spec.ts

@@ -1,4 +1,4 @@
-import {CollectionOf} from "@tsed/schema/src";
+import {CollectionOf} from "@tsed/schema";
 import {expect} from "chai";
 import {getFormioSchema} from "../src";
 

packages/schema-formio/test/date.integration.spec.ts

@@ -1,4 +1,4 @@
-import {DateFormat, DateTime, Email} from "@tsed/schema/src";
+import {DateFormat, DateTime} from "@tsed/schema";
 import {expect} from "chai";
 import {getFormioSchema} from "../src";
 

packages/schema-formio/test/editgrid.integration.spec.ts

@@ -1,4 +1,4 @@
-import {CollectionOf, Property} from "@tsed/schema/src";
+import {CollectionOf, Property} from "@tsed/schema";
 import {expect} from "chai";
 import {Currency, getFormioSchema} from "../src";
 

packages/schema-formio/test/email.integration.spec.ts

@@ -1,4 +1,4 @@
-import {Email} from "@tsed/schema/src";
+import {Email} from "@tsed/schema";
 import {expect} from "chai";
 import {getFormioSchema} from "../src";
 

packages/schema-formio/test/nested-form.integration.spec.ts

@@ -1,4 +1,4 @@
-import {Property} from "@tsed/schema/src";
+import {Property} from "@tsed/schema";
 import {expect} from "chai";
 import {Currency, getFormioSchema, Hidden, Textarea} from "../src";
 

packages/schema/package.json

@@ -2,10 +2,14 @@
   "name": "@tsed/schema",
   "version": "6.62.3",
   "description": "JsonSchema module for Ts.ED Framework",
+  "private": false,
   "source": "./src/index.ts",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
-  "private": false,
+  "exports": {
+    "require": "./lib/index.js",
+    "default": "./lib/index.modern.js"
+  },
   "keywords": [
     "TypeScript",
     "decorators",
@@ -17,7 +21,7 @@
     "tsed"
   ],
   "scripts": {
-    "build": "tsc --build tsconfig.compile.json"
+    "build": "microbundle --target node --no-compress --format modern,cjs --tsconfig ./tsconfig.compile.json"
   },
   "dependencies": {
     "@tsed/core": "6.62.3",

packages/schema/src/components/anyMapper.ts

@@ -0,0 +1,27 @@
+import {JsonLazyRef} from "../domain/JsonLazyRef";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+import {mapGenericsOptions} from "../utils/generics";
+import {toRef} from "../utils/ref";
+
+export function anyMapper(input: any, options: JsonSchemaOptions = {}): any {
+  options.schemas = options.schemas || {};
+
+  if (typeof input !== "object" || input === null) {
+    return input;
+  }
+
+  if (input instanceof JsonLazyRef) {
+    return execMapper("lazyRef", input, options);
+  }
+
+  if ("toJSON" in input) {
+    const schema = input.toJSON(mapGenericsOptions(options));
+
+    return input.canRef ? toRef(input, schema, options) : schema;
+  }
+
+  return execMapper("object", input, options);
+}
+
+registerJsonSchemaMapper("any", anyMapper);

packages/schema/src/components/classMapper.ts

@@ -0,0 +1,50 @@
+import {JsonEntityStore} from "../domain/JsonEntityStore";
+import {JsonSchema} from "../domain/JsonSchema";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+import {mapGenericsOptions, popGenerics} from "../utils/generics";
+import {createRef, createRefName} from "../utils/ref";
+
+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);
+      options.schemas![name] = schema;
+      delete schema.title;
+
+      return createRef(name, value, options);
+    }
+
+    return schema;
+  }
+
+  if (options.schemas && !options.schemas[name]) {
+    options.schemas[name] = {}; // avoid infinite calls
+    options.schemas[name] = execMapper(
+      "any",
+      store.schema,
+      mapGenericsOptions({
+        ...options,
+        root: false
+      })
+    );
+  }
+
+  return createRef(name, value, options);
+}
+
+registerJsonSchemaMapper("class", classMapper);

packages/schema/src/components/genericsMapper.ts

@@ -0,0 +1,69 @@
+import {isClass, isPrimitiveClass} from "@tsed/core";
+import {JsonEntityStore} from "../domain/JsonEntityStore";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+import {GenericsContext, popGenerics} from "../utils/generics";
+import {getJsonType} from "../utils/getJsonType";
+
+/**
+ * @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);

packages/schema/src/components/index.ts

@@ -0,0 +1,9 @@
+export * from "./anyMapper";
+export * from "./classMapper";
+export * from "./genericsMapper";
+export * from "./inheritedClassMapper";
+export * from "./itemMapper";
+export * from "./lazyRefMapper";
+export * from "./mapMapper";
+export * from "./objectMapper";
+export * from "./schemaMapper";

packages/schema/src/components/inheritedClassMapper.ts

@@ -0,0 +1,23 @@
+import {classOf, deepMerge} from "@tsed/core";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+import {getInheritedStores} from "../utils/getInheritedStores";
+
+/**
+ * @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);

packages/schema/src/components/itemMapper.ts

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

packages/schema/src/components/lazyRefMapper.ts

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

packages/schema/src/components/mapMapper.ts

@@ -0,0 +1,25 @@
+import {mapGenericsOptions} from "../utils/generics";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+
+/**
+ * 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);

packages/schema/src/components/objectMapper.ts

@@ -0,0 +1,29 @@
+import {isArray} from "@tsed/core";
+import {JsonSchema} from "../domain/JsonSchema";
+import {alterIgnore} from "../hooks/alterIgnore";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions";
+import {execMapper, registerJsonSchemaMapper} from "../registries/JsonSchemaMapperContainer";
+
+/**
+ * Serialize Any object to a json schema
+ * @param input
+ * @param options
+ * @ignore
+ */
+export function objectMapper(input: any, options: JsonSchemaOptions) {
+  const {specType, operationIdFormatter, root, schemas, 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)) {
+        // remove groups to avoid bad schema generation over children models
+        obj[key] = execMapper("item", value, {...options, groups: value?.$forwardGroups ? options.groups : undefined});
+      }
+
+      return obj;
+    },
+    isArray(input) ? [] : {}
+  );
+}
+
+registerJsonSchemaMapper("object", objectMapper);