@tsed/schema 8.0.1 → 8.0.2

package/src/utils/from.spec.ts

@@ -0,0 +1,243 @@
+import "../index.js";
+
+import {CollectionOf} from "../decorators/collections/collectionOf.js";
+import {Property} from "../decorators/common/property.js";
+import {
+  allOf,
+  any,
+  anyOf,
+  array,
+  boolean,
+  date,
+  datetime,
+  email,
+  from,
+  integer,
+  lazyRef,
+  map,
+  number,
+  object,
+  set,
+  string,
+  time,
+  uri,
+  url
+} from "./from.js";
+
+describe("from", () => {
+  it("should declare a model", () => {
+    expect(from().toJSON()).toEqual({type: "object"});
+    expect(string().toJSON()).toEqual({type: "string"});
+    expect(number().toJSON()).toEqual({type: "number"});
+    expect(integer().toJSON()).toEqual({
+      multipleOf: 1,
+      type: "integer"
+    });
+    expect(boolean().toJSON()).toEqual({type: "boolean"});
+    expect(date().toJSON()).toEqual({
+      format: "date",
+      type: "string"
+    });
+    expect(datetime().toJSON()).toEqual({
+      format: "date-time",
+      type: "string"
+    });
+    expect(time().toJSON()).toEqual({
+      format: "time",
+      type: "string"
+    });
+    expect(email().toJSON()).toEqual({
+      format: "email",
+      type: "string"
+    });
+    expect(email().toJSON()).toEqual({
+      format: "email",
+      type: "string"
+    });
+    expect(uri().toJSON()).toEqual({
+      format: "uri",
+      type: "string"
+    });
+    expect(url().toJSON()).toEqual({
+      format: "url",
+      type: "string"
+    });
+    expect(set().toJSON()).toEqual({
+      type: "array",
+      uniqueItems: true
+    });
+    expect(map().toJSON()).toEqual({
+      additionalProperties: true,
+      type: "object"
+    });
+    expect(array().toJSON()).toEqual({type: "array"});
+    expect(any().toJSON()).toEqual({
+      anyOf: [
+        {
+          type: "null"
+        },
+        {
+          multipleOf: 1,
+          type: "integer"
+        },
+        {
+          type: "number"
+        },
+        {
+          type: "string"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          type: "array"
+        },
+        {
+          type: "object"
+        }
+      ]
+    });
+
+    expect(anyOf(string(), number()).toJSON()).toEqual({
+      anyOf: [{type: "string"}, {type: "number"}]
+    });
+
+    expect(allOf(string(), number()).toJSON()).toEqual({
+      allOf: [{type: "string"}, {type: "number"}]
+    });
+  });
+  it("should create ref when use a label", () => {
+    const ErrorSchema = object({
+      name: string().required().description("The error name"),
+      message: string().required().description("An error message")
+    })
+      .label("GenericError")
+      .unknown();
+
+    const ExceptionSchema = object()
+      .allOf([ErrorSchema])
+      .properties({
+        name: string().required().description("The error name"),
+        message: string().required().description("An error message"),
+        status: number().required().description("The status code of the exception"),
+        errors: array().items(ErrorSchema).description("A list of related errors"),
+        stack: string().description("The stack trace (only in development mode)")
+      });
+
+    expect(ExceptionSchema.toJSON()).toEqual({
+      allOf: [
+        {
+          $ref: "#/definitions/GenericError"
+        }
+      ],
+      definitions: {
+        GenericError: {
+          additionalProperties: true,
+          properties: {
+            message: {
+              description: "An error message",
+              minLength: 1,
+              type: "string"
+            },
+            name: {
+              description: "The error name",
+              minLength: 1,
+              type: "string"
+            }
+          },
+          required: ["name", "message"],
+          type: "object"
+        }
+      },
+      properties: {
+        errors: {
+          description: "A list of related errors",
+          items: {
+            $ref: "#/definitions/GenericError"
+          },
+          type: "array"
+        },
+        message: {
+          description: "An error message",
+          minLength: 1,
+          type: "string"
+        },
+        name: {
+          description: "The error name",
+          minLength: 1,
+          type: "string"
+        },
+        stack: {
+          description: "The stack trace (only in development mode)",
+          type: "string"
+        },
+        status: {
+          description: "The status code of the exception",
+          type: "number"
+        }
+      },
+      required: ["name", "message", "status"],
+      type: "object"
+    });
+  });
+  it("should declare a lazyRef", () => {
+    const schema1 = object({
+      owners: array().items(lazyRef(() => Owner))
+    });
+
+    class Post {
+      @Property()
+      id: string;
+
+      @Property(() => Owner)
+      owner: typeof Owner;
+    }
+
+    class Owner {
+      @Property()
+      id: string;
+
+      @CollectionOf(() => Post)
+      posts: Post[];
+    }
+
+    expect(schema1.toJSON()).toEqual({
+      definitions: {
+        Owner: {
+          properties: {
+            id: {
+              type: "string"
+            },
+            posts: {
+              items: {
+                $ref: "#/definitions/Post"
+              },
+              type: "array"
+            }
+          },
+          type: "object"
+        },
+        Post: {
+          properties: {
+            id: {
+              type: "string"
+            },
+            owner: {
+              $ref: "#/definitions/Owner"
+            }
+          },
+          type: "object"
+        }
+      },
+      properties: {
+        owners: {
+          items: {
+            $ref: "#/definitions/Owner"
+          },
+          type: "array"
+        }
+      },
+      type: "object"
+    });
+  });
+});

