@tsed/schema 8.0.1 → 8.0.2

package/src/utils/mergeSpec.spec.ts

@@ -0,0 +1,533 @@
+import {OpenSpec2, OpenSpec3} from "@tsed/openspec";
+
+import {mergeSpec} from "./mergeSpec.js";
+
+describe("mergeSpec", () => {
+  describe("security", () => {
+    it("should merge spec", () => {
+      const spec1: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              security: [
+                {
+                  openid: ["profile", "email"]
+                },
+                {
+                  ga: ["profile", "email"]
+                }
+              ],
+              responses: {}
+            }
+          }
+        }
+      };
+
+      const spec2: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              security: [
+                {
+                  fb: ["profile", "email"],
+                  openid: ["profile", "email"]
+                },
+                {
+                  ga: ["profile", "email", "custom"]
+                }
+              ],
+              responses: {}
+            }
+          }
+        }
+      };
+
+      expect(mergeSpec(spec1, spec2)).toEqual({
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {},
+              security: [
+                {
+                  fb: ["profile", "email"],
+                  openid: ["profile", "email"]
+                },
+                {
+                  ga: ["profile", "email", "custom"]
+                }
+              ]
+            }
+          }
+        },
+        swagger: "2.0"
+      });
+    });
+  });
+  describe("allOf", () => {
+    it("should merge spec by type", () => {
+      const spec1: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    type: "object",
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            type: "string"
+                          },
+                          {
+                            type: "number"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+
+      const spec2: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    type: "object",
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            type: "string"
+                          },
+                          {
+                            type: "number",
+                            minimum: 1
+                          },
+                          {
+                            type: "boolean"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+
+      expect(mergeSpec(spec1, spec2)).toEqual({
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            type: "string"
+                          },
+                          {
+                            minimum: 1,
+                            type: "number"
+                          },
+                          {
+                            type: "boolean"
+                          }
+                        ]
+                      }
+                    },
+                    type: "object"
+                  }
+                }
+              }
+            }
+          }
+        },
+        swagger: "2.0"
+      });
+    });
+    it("should merge spec by $ref", () => {
+      const spec1: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    type: "object",
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            $ref: "#/definitions/MyClass1"
+                          },
+                          {
+                            $ref: "#/definitions/MyClass2"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      const spec2: OpenSpec2 = {
+        swagger: "2.0",
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    type: "object",
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            type: "string"
+                          },
+                          {
+                            type: "number",
+                            minimum: 1
+                          },
+                          {
+                            $ref: "#/definitions/MyClass2"
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+
+      expect(mergeSpec(spec1, spec2)).toEqual({
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              responses: {
+                "200": {
+                  description: "description",
+                  schema: {
+                    properties: {
+                      test: {
+                        allOf: [
+                          {
+                            $ref: "#/definitions/MyClass1"
+                          },
+                          {
+                            $ref: "#/definitions/MyClass2"
+                          },
+                          {
+                            type: "string"
+                          },
+                          {
+                            minimum: 1,
+                            type: "number"
+                          }
+                        ]
+                      }
+                    },
+                    type: "object"
+                  }
+                }
+              }
+            }
+          }
+        },
+        swagger: "2.0"
+      });
+    });
+  });
+  describe("oneOf", () => {
+    it("should merge spec", () => {
+      const spec1: OpenSpec3 = {
+        openapi: "3.0.1",
+        info: {
+          title: "title",
+          version: "1.0.0",
+          description: "description"
+        },
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              parameters: [
+                {
+                  in: "query",
+                  required: false,
+                  name: "email",
+                  schema: {
+                    oneOf: [
+                      {
+                        $ref: "#/components/schemas/ContainsSearchableString"
+                      },
+                      {
+                        $ref: "#/components/schemas/EqualsSearchableString"
+                      }
+                    ]
+                  }
+                }
+              ],
+              responses: {
+                "206": {
+                  content: {
+                    "application/json": {
+                      schema: {
+                        $ref: "#/components/schemas/ContactQueryParams"
+                      }
+                    }
+                  },
+                  description: "Partial Content"
+                }
+              }
+            }
+          }
+        }
+      };
+
+      const spec2: OpenSpec3 = {
+        openapi: "3.0.1",
+        info: {
+          title: "title",
+          version: "1.0.0",
+          description: "description"
+        },
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              parameters: [
+                {
+                  in: "query",
+                  required: false,
+                  name: "email",
+                  schema: {
+                    oneOf: [
+                      {
+                        $ref: "#/components/schemas/ContainsSearchableString"
+                      },
+                      {
+                        $ref: "#/components/schemas/EqualsSearchableString"
+                      }
+                    ]
+                  }
+                }
+              ],
+              responses: {
+                "206": {
+                  content: {
+                    "application/json": {
+                      schema: {
+                        $ref: "#/components/schemas/ContactQueryParams"
+                      }
+                    }
+                  },
+                  description: "Partial Content"
+                }
+              }
+            }
+          }
+        }
+      };
+
+      expect(mergeSpec(spec1, spec2)).toEqual({
+        openapi: "3.0.1",
+        info: {
+          title: "title",
+          version: "1.0.0",
+          description: "description"
+        },
+        paths: {
+          "/get": {
+            get: {
+              operationId: "id",
+              parameters: [
+                {
+                  in: "query",
+                  required: false,
+                  name: "email",
+                  schema: {
+                    oneOf: [
+                      {
+                        $ref: "#/components/schemas/ContainsSearchableString"
+                      },
+                      {
+                        $ref: "#/components/schemas/EqualsSearchableString"
+                      }
+                    ]
+                  }
+                }
+              ],
+              responses: {
+                "206": {
+                  content: {
+                    "application/json": {
+                      schema: {
+                        $ref: "#/components/schemas/ContactQueryParams"
+                      }
+                    }
+                  },
+                  description: "Partial Content"
+                }
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+  describe("merge two specs", () => {
+    it("should merge the spec", () => {
+      const spec1 = {
+        paths: {
+          "/rest/api/1.0/test": {
+            get: {
+              operationId: "helloWorldControllerGet",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/1.0/test/{id}": {
+            get: {
+              operationId: "helloWorldControllerGetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/2.0/test": {
+            get: {
+              operationId: "helloWorldController2Get",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController2"]
+            }
+          },
+          "/rest/api/2.0/test/{id}": {
+            get: {
+              operationId: "helloWorldController2GetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController2"]
+            }
+          }
+        }
+      };
+
+      const spec2 = {
+        paths: {
+          "/rest/api/1.0/test": {
+            get: {
+              operationId: "helloWorldControllerGet",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/1.0/test/{id}": {
+            get: {
+              operationId: "helloWorldControllerGetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/2.0/test": {
+            get: {
+              operationId: "helloWorldController2Get",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController2"]
+            }
+          },
+          "/rest/api/2.0/test/{id}": {
+            get: {
+              operationId: "helloWorldController2GetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController2"]
+            }
+          }
+        }
+      };
+
+      const spec = mergeSpec(spec1, spec2);
+
+      expect(spec).toEqual({
+        paths: {
+          "/rest/api/1.0/test": {
+            get: {
+              operationId: "helloWorldControllerGet",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/1.0/test/{id}": {
+            get: {
+              operationId: "helloWorldControllerGetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController"]
+            }
+          },
+          "/rest/api/2.0/test": {
+            get: {
+              operationId: "helloWorldController2Get",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["HelloWorldController2"]
+            }
+          },
+          "/rest/api/2.0/test/{id}": {
+            get: {
+              operationId: "helloWorldController2GetById",
+              responses: {"200": {description: "Success"}},
+              parameters: [{in: "path", name: "id", required: true, schema: {type: "string"}}],
+              tags: ["HelloWorldController2"]
+            }
+          }
+        }
+      });
+    });
+  });
+});

package/src/utils/mergeSpec.ts

@@ -0,0 +1,54 @@
+import {deepMerge, mergeReducerBuilder} from "@tsed/core";
+import {OpenSpec2, OpenSpec3} from "@tsed/openspec";
+
+/**
+ * @ignore
+ */
+export const schemesReducer = mergeReducerBuilder((current, value) => {
+  if (current.type && current.type && current.type === value.type && value.type === "array") {
+    return JSON.stringify(current.items) === JSON.stringify(value.items);
+  }
+
+  return (current.type && current.type === value.type) || (current.$ref && current.$ref === value.$ref);
+});
+
+/**
+ * @ignore
+ */
+export const parameters = mergeReducerBuilder((current, value) => current.in === value.in && current.name === value.name);
+
+/**
+ * @ignore
+ */
+export const security = mergeReducerBuilder((current, value) => {
+  return !!Object.keys(value).find((key) => !!current[key]);
+});
+
+/**
+ * @ignore
+ */
+export const tagsReducer = mergeReducerBuilder((current, value) => current.name === value.name);
+
+/**
+ * @ignore
+ */
+const SPEC_REDUCERS = {
+  security,
+  parameters,
+  oneOf: schemesReducer,
+  anyOf: schemesReducer,
+  allOf: schemesReducer,
+  tags: tagsReducer
+};
+
+/**
+ * Merge two spec
+ * @param spec
+ * @param input
+ */
+export function mergeSpec<Spec = OpenSpec2 | OpenSpec3>(spec: Partial<Spec>, input: Partial<Spec>): Partial<Spec> {
+  return deepMerge(spec, input, {
+    reducers: SPEC_REDUCERS,
+    cleanUndefinedProps: true
+  });
+}

package/src/utils/operationIdFormatter.spec.ts

@@ -0,0 +1,11 @@
+import {operationIdFormatter} from "./operationIdFormatter.js";
+
+describe("operationIdFormatter", () => {
+  it("should define new OperationId", () => {
+    const formatter = operationIdFormatter();
+
+    expect(formatter("Test", "test")).toBe("testTest");
+    expect(formatter("Test", "test")).toBe("testTest_1");
+    expect(formatter("Test", "test", "/path/{id}")).toBe("testTestById");
+  });
+});

package/src/utils/operationIdFormatter.ts

@@ -0,0 +1,49 @@
+import {camelCase} from "change-case";
+
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions.js";
+
+const DEFAULT_PATTERN = "%c.%m";
+
+/**
+ * @ignore
+ */
+export function operationIdFormatter(pattern: string = "") {
+  const OPERATION_IDS = new Map<string, number>();
+
+  const transform = (name: string, propertyKey: string) => {
+    const str = (pattern || DEFAULT_PATTERN).replace(/%c/, name).replace(/%m/, propertyKey);
+    return pattern === "" ? camelCase(str) : str;
+  };
+
+  return (name: string, propertyKey: string, path: string = "") => {
+    const operationId = transform(name, propertyKey);
+    const operationKey = name + propertyKey;
+
+    if (!OPERATION_IDS.has(operationKey)) {
+      OPERATION_IDS.set(operationKey, 0);
+
+      return operationId;
+    }
+
+    // try with paths
+    const result = path.match(/{(\w+)}/gi);
+    if (result) {
+      const operationKey = name + propertyKey + result[0];
+
+      if (!OPERATION_IDS.has(operationKey)) {
+        OPERATION_IDS.set(operationKey, 0);
+
+        return camelCase(`${operationId} By ${result}`);
+      }
+    }
+
+    const id = OPERATION_IDS.get(operationKey)! + 1;
+    OPERATION_IDS.set(operationKey, id);
+
+    return `${operationId}_${id}`;
+  };
+}
+
+export function getOperationId(path: string, {store, operationIdFormatter}: JsonSchemaOptions) {
+  return operationIdFormatter!(store.parent.schema.get("name") || store.parent.targetName, store.propertyName, path);
+}

package/src/utils/ref.ts

@@ -0,0 +1,65 @@
+import {cleanObject, setValue} from "@tsed/core";
+import {pascalCase} from "change-case";
+
+import type {JsonSchema} from "../domain/JsonSchema.js";
+import {SpecTypes} from "../domain/SpecTypes.js";
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions.js";
+import {anyOf} from "./from.js";
+
+/**
+ * ignore
+ * @param options
+ */
+function getHost(options: JsonSchemaOptions) {
+  const {host = `#/${[SpecTypes.OPENAPI, SpecTypes.ASYNCAPI].includes(options.specType!) ? "components/schemas" : "definitions"}`} =
+    options;
+
+  return host;
+}
+
+/**
+ * @ignore
+ */
+export function createRefName(name: string, options: JsonSchemaOptions) {
+  if (options.groups && options.groups.length) {
+    return pascalCase(`${name} ${options.groupsName || options.groups.join(" ")}`);
+  }
+
+  return name;
+}
+
+/**
+ * @ignore
+ */
+export function createRef(name: string, schema: JsonSchema, options: JsonSchemaOptions) {
+  const host = getHost(options);
+  const ref = {
+    $ref: `${host}/${name}`
+  };
+
+  const readOnly = schema.isReadOnly;
+  const writeOnly = schema.isWriteOnly;
+
+  return cleanObject({
+    readOnly: readOnly ? true : undefined,
+    writeOnly: writeOnly ? true : undefined,
+    ...(readOnly || writeOnly
+      ? {
+          anyOf: [ref]
+        }
+      : ref)
+  });
+}
+
+/**
+ * @ignore
+ */
+export function toRef(value: JsonSchema, schema: unknown | undefined, options: JsonSchemaOptions) {
+  const name = createRefName(value.getName(), options);
+
+  if (schema) {
+    setValue(options, `components.schemas.${name}`, schema);
+  }
+
+  return createRef(name, value, options);
+}