@tsed/schema 8.11.0 → 8.11.2-rc.1

package/src/utils/getJsonSchema.spec.ts

@@ -1,695 +0,0 @@
-import {ancestorsOf, nameOf, Type} from "@tsed/core";
-
-import {Post} from "../../test/helpers/Post.js";
-import {CollectionOf, Email, Format, getJsonSchema, JsonEntityStore, MinLength, Name, Property, Required} from "../index.js";
-
-describe("getJsonSchema", () => {
-  it("should declare all schema correctly (basic)", () => {
-    // WHEN
-    class Model {
-      @Property()
-      @Required()
-      prop1: string;
-
-      @CollectionOf(String)
-      prop2: string[];
-
-      @CollectionOf(String)
-      prop3: Set<string>;
-
-      @CollectionOf(String)
-      prop4: Map<string, string>;
-    }
-
-    // THEN
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      required: ["prop1"],
-      properties: {
-        prop1: {
-          minLength: 1,
-          type: "string"
-        },
-        prop2: {
-          type: "array",
-          items: {
-            type: "string"
-          }
-        },
-        prop3: {
-          type: "array",
-          uniqueItems: true,
-          items: {
-            type: "string"
-          }
-        },
-        prop4: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        }
-      }
-    });
-  });
-  it("should declare all schema correctly (alias)", () => {
-    // WHEN
-    class Model {
-      @Name("prop_1")
-      @Required()
-      prop1: string;
-    }
-
-    // THEN
-    const classSchema = JsonEntityStore.from(Model);
-
-    expect(classSchema.schema.toJSON()).toEqual({
-      type: "object",
-      required: ["prop_1"],
-      properties: {
-        prop_1: {
-          minLength: 1,
-          type: "string"
-        }
-      }
-    });
-  });
-  it("should declare prop with a nested model", () => {
-    // WHEN
-    class NestedModel {
-      @Property()
-      id: string;
-
-      @Property()
-      prop1: string;
-    }
-
-    class Model {
-      @Property()
-      id: string;
-
-      @Property()
-      nested: NestedModel;
-    }
-
-    // THEN
-
-    expect(getJsonSchema(NestedModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        prop1: {
-          type: "string"
-        }
-      }
-    });
-
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/NestedModel"
-        }
-      },
-      definitions: {
-        NestedModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-  });
-  it("should declare prop with a nested model with named model", () => {
-    // WHEN
-    @Name("Nested")
-    class NestedModel {
-      @Property()
-      id: string;
-
-      @Property()
-      prop1: string;
-    }
-
-    class Model {
-      @Property()
-      id: string;
-
-      @Property()
-      nested: NestedModel;
-    }
-
-    // THEN
-
-    expect(getJsonSchema(NestedModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        prop1: {
-          type: "string"
-        }
-      }
-    });
-
-    const options = {components: {schemas: {}}};
-    expect(JsonEntityStore.from(Model).schema.clone().toJSON(options)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/Nested"
-        }
-      }
-    });
-    expect(options).toEqual({
-      components: {
-        schemas: {
-          Nested: {
-            properties: {
-              id: {
-                type: "string"
-              },
-              prop1: {
-                type: "string"
-              }
-            },
-            type: "object"
-          }
-        }
-      }
-    });
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/Nested"
-        }
-      },
-      definitions: {
-        Nested: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-  });
-  it("should declare prop with a nested of nested model (Array)", () => {
-    // WHEN
-    class ChildModel {
-      @Property()
-      id: string;
-
-      @Property()
-      prop1: string;
-    }
-
-    class NestedModel {
-      @Property()
-      id: string;
-
-      @CollectionOf(ChildModel)
-      children: ChildModel[];
-    }
-
-    class Model {
-      @Property()
-      id: string;
-
-      @Property()
-      nested: NestedModel;
-    }
-
-    // THEN
-    expect(getJsonSchema(ChildModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        prop1: {
-          type: "string"
-        }
-      }
-    });
-
-    expect(getJsonSchema(NestedModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        children: {
-          type: "array",
-          items: {
-            $ref: "#/definitions/ChildModel"
-          }
-        }
-      },
-      definitions: {
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/NestedModel"
-        }
-      },
-      definitions: {
-        NestedModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            children: {
-              type: "array",
-              items: {
-                $ref: "#/definitions/ChildModel"
-              }
-            }
-          }
-        },
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-  });
-  it("should declare prop with a nested of nested model (Set)", () => {
-    // WHEN
-    class ChildModel {
-      @Property()
-      id: string;
-
-      @Property()
-      prop1: string;
-    }
-
-    class NestedModel {
-      @Property()
-      id: string;
-
-      @CollectionOf(ChildModel)
-      children: Set<ChildModel>;
-    }
-
-    class Model {
-      @Property()
-      id: string;
-
-      @Property()
-      nested: NestedModel;
-    }
-
-    // THEN
-    expect(getJsonSchema(ChildModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        prop1: {
-          type: "string"
-        }
-      }
-    });
-
-    expect(getJsonSchema(NestedModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        children: {
-          type: "array",
-          uniqueItems: true,
-          items: {
-            $ref: "#/definitions/ChildModel"
-          }
-        }
-      },
-      definitions: {
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/NestedModel"
-        }
-      },
-      definitions: {
-        NestedModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            children: {
-              type: "array",
-              uniqueItems: true,
-              items: {
-                $ref: "#/definitions/ChildModel"
-              }
-            }
-          }
-        },
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-  });
-  it("should declare prop with a nested of nested model (Map)", () => {
-    // WHEN
-    class ChildModel {
-      @Property()
-      id: string;
-
-      @Property()
-      prop1: string;
-    }
-
-    class NestedModel {
-      @Property()
-      id: string;
-
-      @CollectionOf(ChildModel)
-      children: Map<string, ChildModel>;
-    }
-
-    class Model {
-      @Property()
-      id: string;
-
-      @Property()
-      nested: NestedModel;
-    }
-
-    // THEN
-    expect(getJsonSchema(ChildModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        prop1: {
-          type: "string"
-        }
-      }
-    });
-
-    expect(getJsonSchema(NestedModel)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        children: {
-          type: "object",
-          additionalProperties: {
-            $ref: "#/definitions/ChildModel"
-          }
-        }
-      },
-      definitions: {
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        nested: {
-          $ref: "#/definitions/NestedModel"
-        }
-      },
-      definitions: {
-        NestedModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            children: {
-              type: "object",
-              additionalProperties: {
-                $ref: "#/definitions/ChildModel"
-              }
-            }
-          }
-        },
-        ChildModel: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string"
-            },
-            prop1: {
-              type: "string"
-            }
-          }
-        }
-      }
-    });
-  });
-  it("should accept circular ref", () => {
-    // WHEN
-
-    // THEN
-    const classSchema = getJsonSchema(Post);
-
-    expect(classSchema).toEqual({
-      definitions: {
-        Post: {
-          properties: {
-            id: {
-              type: "string"
-            },
-            owner: {
-              $ref: "#/definitions/User"
-            }
-          },
-          type: "object"
-        },
-        User: {
-          properties: {
-            name: {
-              type: "string"
-            },
-            posts: {
-              items: {
-                $ref: "#/definitions/Post"
-              },
-              type: "array"
-            }
-          },
-          type: "object"
-        }
-      },
-      properties: {
-        id: {
-          type: "string"
-        },
-        owner: {
-          $ref: "#/definitions/User"
-        }
-      },
-      type: "object"
-    });
-  });
-  it("should return the json schema for an inherited model", () => {
-    class Base {
-      @Property()
-      id: string;
-
-      @Required()
-      @Email()
-      email: string;
-    }
-
-    class Model extends Base {
-      @MinLength(0)
-      declare email: string;
-
-      @Property()
-      name: string;
-    }
-
-    expect(getJsonSchema(Model)).toEqual({
-      type: "object",
-      properties: {
-        id: {
-          type: "string"
-        },
-        email: {
-          type: "string",
-          minLength: 0,
-          format: "email"
-        },
-        name: {
-          type: "string"
-        }
-      },
-      required: ["email"]
-    });
-  });
-  it("should keep required meta from inherited class", () => {
-    // WHEN
-    const AutoUUID = <T extends Type<any>>(Base: T) => {
-      class AutoUUIDMixin extends Base {
-        @Property() //showing up in swagger as a property
-        @Format("uuid") //showing up as a uuid in swagger
-        @Required(true)
-        id: string;
-      }
-
-      return AutoUUIDMixin;
-    };
-
-    const WithDates = <T extends Type<any>>(Base: T) => {
-      class WithDates extends Base {
-        @Property() //showing up in swagger as a property
-        @Format("datetime") //showing up as a uuid in swagger
-        @Required(true)
-        created_at: string;
-
-        @Property() //showing up in swagger as a property
-        @Format("datetime") //showing up as a uuid in swagger
-        @Required(true)
-        updated_at: string;
-      }
-
-      return WithDates;
-    };
-
-    class Model {
-      @Required()
-      name: string;
-    }
-
-    const DefaultMixins = <T extends Type<any>>(Base: T) => AutoUUID(WithDates(Base));
-
-    class EmailTemplate extends DefaultMixins(Model) {
-      @Required()
-      engine: string;
-    }
-
-    // THEN
-    expect(ancestorsOf(EmailTemplate).map(nameOf)).toEqual(["Model", "WithDates", "AutoUUIDMixin", "EmailTemplate"]);
-    expect(getJsonSchema(EmailTemplate)).toEqual({
-      properties: {
-        created_at: {
-          format: "datetime",
-          minLength: 1,
-          type: "string"
-        },
-        engine: {
-          minLength: 1,
-          type: "string"
-        },
-        id: {
-          format: "uuid",
-          minLength: 1,
-          type: "string"
-        },
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        updated_at: {
-          format: "datetime",
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: ["name", "created_at", "updated_at", "id", "engine"],
-      type: "object"
-    });
-  });
-});