package/src/utils/from.ts

@@ -0,0 +1,281 @@
+import {isClass, Type} from "@tsed/core";
+
+import {JsonEntityStore} from "../domain/JsonEntityStore.js";
+import {JsonFormatTypes} from "../domain/JsonFormatTypes.js";
+import {JsonLazyRef} from "../domain/JsonLazyRef.js";
+import {JsonSchema} from "../domain/JsonSchema.js";
+import {enumsRegistry} from "../registries/enumRegistries.js";
+import {getJsonEntityStore} from "./getJsonEntityStore.js";
+
+/**
+ * Create a new model from the given type.
+ *
+ * ```typescript
+ * from(String)
+ * ```
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function from(type: Type<any> = Object) {
+  if (isClass(type)) {
+    const {schema} = getJsonEntityStore(type);
+
+    schema.properties = function properties(obj: {[key: string]: JsonSchema}) {
+      Object.entries(obj).forEach(([propertyKey, propSchema]) => {
+        getJsonEntityStore(type.prototype, propertyKey).schema.assign(propSchema);
+      });
+
+      return this;
+    };
+
+    return schema;
+  }
+
+  return JsonSchema.from({type});
+}
+
+/**
+ * Declare a new number model.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function number() {
+  return from(Number);
+}
+
+/**
+ * Declare a new integer model.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function integer() {
+  return from(Number).integer();
+}
+
+/**
+ * Declare a new string model.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function string() {
+  return from(String);
+}
+
+/**
+ * Declare a new boolean model.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function boolean() {
+  return from(Boolean);
+}
+
+/**
+ * Declare a new string model with `format: date`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function date() {
+  return from(Date).format(JsonFormatTypes.DATE);
+}
+
+/**
+ * Declare a new string model with `format: datetime`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function datetime() {
+  return from(Date).format(JsonFormatTypes.DATE_TIME);
+}
+
+/**
+ * Declare a new string model with `format: time`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function time() {
+  return from(Date).format(JsonFormatTypes.TIME);
+}
+
+/**
+ * Declare a new string model with `format: email`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function email() {
+  return from(String).format(JsonFormatTypes.EMAIL);
+}
+
+/**
+ * Declare a new string model with `format: uri`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function uri() {
+  return from(String).format(JsonFormatTypes.URI);
+}
+
+/**
+ * Declare a new string model with `format: url`.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function url() {
+  return from(String).format(JsonFormatTypes.URL);
+}
+
+/**
+ * Declare a new object model with `additionalProperties: true`.
+ *
+ * ```json
+ * {
+ *   "type": "array"
+ * }
+ * ```
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function array() {
+  return from(Array);
+}
+
+/**
+ * Declare a new object model with `additionalProperties: true`.
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "additionalProperties": true
+ * }
+ * ```
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function map() {
+  return from(Map).unknown(true);
+}
+
+/**
+ * Declare a new array model with `uniqueItems: true`.
+ *
+ * ```json
+ * {
+ *   "type": "array",
+ *   "uniqueItems": true
+ * }
+ * ```
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function set() {
+  return from(Array).uniqueItems(true);
+}
+
+/**
+ * Declare a new object model.
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function object(properties: {[key: string]: JsonSchema} = {}) {
+  return from(Object).properties(properties);
+}
+
+/**
+ * Declare a model with any type (By default: `integer`, `number`, `string`, `boolean`, `array`, `object`, `null`)
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ */
+export function any(...types: any[]) {
+  return from().any(...types);
+}
+
+/**
+ * See https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
+ * @schemaFunctional
+ */
+export function anyOf(...anyOf: any[]) {
+  return from().anyOf(anyOf);
+}
+
+/**
+ * See https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @schemaFunctional
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
+ */
+export function oneOf(...oneOf: any[]) {
+  return from().oneOf(oneOf);
+}
+
+/**
+ * See https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
+ *
+ *  * See @@JsonSchema@@ to discover available methods.
+ *
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
+ * @schemaFunctional
+ */
+export function allOf(...allOf: any[]) {
+  return from().allOf(allOf);
+}
+
+/**
+ * Declare a sub schema which will be resolved later. Use this function when you have a circular reference between two schemes.
+ *
+ * @schemaFunctional
+ */
+export function lazyRef(cb: () => Type<any>) {
+  try {
+    // solve issue with a self referenced model
+    if (cb()) {
+      // type is already accessible
+      return JsonEntityStore.from(cb()).schema as any;
+    }
+  } catch (er) {}
+
+  return new JsonLazyRef(cb);
+}
+export function enums(e: Record<string, any>) {
+  const schema = string().enum(e);
+  enumsRegistry.set(e, schema);
+
+  return schema;
+}