@tsed/schema 8.11.1 → 8.12.0-rc.1

package/lib/browser/decorators/operations/path.js

@@ -1,13 +0,0 @@
-import { DecoratorTypes as e, UnsupportedDecoratorType as p } from "@tsed/core";
-import { JsonEntityFn as n } from "../common/jsonEntityFn.js";
-function a(r) {
-  return n((o, t) => {
-    if (o.decoratorType !== e.CLASS)
-      throw new p(a, t);
-    o.path = r;
-  });
-}
-export {
-  a as Path
-};
-//# sourceMappingURL=path.js.map

package/lib/browser/decorators/operations/path.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"path.js","sources":["../../../../src/decorators/operations/path.ts"],"sourcesContent":["import {DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\n\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\n\n/**\n * Set class path to expose all endpoints\n *\n * ::: warning\n * Don't use this decorator to change the path if you develop your application with Ts.ED.\n * :::\n *\n * @param path\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Path(path: string): ClassDecorator {\n  return JsonEntityFn((store, args) => {\n    if (store.decoratorType !== DecoratorTypes.CLASS) {\n      throw new UnsupportedDecoratorType(Path, args);\n    }\n\n    store.path = path;\n  });\n}\n"],"names":["Path","path","JsonEntityFn","store","args","DecoratorTypes","UnsupportedDecoratorType"],"mappings":";;AAkBO,SAASA,EAAKC,GAA8B;AAC1C,SAAAC,EAAa,CAACC,GAAOC,MAAS;AAC/B,QAAAD,EAAM,kBAAkBE,EAAe;AACnC,YAAA,IAAIC,EAAyBN,GAAMI,CAAI;AAG/C,IAAAD,EAAM,OAAOF;AAAA,EAAA,CACd;AACH;"}

package/lib/browser/decorators/operations/produces.js

@@ -1,20 +0,0 @@
-import { UnsupportedDecoratorType as c, DecoratorTypes as t, decorateMethodsOf as n } from "@tsed/core";
-import { JsonEntityFn as p } from "../common/jsonEntityFn.js";
-function a(...e) {
-  return p((o, r) => {
-    switch (o.decoratorType) {
-      case t.METHOD:
-        o.operation.produces(e);
-        break;
-      case t.CLASS:
-        n(r[0], a(...e));
-        break;
-      default:
-        throw new c(a, r);
-    }
-  });
-}
-export {
-  a as Produces
-};
-//# sourceMappingURL=produces.js.map

package/lib/browser/decorators/operations/produces.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"produces.js","sources":["../../../../src/decorators/operations/produces.ts"],"sourcesContent":["import {decorateMethodsOf, DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\n\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\n\n/**\n * Add produces metadata on the decorated element.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * class Model {\n *    @Produces(\"text/html\")\n *    id: string;\n * }\n * ```\n *\n * ::: warning\n * For openspec v3 prefer `@Returns().ContentType()` usage (see @@Returns@@).\n * :::\n *\n * @param produces\n * @decorator\n * @swagger\n * @methodDecorator\n * @classDecorator\n * @operation\n * @response\n */\nexport function Produces(...produces: string[]): ClassDecorator & MethodDecorator {\n  return JsonEntityFn((store, args) => {\n    switch (store.decoratorType) {\n      case DecoratorTypes.METHOD:\n        store.operation!.produces(produces);\n        break;\n      case DecoratorTypes.CLASS:\n        decorateMethodsOf(args[0], Produces(...produces));\n        break;\n\n      default:\n        throw new UnsupportedDecoratorType(Produces, args);\n    }\n  });\n}\n"],"names":["Produces","produces","JsonEntityFn","store","args","DecoratorTypes","decorateMethodsOf","UnsupportedDecoratorType"],"mappings":";;AA6BO,SAASA,KAAYC,GAAsD;AACzE,SAAAC,EAAa,CAACC,GAAOC,MAAS;AACnC,YAAQD,EAAM,eAAe;AAAA,MAC3B,KAAKE,EAAe;AACZ,QAAAF,EAAA,UAAW,SAASF,CAAQ;AAClC;AAAA,MACF,KAAKI,EAAe;AAClB,QAAAC,EAAkBF,EAAK,CAAC,GAAGJ,EAAS,GAAGC,CAAQ,CAAC;AAChD;AAAA,MAEF;AACQ,cAAA,IAAIM,EAAyBP,GAAUI,CAAI;AAAA,IAAA;AAAA,EACrD,CACD;AACH;"}

package/lib/browser/decorators/operations/publish.js

@@ -1,9 +0,0 @@
-import { OperationVerbs as o } from "../../constants/OperationVerbs.js";
-import { Operation as t } from "./operation.js";
-function n(r) {
-  return t(o.PUBLISH, r);
-}
-export {
-  n as Publish
-};
-//# sourceMappingURL=publish.js.map

package/lib/browser/decorators/operations/publish.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"publish.js","sources":["../../../../src/decorators/operations/publish.ts"],"sourcesContent":["import {OperationVerbs} from \"../../constants/OperationVerbs.js\";\nimport {Operation} from \"./operation.js\";\n\nexport function Publish(event: string) {\n  return Operation(OperationVerbs.PUBLISH, event);\n}\n"],"names":["Publish","event","Operation","OperationVerbs"],"mappings":";;AAGO,SAASA,EAAQC,GAAe;AAC9B,SAAAC,EAAUC,EAAe,SAASF,CAAK;AAChD;"}

package/lib/browser/decorators/operations/redirect.js

@@ -1,20 +0,0 @@
-import { isNumber as n, isString as s, useDecorators as c } from "@tsed/core";
-import { JsonEntityFn as o } from "../common/jsonEntityFn.js";
-import { Returns as f } from "./returns.js";
-function b(...u) {
-  const { status: e, url: i, meta: m } = u.reduce(
-    (r, t) => n(t) ? (r.status = t, r) : s(t) ? (r.url = t, r) : (r.meta = t, r),
-    { status: 302, url: "", meta: {} }
-  );
-  return c(
-    f(e).Location(i, m),
-    o((r) => {
-      var t;
-      (t = r.operation) == null || t.setRedirection(e);
-    })
-  );
-}
-export {
-  b as Redirect
-};
-//# sourceMappingURL=redirect.js.map

package/lib/browser/decorators/operations/redirect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"redirect.js","sources":["../../../../src/decorators/operations/redirect.ts"],"sourcesContent":["import {isNumber, isString, useDecorators} from \"@tsed/core\";\n\nimport {JsonHeader} from \"../../interfaces/JsonOpenSpec.js\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\nimport {Returns} from \"./returns.js\";\n\n/**\n * Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an HTTP status code . If not specified, status defaults to “302 “Found”.\n *\n * ```typescript\n *  @Redirect('/foo/bar')\n *  @Redirect(301, 'http://example.com').Type(Model)\n *  private myMethod() {}\n * ```\n * Redirects can be a fully-qualified URL for redirecting to a different site:\n *\n * ```typescript\n *  @Redirect('http://google.com');\n *  private myMethod() {}\n * ```\n *\n * Redirects can be relative to the root of the host name. For example, if the application is on http://example.com/admin/post/new, the following would redirect to the URL http://example.com/admin:\n *\n * ```typescript\n *  @Redirect('/admin');\n * ```\n * Redirects can be relative to the current URL. For example, from http://example.com/blog/admin/ (notice the trailing slash), the following would redirect to the URL http://example.com/blog/admin/post/new.\n *\n * ```typescript\n *  @Redirect('post/new');\n * ```\n *\n * Redirecting to post/new from http://example.com/blog/admin (no trailing slash), will redirect to http://example.com/blog/post/new.\n *\n * If you found the above behavior confusing, think of path segments as directories (with trailing slashes) and files, it will start to make sense.\n *\n * Path-relative redirects are also possible. If you were on http://example.com/admin/post/new, the following would redirect to http//example.com/admin/post:\n *\n * ```typescript\n *  @Redirect('..');\n * ``\n *\n * A back redirection redirects the request back to the referer, defaulting to / when the referer is missing.\n *\n * ```typescript\n *  @Redirect('back');\n * ```\n *\n * @param url\n * @param meta\n * @decorator\n * @operation\n * @response\n * @headers\n */\nexport function Redirect(url: string, meta?: JsonHeader): MethodDecorator;\nexport function Redirect(status: number, url: string, meta?: JsonHeader): MethodDecorator;\nexport function Redirect(...args: any[]): MethodDecorator {\n  const {status, url, meta} = args.reduce(\n    (options: any, value: any) => {\n      if (isNumber(value)) {\n        options.status = value;\n        return options;\n      }\n\n      if (isString(value)) {\n        options.url = value;\n        return options;\n      }\n\n      options.meta = value;\n      return options;\n    },\n    {status: 302, url: \"\", meta: {}}\n  );\n  return useDecorators(\n    Returns(status).Location(url, meta),\n    JsonEntityFn((entity) => {\n      entity.operation?.setRedirection(status);\n    })\n  );\n}\n"],"names":["Redirect","args","status","url","meta","options","value","isNumber","isString","useDecorators","Returns","JsonEntityFn","entity","_a"],"mappings":";;;AAyDO,SAASA,KAAYC,GAA8B;AACxD,QAAM,EAAC,QAAAC,GAAQ,KAAAC,GAAK,MAAAC,MAAQH,EAAK;AAAA,IAC/B,CAACI,GAAcC,MACTC,EAASD,CAAK,KAChBD,EAAQ,SAASC,GACVD,KAGLG,EAASF,CAAK,KAChBD,EAAQ,MAAMC,GACPD,MAGTA,EAAQ,OAAOC,GACRD;AAAA,IAET,EAAC,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAE,EAAA;AAAA,EACjC;AACO,SAAAI;AAAA,IACLC,EAAQR,CAAM,EAAE,SAASC,GAAKC,CAAI;AAAA,IAClCO,EAAa,CAACC,MAAW;;AAChB,OAAAC,IAAAD,EAAA,cAAA,QAAAC,EAAW,eAAeX;AAAA,IAClC,CAAA;AAAA,EACH;AACF;"}

package/lib/browser/decorators/operations/returns.js

@@ -1,180 +0,0 @@
-import { isString as l, isArray as f, isCollection as d, isPrimitiveOrPrimitiveClass as g, isPlainObject as w, decoratorTypeOf as T, DecoratorTypes as p, decorateMethodsOf as b, isObject as C } from "@tsed/core";
-import { getStatusMessage as y } from "../../constants/httpStatusMessages.js";
-import { DecoratorContext as x } from "../../domain/DecoratorContext.js";
-import { JsonEntityStore as A } from "../../domain/JsonEntityStore.js";
-import { JsonParameter as P } from "../../domain/JsonParameter.js";
-import { JsonSchema as O } from "../../domain/JsonSchema.js";
-import { string as G } from "../../fn/string.js";
-import { getStatusModel as M } from "../../utils/defineStatusModel.js";
-import { isSuccessStatus as v } from "../../utils/isSuccessStatus.js";
-import { mapHeaders as N } from "../../utils/mapHeaders.js";
-function j(n) {
-  return C(n) && !("toJSON" in n);
-}
-function S(n) {
-  return n.map((t) => j(t) ? G().enum(Object.values(t)) : t);
-}
-class E extends x {
-  constructor({ status: t, model: e }) {
-    super(), this.methods = [
-      "contentType",
-      "description",
-      "examples",
-      "type",
-      "status",
-      "of",
-      "ofInteger",
-      "oneOf",
-      "allOf",
-      "anyOf",
-      "nested",
-      "header",
-      "headers",
-      "schema",
-      "title",
-      "groups",
-      "allowedGroups",
-      "location",
-      "binary"
-    ], this.model(e), this.status(t);
-  }
-  type(t) {
-    return this.model(t);
-  }
-  model(t) {
-    return t && this.set("model", t), this;
-  }
-  status(t) {
-    return this.set("status", t), t && y(t) && !this.get("description") && (this.set("description", y(t)), this.get("model") || this.model(M(+t))), this;
-  }
-  headers(t) {
-    return this.set("headers", {
-      ...this.get("headers") || {},
-      ...N(t)
-    }), this;
-  }
-  header(t, e) {
-    return e === void 0 && l(t) ? this.headers({ [t]: { type: "string" } }) : this.headers({ [t]: e });
-  }
-  location(t, e = {}) {
-    return this.headers({
-      Location: {
-        ...e,
-        value: t
-      }
-    }), this;
-  }
-  groups(...t) {
-    return t.length === 2 && f(t[1]) ? (this.set("groupsName", t[0]), this.set("groups", t[1])) : this.set("groups", t), this;
-  }
-  allowedGroups(...t) {
-    return this.set("allowedGroups", new Set(t)), this;
-  }
-  nested(...t) {
-    const e = this.get("model");
-    return this.checkPrimitive(e), this.checkCollection(e), this.addAction((s) => {
-      this.get("schema").nestedGenerics.push(S(t));
-    }), this;
-  }
-  of(...t) {
-    const e = this.get("model");
-    return this.checkPrimitive(e), this.addAction(() => {
-      const s = this.get("schema");
-      d(e) ? s == null || s.itemSchema({ type: t[0] }) : s == null || s.nestedGenerics.push(S(t));
-    }), this;
-  }
-  ofInteger() {
-    return this.of("integer");
-  }
-  oneOf(...t) {
-    return this.manyOf("oneOf", t);
-  }
-  allOf(...t) {
-    return this.manyOf("allOf", t);
-  }
-  anyOf(...t) {
-    return this.manyOf("anyOf", t);
-  }
-  schema(t) {
-    return this.addAction(() => {
-      this.get("schema").assign(t);
-    }), this;
-  }
-  examples(t) {
-    return this.set("examples", l(t) ? [t] : t), this;
-  }
-  title(t) {
-    return this.schema({ title: t });
-  }
-  binary() {
-    return this.type(String), this.set("contentType", "application/octet-stream"), this.schema({ format: "binary" }), this;
-  }
-  checkPrimitive(t) {
-    if (g(t))
-      throw new Error("Returns.Of cannot be used with the following primitive classes: String, Number, Boolean");
-  }
-  checkCollection(t) {
-    if (d(t))
-      throw new Error("Returns.Nested cannot be used with the following classes: Map, Set, Array, String, Number, Boolean");
-  }
-  getContentType() {
-    const t = this.get("model");
-    let e = this.get("contentType");
-    return (t && !w(t) && !g(t) || this.hasOfTypes) && (e = e || "application/json"), e;
-  }
-  getStatus() {
-    return this.get("status") || "default";
-  }
-  onInit(t, e) {
-    switch (T(t)) {
-      case p.METHOD:
-        this.entity = A.from(...t), this.entity.operation && this.map();
-        break;
-      case p.CLASS:
-        this.decoratorType = p.CLASS, b(t[0], e);
-        break;
-    }
-  }
-  map() {
-    const t = this.get("model"), { entity: e, decoratorType: s } = this, i = this.entity.operation, a = this.getStatus(), o = i.ensureResponseOf(a), c = this.getContentType();
-    let { description: r = o.get("description") } = this.toObject();
-    r && (r = s === p.CLASS && o.get("description") || r, o.description(r));
-    const m = this.getMergedKey("headers", o.get("headers"));
-    return m && o.headers(m), this.mapMedia(o), (v(this.get("status")) || a === "default") && t && (e.type = t), c && i.addProduce(c), this.runActions();
-  }
-  mapMedia(t) {
-    const e = this.getContentType(), s = this.get("model"), i = t.getMedia(e || "*/*"), a = i.get("schema") || new O({ type: s }), o = this.get("groups"), c = this.get("groupsName"), r = this.get("allowedGroups"), m = this.entity.operation;
-    if (s && (f(s) ? a.oneOf(s.map((h) => ({ type: h }))) : a.type(s)), this.set("schema", a), i.schema(a), i.groups = o, i.groupsName = c, r) {
-      i.allowedGroups = r;
-      const h = new P();
-      h.in("query").name("includes"), h.schema(
-        O.from({
-          type: "array",
-          items: {
-            type: "string",
-            enum: [...r]
-          }
-        })
-      ), m.addParameter(-1, h);
-    }
-    const u = this.get("examples");
-    return u && i.examples(u), i;
-  }
-  manyOf(t, e) {
-    const s = this.get("model");
-    return this.hasOfTypes = !0, this.addAction(() => {
-      const i = this.get("schema");
-      d(s) ? (i.type(s || Object), i.itemSchema().set(t, e)) : i.set(t, e);
-    }), this;
-  }
-}
-function z(n, t) {
-  return new E({
-    status: n,
-    model: t
-  }).build();
-}
-export {
-  z as Returns
-};
-//# sourceMappingURL=returns.js.map

package/lib/browser/decorators/operations/returns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"returns.js","sources":["../../../../src/decorators/operations/returns.ts"],"sourcesContent":["import {\n  decorateMethodsOf,\n  decoratorTypeOf,\n  DecoratorTypes,\n  isArray,\n  isCollection,\n  isObject,\n  isPlainObject,\n  isPrimitiveOrPrimitiveClass,\n  isString,\n  Type\n} from \"@tsed/core\";\nimport {OS3Example} from \"@tsed/openspec\";\n\nimport {getStatusMessage} from \"../../constants/httpStatusMessages.js\";\nimport {DecoratorContext} from \"../../domain/DecoratorContext.js\";\nimport {JsonEntityStore} from \"../../domain/JsonEntityStore.js\";\nimport {JsonParameter} from \"../../domain/JsonParameter.js\";\nimport {JsonResponse} from \"../../domain/JsonResponse.js\";\nimport {JsonSchema, JsonSchemaObject} from \"../../domain/JsonSchema.js\";\nimport {string} from \"../../fn/string.js\";\nimport {JsonHeader, JsonHeaders} from \"../../interfaces/JsonOpenSpec.js\";\nimport {getStatusModel} from \"../../utils/defineStatusModel.js\";\nimport {GenericValue} from \"../../utils/generics.js\";\nimport {isSuccessStatus} from \"../../utils/isSuccessStatus.js\";\nimport {mapHeaders} from \"../../utils/mapHeaders.js\";\n\nexport interface ReturnsChainedDecorators {\n  <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;\n\n  (target: Function): void;\n\n  /**\n   * Set a Content-Type for the current response\n   * @param value\n   * @constructor\n   */\n  ContentType(value: string): this;\n\n  /**\n   * Add a description\n   * @param description\n   */\n  Description(description: string): this;\n\n  /**\n   * Add examples\n   * @param examples\n   */\n  Examples(examples: Record<string, OS3Example>): this;\n\n  Examples(examples: Record<string, any>): this;\n\n  Examples(examples: any): this;\n\n  /**\n   * Change the model type\n   * @param type\n   */\n  Type(type: Type<any> | any): this;\n\n  /**\n   * Change the status\n   * @param status\n   * @constructor\n   */\n  Status(status: string | number): this;\n\n  /**\n   * Add the nested types\n   * @param types\n   */\n  Of(...types: GenericValue[]): this;\n\n  /**\n   * For the integer type\n   */\n  OfInteger(): this;\n\n  /**\n   * Add the nested types\n   * @param types\n   */\n  OneOf(...types: GenericValue[]): this;\n\n  /**\n   * Add the nested types\n   * @param types\n   */\n  AllOf(...types: GenericValue[]): this;\n\n  /**\n   * Add the nested types\n   * @param types\n   */\n  AnyOf(...types: GenericValue[]): this;\n\n  /**\n   * Declare a nested generic models\n   * @param generics\n   */\n  Nested(...generics: GenericValue[]): this;\n\n  /**\n   * Add header.\n   * @param key\n   * @param value\n   */\n  Header(key: string, value?: number | string | (JsonHeader & {value?: string | number | boolean})): this;\n\n  /**\n   * Add headers\n   */\n  Headers(headers: JsonHeaders): this;\n\n  /**\n   * Add location hea\n   */\n  Location(location: string, meta?: JsonHeader): this;\n\n  /**\n   * Assign partial schema\n   * @param schema\n   */\n  Schema(schema: Partial<JsonSchemaObject> | JsonSchema): this;\n\n  /**\n   * Add an inline title for the return model.\n   * @param title\n   */\n  Title(title: string): this;\n\n  /**\n   * Use group to filter model\n   * @param groups\n   */\n  Groups(...groups: string[]): this;\n\n  Groups(groupName: string, groups: string[]): this;\n\n  /**\n   * Add a list of allowed groups to filter dynamically fields. Listed groups can be used by the consumer to change\n   * the mapped response.\n   * @param allowedGroups\n   */\n  AllowedGroups(...allowedGroups: string[]): this;\n\n  /**\n   * Apply the application/octet-stream and binary format on Open API documentation\n   */\n  Binary(): this;\n\n  [key: string]: any;\n}\n\n/**\n * @ignore\n */\nfunction isEnum(type: any) {\n  return isObject(type) && !(\"toJSON\" in type);\n}\n\nfunction mapGenerics(types: GenericValue[]) {\n  return types.map((type) => {\n    if (isEnum(type)) {\n      return string().enum(Object.values(type));\n    }\n    return type;\n  });\n}\n\n/**\n * @ignore\n */\nclass ReturnDecoratorContext extends DecoratorContext<ReturnsChainedDecorators> {\n  readonly methods: string[] = [\n    \"contentType\",\n    \"description\",\n    \"examples\",\n    \"type\",\n    \"status\",\n    \"of\",\n    \"ofInteger\",\n    \"oneOf\",\n    \"allOf\",\n    \"anyOf\",\n    \"nested\",\n    \"header\",\n    \"headers\",\n    \"schema\",\n    \"title\",\n    \"groups\",\n    \"allowedGroups\",\n    \"location\",\n    \"binary\"\n  ];\n\n  private hasOfTypes: boolean;\n\n  constructor({status, model}: any) {\n    super();\n\n    this.model(model);\n    this.status(status);\n  }\n\n  type(model: any) {\n    return this.model(model);\n  }\n\n  model(model: any) {\n    model && this.set(\"model\", model);\n    return this;\n  }\n\n  status(status: number | string) {\n    this.set(\"status\", status);\n\n    if (status && getStatusMessage(status) && !this.get(\"description\")) {\n      this.set(\"description\", getStatusMessage(status));\n\n      if (!this.get(\"model\")) {\n        this.model(getStatusModel(+status));\n      }\n    }\n\n    return this;\n  }\n\n  headers(headers: JsonHeaders) {\n    this.set(\"headers\", {\n      ...(this.get(\"headers\") || {}),\n      ...mapHeaders(headers)\n    });\n\n    return this;\n  }\n\n  header(key: string, value?: string | JsonHeader) {\n    if (value === undefined && isString(key)) {\n      return this.headers({[key]: {type: \"string\"}});\n    }\n\n    return this.headers({[key]: value!});\n  }\n\n  location(path: string, meta: JsonHeaders = {}) {\n    this.headers({\n      Location: {\n        ...meta,\n        value: path\n      }\n    });\n\n    return this;\n  }\n\n  groups(groupName: string, groups: string[]): this;\n  groups(...groups: string[]): this;\n  groups(...groups: string[] | [string, string[]]) {\n    if (groups.length === 2 && isArray(groups[1])) {\n      this.set(\"groupsName\", groups[0]);\n      this.set(\"groups\", groups[1]);\n    } else {\n      this.set(\"groups\", groups);\n    }\n\n    return this;\n  }\n\n  allowedGroups(...allowedGroups: string[]) {\n    this.set(\"allowedGroups\", new Set(allowedGroups));\n    return this;\n  }\n\n  nested(...generics: GenericValue[]) {\n    const model = this.get(\"model\");\n    this.checkPrimitive(model);\n    this.checkCollection(model);\n\n    this.addAction((ctx) => {\n      (this.get(\"schema\") as JsonSchema).nestedGenerics.push(mapGenerics(generics));\n    });\n\n    return this;\n  }\n\n  of(...types: (Type<any> | any)[]) {\n    const model = this.get(\"model\");\n    this.checkPrimitive(model);\n\n    this.addAction(() => {\n      const schema = this.get(\"schema\") as JsonSchema;\n\n      if (isCollection(model)) {\n        schema?.itemSchema({type: types[0]});\n      } else {\n        schema?.nestedGenerics.push(mapGenerics(types));\n      }\n    });\n\n    return this;\n  }\n\n  ofInteger() {\n    return this.of(\"integer\");\n  }\n\n  oneOf(...types: (Type<any> | any)[]) {\n    return this.manyOf(\"oneOf\", types);\n  }\n\n  allOf(...types: (Type<any> | any)[]) {\n    return this.manyOf(\"allOf\", types);\n  }\n\n  anyOf(...types: (Type<any> | any)[]) {\n    return this.manyOf(\"anyOf\", types);\n  }\n\n  schema(partial: Partial<JsonSchemaObject> | JsonSchema) {\n    this.addAction(() => {\n      const schema = this.get(\"schema\") as JsonSchema;\n\n      schema!.assign(partial);\n    });\n\n    return this;\n  }\n\n  examples(examples: any) {\n    this.set(\"examples\", isString(examples) ? [examples] : examples);\n    return this;\n  }\n\n  title(title: string) {\n    return this.schema({title});\n  }\n\n  binary() {\n    this.type(String);\n    this.set(\"contentType\", \"application/octet-stream\");\n    this.schema({format: \"binary\"});\n\n    return this;\n  }\n\n  protected checkPrimitive(model: any) {\n    if (isPrimitiveOrPrimitiveClass(model)) {\n      throw new Error(\"Returns.Of cannot be used with the following primitive classes: String, Number, Boolean\");\n    }\n  }\n\n  protected checkCollection(model: any) {\n    if (isCollection(model)) {\n      throw new Error(\"Returns.Nested cannot be used with the following classes: Map, Set, Array, String, Number, Boolean\");\n    }\n  }\n\n  protected getContentType() {\n    const model = this.get(\"model\");\n    let contentType = this.get(\"contentType\");\n\n    if ((model && !isPlainObject(model) && !isPrimitiveOrPrimitiveClass(model)) || this.hasOfTypes) {\n      contentType = contentType || \"application/json\";\n    }\n\n    return contentType;\n  }\n\n  protected getStatus() {\n    return this.get(\"status\") || \"default\";\n  }\n\n  protected onInit(args: any[], decorator: any) {\n    const type = decoratorTypeOf(args);\n    switch (type) {\n      case DecoratorTypes.METHOD:\n        this.entity = JsonEntityStore.from(...args);\n        if (this.entity.operation) {\n          this.map();\n        }\n        break;\n      case DecoratorTypes.CLASS:\n        this.decoratorType = DecoratorTypes.CLASS;\n        decorateMethodsOf(args[0], decorator);\n        break;\n    }\n  }\n\n  protected map() {\n    const model = this.get(\"model\");\n    const {entity, decoratorType} = this;\n    const operation = this.entity.operation!;\n    const currentStatus = this.getStatus();\n    const response = operation.ensureResponseOf(currentStatus);\n    const contentType = this.getContentType();\n\n    let {description = response.get(\"description\")} = this.toObject();\n\n    if (description) {\n      description = decoratorType === DecoratorTypes.CLASS ? response.get(\"description\") || description : description;\n      response.description(description);\n    }\n\n    const headers = this.getMergedKey(\"headers\", response.get(\"headers\"));\n\n    if (headers) {\n      response.headers(headers);\n    }\n\n    this.mapMedia(response);\n\n    if (isSuccessStatus(this.get(\"status\")) || currentStatus === \"default\") {\n      if (model) {\n        entity.type = model;\n      }\n    }\n\n    // additional info for OS2\n    contentType && operation.addProduce(contentType);\n\n    // run additional actions\n    return this.runActions();\n  }\n\n  protected mapMedia(response: JsonResponse) {\n    const contentType = this.getContentType();\n    const model = this.get(\"model\");\n    const media = response.getMedia(contentType || \"*/*\");\n    const schema = media.get(\"schema\") || new JsonSchema({type: model});\n    const groups = this.get(\"groups\");\n    const groupsName = this.get(\"groupsName\");\n    const allowedGroups = this.get(\"allowedGroups\");\n    const operation = this.entity.operation!;\n\n    if (model) {\n      if (isArray(model)) {\n        schema.oneOf(model.map((type) => ({type})));\n      } else {\n        schema.type(model);\n      }\n    }\n\n    this.set(\"schema\", schema);\n\n    media.schema(schema);\n\n    media.groups = groups;\n    media.groupsName = groupsName;\n\n    if (allowedGroups) {\n      media.allowedGroups = allowedGroups;\n\n      const jsonParameter = new JsonParameter();\n      jsonParameter.in(\"query\").name(\"includes\");\n      jsonParameter.schema(\n        JsonSchema.from({\n          type: \"array\",\n          items: {\n            type: \"string\",\n            enum: [...allowedGroups]\n          }\n        })\n      );\n\n      operation.addParameter(-1, jsonParameter);\n    }\n\n    const examples = this.get(\"examples\");\n\n    if (examples) {\n      media.examples(examples);\n    }\n\n    return media;\n  }\n\n  private manyOf(kind: string, types: any[]) {\n    const model = this.get(\"model\");\n    this.hasOfTypes = true;\n\n    this.addAction(() => {\n      const schema = this.get(\"schema\") as JsonSchema;\n\n      if (isCollection(model)) {\n        schema.type(model || Object);\n\n        schema.itemSchema().set(kind, types);\n      } else {\n        schema.set(kind, types);\n      }\n    });\n\n    return this;\n  }\n}\n\n/**\n * Add responses documentation for a specific status code.\n *\n * ## Usage\n *\n * Ts.ED v5/v6 API introducing the chaining decorator concept. Now a decorator like Returns can be used with another decorators like Description.\n *\n * ::: warning\n * v5 has a basic support of the chaining decorator to facilitate the migration to v6!\n * :::\n *\n * ```typescript\n * import {Returns} from \"@tsed/schema\";\n *\n * @Controller(\"/\")\n * class MyController {\n *   @Returns(404, String).Description(\"Not Found\")\n *   @Returns(200, Model).Description(\"Success\")\n *   async myMethod(): Promise<Model> {}\n * }\n * ```\n *\n * ::: tip\n * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know\n * what chained decorators are available under Returns decorator.\n * :::\n *\n * This example will produce this documentation in swagger:\n *\n * ```json\n * {\n *   \"responses\": {\n *     \"404\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"type\": \"string\"}\n *     },\n *     \"2OO\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"$ref\": \"...\"}\n *     }\n *   }\n * }\n * ```\n *\n * ## Declaring an Array\n *\n * Use chained decorators to declare an array with model as following:\n *\n * ```typescript\n * import {Returns} from \"@tsed/schema\";\n *\n * @Controller(\"/models\")\n * class ModelCtrl {\n *   @Get(\"/\")\n *   @Returns(200, Array).Of(Model).Description(\"Success\")\n *   async myMethod(): Promise<Model>  {\n *   }\n * }\n * ```\n *\n * Deprecated version:\n *\n * ```typescript\n * import {ReturnsArray} from \"@tsed/platform-http\";\n * import {Returns} from \"@tsed/schema\";\n *\n * @Controller(\"/\")\n * class MyController {\n *   @ReturnsArray(200, Model) // deprecated\n *   async myMethod(): Promise<Model> {}\n * }\n * ```\n *\n * ### Declaring a generic model <Badge text=\"6+\"/>\n *\n * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to\n * declare explicitly the generic models with the decorators.\n *\n * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.\n *\n * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:\n *\n * ```typescript\n * @Generics(\"T\")\n * class Pagination<T> {\n *  @CollectionOf(\"T\")\n *  data: T[];\n *\n *  @Property()\n *  totalCount: number;\n * }\n * ```\n *\n * Now, we need a model to be used with the generic Pagination model:\n *\n * ```typescript\n * class Product {\n *  @Property()\n *  id: string;\n *\n *  @Property()\n *  title: string;\n * }\n * ```\n *\n * Finally, we can use our models on a method as following:\n *\n * ```typescript\n * class Controller {\n *   @OperationPath(\"POST\", \"/\")\n *   @Returns(200, Pagination).Of(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Product> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * ### Declaring a nested generics models <Badge text=\"6+\"/>\n *\n * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:\n *\n * ```typescript\n * import {Post, Generics, Property, Returns} from \"@tsed/schema\";\n *\n * class Controller {\n *   @Post(\"/\")\n *   @Returns(200, Pagination).Of(Submission).Nested(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Submission<Product>> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * And here is the Submission model:\n *\n * ```typescript\n * import {Generics, Property} from \"@tsed/schema\";\n *\n * @Generics(\"T\")\n * class Submission<T> {\n *   @Property()\n *   _id: string;\n *   @Property(\"T\")\n *   data: T;\n * }\n * ```\n *\n * @param status\n * @param model\n * @decorator\n * @swagger\n * @schema\n * @response\n * @operation\n */\nexport function Returns(status?: string | number, model?: Type<any> | Type<any>[]): ReturnsChainedDecorators;\nexport function Returns(status?: string | number, model?: Type<any> | Type<any>[] | any): ReturnsChainedDecorators {\n  const context = new ReturnDecoratorContext({\n    status,\n    model\n  });\n\n  return context.build();\n}\n"],"names":["isEnum","type","isObject","mapGenerics","types","string","ReturnDecoratorContext","DecoratorContext","status","model","getStatusMessage","getStatusModel","headers","mapHeaders","key","value","isString","path","meta","groups","isArray","allowedGroups","generics","ctx","schema","isCollection","partial","examples","title","isPrimitiveOrPrimitiveClass","contentType","isPlainObject","args","decorator","decoratorTypeOf","DecoratorTypes","JsonEntityStore","decorateMethodsOf","entity","decoratorType","operation","currentStatus","response","description","isSuccessStatus","media","JsonSchema","groupsName","jsonParameter","JsonParameter","kind","Returns"],"mappings":"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"}

package/lib/browser/decorators/operations/route.js

@@ -1,37 +0,0 @@
-import { OperationVerbs as c } from "../../constants/OperationVerbs.js";
-import { Operation as o } from "./operation.js";
-function u(n = "/", ...t) {
-  return o(...[c.ALL, n].concat(t));
-}
-function i(n = "/", ...t) {
-  return o(...[c.GET, n].concat(t));
-}
-function a(n = "/", ...t) {
-  return o(...[c.POST, n].concat(t));
-}
-function f(n = "/", ...t) {
-  return o(...[c.PUT, n].concat(t));
-}
-function P(n = "/", ...t) {
-  return o(...[c.DELETE, n].concat(t));
-}
-function p(n = "/", ...t) {
-  return o(...[c.HEAD, n].concat(t));
-}
-function O(n = "/", ...t) {
-  return o(...[c.PATCH, n].concat(t));
-}
-function T(n = "/", ...t) {
-  return o(...[c.OPTIONS, n].concat(t));
-}
-export {
-  u as All,
-  P as Delete,
-  i as Get,
-  p as Head,
-  T as Options,
-  O as Patch,
-  a as Post,
-  f as Put
-};
-//# sourceMappingURL=route.js.map

package/lib/browser/decorators/operations/route.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"route.js","sources":["../../../../src/decorators/operations/route.ts"],"sourcesContent":["import {OperationVerbs} from \"../../constants/OperationVerbs.js\";\nimport {Operation} from \"./operation.js\";\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function All(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.ALL, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Get(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.GET, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Post(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.POST, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Put(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.PUT, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Delete(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.DELETE, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Head(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.HEAD, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Patch(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Operation(...[OperationVerbs.PATCH, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Options(path: string | RegExp | unknown = \"/\", ...args: unknown[]) {\n  return Operation(...[OperationVerbs.OPTIONS, path].concat(args));\n}\n"],"names":["All","path","args","Operation","OperationVerbs","Get","Post","Put","Delete","Head","Patch","Options"],"mappings":";;AAkBgB,SAAAA,EAAIC,IAAkC,QAAQC,GAAiB;AACtE,SAAAC,EAAU,GAAG,CAACC,EAAe,KAAKH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC7D;AAiBgB,SAAAG,EAAIJ,IAAkC,QAAQC,GAAiB;AACtE,SAAAC,EAAU,GAAG,CAACC,EAAe,KAAKH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC7D;AAiBgB,SAAAI,EAAKL,IAAkC,QAAQC,GAAiB;AACvE,SAAAC,EAAU,GAAG,CAACC,EAAe,MAAMH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC9D;AAiBgB,SAAAK,EAAIN,IAAkC,QAAQC,GAAiB;AACtE,SAAAC,EAAU,GAAG,CAACC,EAAe,KAAKH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC7D;AAiBgB,SAAAM,EAAOP,IAAkC,QAAQC,GAAiB;AACzE,SAAAC,EAAU,GAAG,CAACC,EAAe,QAAQH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAChE;AAiBgB,SAAAO,EAAKR,IAAkC,QAAQC,GAAiB;AACvE,SAAAC,EAAU,GAAG,CAACC,EAAe,MAAMH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC9D;AAiBgB,SAAAQ,EAAMT,IAA8B,QAAQC,GAAa;AAChE,SAAAC,EAAU,GAAG,CAACC,EAAe,OAAOH,CAAI,EAAE,OAAOC,CAAI,CAAC;AAC/D;AAiBgB,SAAAS,EAAQV,IAAkC,QAAQC,GAAiB;AAC1E,SAAAC,EAAU,GAAG,CAACC,EAAe,SAASH,CAAI,EAAE,OAAOC,CAAI,CAAC;AACjE;"}

package/lib/browser/decorators/operations/security.js

@@ -1,20 +0,0 @@
-import { UnsupportedDecoratorType as d, DecoratorTypes as a, decorateMethodsOf as i } from "@tsed/core";
-import { JsonEntityFn as f } from "../common/jsonEntityFn.js";
-function t(o, ...p) {
-  return f((r, e) => {
-    switch (r.decoratorType) {
-      case a.METHOD:
-        Array.isArray(o) ? r.operation.security(o) : r.operation.addSecurityScopes(o, p);
-        break;
-      case a.CLASS:
-        Array.isArray(o) ? i(e[0], t(o)) : i(e[0], t(o, ...p));
-        break;
-      default:
-        throw new d(t, e);
-    }
-  });
-}
-export {
-  t as Security
-};
-//# sourceMappingURL=security.js.map

package/lib/browser/decorators/operations/security.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"security.js","sources":["../../../../src/decorators/operations/security.ts"],"sourcesContent":["import {decorateMethodsOf, DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {OpenSpecSecurity} from \"@tsed/openspec\";\n\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\n\n/**\n * Add security metadata on the decorated method.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * @Controller(\"/\")\n * class ModelCtrl {\n *    @Security(\"write:calendars\")\n *    async method() {}\n * }\n * ```\n *\n * @param name\n * @param scopes\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Security(name: string, ...scopes: string[]): ClassDecorator & MethodDecorator;\n/**\n * Add security metadata on the decorated method.\n *\n * You can use it to add multiple authentication types.\n * See <https://swagger.io/docs/specification/authentication/#multiple>.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * @Controller(\"/\")\n * class ModelCtrl {\n *    @Security([{ \"A\": [\"scope-1\"] }, { \"B\": [], \"C\": [\"scope-2\", \"scope-3\"]}])\n *    async method() {}\n * }\n * ```\n * this will add the following security metadata\n * ```yaml\n * security: # A OR (B AND C)\n *   - A: [\"scope-1\"]\n *   - B: []\n *     C: [\"scope-2\", \"scope-3\"]\n * ```\n *\n * @param security\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Security(security: OpenSpecSecurity): ClassDecorator & MethodDecorator;\nexport function Security(nameOrSecurity: string | OpenSpecSecurity, ...scopes: string[]): ClassDecorator & MethodDecorator {\n  return JsonEntityFn((store, args) => {\n    switch (store.decoratorType) {\n      case DecoratorTypes.METHOD:\n        if (Array.isArray(nameOrSecurity)) {\n          store.operation!.security(nameOrSecurity);\n        } else {\n          store.operation!.addSecurityScopes(nameOrSecurity, scopes);\n        }\n        break;\n      case DecoratorTypes.CLASS:\n        if (Array.isArray(nameOrSecurity)) {\n          decorateMethodsOf(args[0], Security(nameOrSecurity));\n        } else {\n          decorateMethodsOf(args[0], Security(nameOrSecurity, ...scopes));\n        }\n        break;\n\n      default:\n        throw new UnsupportedDecoratorType(Security, args);\n    }\n  });\n}\n"],"names":["Security","nameOrSecurity","scopes","JsonEntityFn","store","args","DecoratorTypes","decorateMethodsOf","UnsupportedDecoratorType"],"mappings":";;AA4DgB,SAAAA,EAASC,MAA8CC,GAAoD;AAClH,SAAAC,EAAa,CAACC,GAAOC,MAAS;AACnC,YAAQD,EAAM,eAAe;AAAA,MAC3B,KAAKE,EAAe;AACd,QAAA,MAAM,QAAQL,CAAc,IACxBG,EAAA,UAAW,SAASH,CAAc,IAElCG,EAAA,UAAW,kBAAkBH,GAAgBC,CAAM;AAE3D;AAAA,MACF,KAAKI,EAAe;AACd,QAAA,MAAM,QAAQL,CAAc,IAC9BM,EAAkBF,EAAK,CAAC,GAAGL,EAASC,CAAc,CAAC,IAEnDM,EAAkBF,EAAK,CAAC,GAAGL,EAASC,GAAgB,GAAGC,CAAM,CAAC;AAEhE;AAAA,MAEF;AACQ,cAAA,IAAIM,EAAyBR,GAAUK,CAAI;AAAA,IAAA;AAAA,EACrD,CACD;AACH;"}

package/lib/browser/decorators/operations/status.js

@@ -1,8 +0,0 @@
-import { Returns as n } from "./returns.js";
-function u(t, r) {
-  return n(t, r);
-}
-export {
-  u as Status
-};
-//# sourceMappingURL=status.js.map

package/lib/browser/decorators/operations/status.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"status.js","sources":["../../../../src/decorators/operations/status.ts"],"sourcesContent":["import {Type} from \"@tsed/core\";\n\nimport {Returns, ReturnsChainedDecorators} from \"./returns.js\";\n\n/**\n * Add responses documentation for a specific status code.\n *\n * ## Usage\n *\n * Ts.ED v6 API introducing the chaining decorator concept.\n * Now a decorator like Returns can be used with another decorators like Description.\n *\n * ```typescript\n * import {Returns} from \"@tsed/schema\";\n *\n * @Controller(\"/\")\n * class MyController {\n *   @Status(404, String).Description(\"Not Found\")\n *   @Status(200, Model).Description(\"Success\")\n *   async myMethod(): Promise<Model> {}\n * }\n * ```\n *\n * ::: tip\n * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know\n * what chained decorators are available under Returns decorator.\n * :::\n *\n * This example will produce this documentation in swagger:\n *\n * ```json\n * {\n *   \"responses\": {\n *     \"404\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"type\": \"string\"}\n *     },\n *     \"2OO\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"$ref\": \"...\"}\n *     }\n *   }\n * }\n * ```\n *\n * ### Declaring a generic model\n *\n * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to\n * declare explicitly the generic models with the decorators.\n *\n * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.\n *\n * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:\n *\n * ```typescript\n * @Generics(\"T\")\n * class Pagination<T> {\n *  @CollectionOf(\"T\")\n *  data: T[];\n *\n *  @Property()\n *  totalCount: number;\n * }\n * ```\n *\n * Now, we need a model to be used with the generic Pagination model:\n *\n * ```typescript\n * class Product {\n *  @Property()\n *  id: string;\n *\n *  @Property()\n *  title: string;\n * }\n * ```\n *\n * Finally, we can use our models on a method as following:\n *\n * ```typescript\n * class Controller {\n *   @OperationPath(\"POST\", \"/\")\n *   @Status(200, Pagination).Of(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Product> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * ### Declaring a nested generics models <Badge text=\"6+\"/>\n *\n * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:\n *\n * ```typescript\n * import {Post, Generics, Property, Returns} from \"@tsed/schema\";\n *\n * class Controller {\n *   @Post(\"/\")\n *   @Status(200, Pagination).Of(Submission).Nested(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Submission<Product>> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * And here is the Submission model:\n *\n * ```typescript\n * import {Generics, Property} from \"@tsed/schema\";\n *\n * @Generics(\"T\")\n * class Submission<T> {\n *   @Property()\n *   _id: string;\n *   @Property(\"T\")\n *   data: T;\n * }\n * ```\n *\n * @param status\n * @param model\n * @decorator\n * @swagger\n * @schema\n * @response\n * @operation\n */\nexport function Status(status: string | number, model?: Type<any> | any): ReturnsChainedDecorators {\n  return Returns(status, model);\n}\n"],"names":["Status","status","model","Returns"],"mappings":";AA+HgB,SAAAA,EAAOC,GAAyBC,GAAmD;AAC1F,SAAAC,EAAQF,GAAQC,CAAK;AAC9B;"}

package/lib/browser/decorators/operations/subscribe.js

@@ -1,9 +0,0 @@
-import { OperationVerbs as o } from "../../constants/OperationVerbs.js";
-import { Operation as t } from "./operation.js";
-function n(r) {
-  return t(o.SUBSCRIBE, r);
-}
-export {
-  n as Subscribe
-};
-//# sourceMappingURL=subscribe.js.map

package/lib/browser/decorators/operations/subscribe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"subscribe.js","sources":["../../../../src/decorators/operations/subscribe.ts"],"sourcesContent":["import {OperationVerbs} from \"../../constants/OperationVerbs.js\";\nimport {Operation} from \"./operation.js\";\n\nexport function Subscribe(event: string) {\n  return Operation(OperationVerbs.SUBSCRIBE, event);\n}\n"],"names":["Subscribe","event","Operation","OperationVerbs"],"mappings":";;AAGO,SAASA,EAAUC,GAAe;AAChC,SAAAC,EAAUC,EAAe,WAAWF,CAAK;AAClD;"}

package/lib/browser/decorators/operations/summary.js

@@ -1,13 +0,0 @@
-import { DecoratorTypes as e, UnsupportedDecoratorType as n } from "@tsed/core";
-import { JsonEntityFn as p } from "../common/jsonEntityFn.js";
-function m(o) {
-  return p((r, t) => {
-    if (r.decoratorType !== e.METHOD)
-      throw new n(m, t);
-    r.operation.summary(o);
-  });
-}
-export {
-  m as Summary
-};
-//# sourceMappingURL=summary.js.map

package/lib/browser/decorators/operations/summary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"summary.js","sources":["../../../../src/decorators/operations/summary.ts"],"sourcesContent":["import {DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\n\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\n\n/**\n * Add summary metadata on the decorated element.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * class Model {\n *    @Summary(\"summary\")\n *    id: string;\n * }\n * ```\n *\n * @param summary\n * @decorator\n * @swagger\n * @schema\n * @operation\n */\nexport function Summary(summary: string): MethodDecorator {\n  return JsonEntityFn((store, args) => {\n    if (store.decoratorType !== DecoratorTypes.METHOD) {\n      throw new UnsupportedDecoratorType(Summary, args);\n    }\n\n    store.operation!.summary(summary);\n  });\n}\n"],"names":["Summary","summary","JsonEntityFn","store","args","DecoratorTypes","UnsupportedDecoratorType"],"mappings":";;AAuBO,SAASA,EAAQC,GAAkC;AACjD,SAAAC,EAAa,CAACC,GAAOC,MAAS;AAC/B,QAAAD,EAAM,kBAAkBE,EAAe;AACnC,YAAA,IAAIC,EAAyBN,GAASI,CAAI;AAG5C,IAAAD,EAAA,UAAW,QAAQF,CAAO;AAAA,EAAA,CACjC;AACH;"}

package/lib/browser/decorators/operations/tags.js

@@ -1,25 +0,0 @@
-import { UnsupportedDecoratorType as a, DecoratorTypes as t, decorateMethodsOf as p } from "@tsed/core";
-import { JsonEntityFn as c } from "../common/jsonEntityFn.js";
-function i(e) {
-  return e.map((r) => typeof r == "string" ? {
-    name: r
-  } : r);
-}
-function n(...e) {
-  return c((r, o) => {
-    switch (r.decoratorType) {
-      case t.METHOD:
-        r.operation.addTags(i(e));
-        break;
-      case t.CLASS:
-        p(o[0], n(...e));
-        break;
-      default:
-        throw new a(n, o);
-    }
-  });
-}
-export {
-  n as Tags
-};
-//# sourceMappingURL=tags.js.map

package/lib/browser/decorators/operations/tags.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tags.js","sources":["../../../../src/decorators/operations/tags.ts"],"sourcesContent":["import {decorateMethodsOf, DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {OpenSpecTag} from \"@tsed/openspec\";\n\nimport {JsonEntityFn} from \"../common/jsonEntityFn.js\";\n\nfunction mapTags(tags: (string | OpenSpecTag)[]) {\n  return tags.map((tag) => {\n    if (typeof tag === \"string\") {\n      return {\n        name: tag\n      };\n    }\n\n    return tag;\n  });\n}\n\n/**\n * Add metadata tags to the decorated element (class or method).\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * @Controller(\"/\")\n * class MyController {\n *  @Tags(\"api\")\n *  get() {}\n * }\n * ```\n * ### On Class\n *\n * ```typescript\n * @Controller(\"/\")\n * @Tags(\"api\")\n * class MyController {\n *  get() {}\n * }\n * ```\n *\n * @param tags\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Tags(...tags: (string | OpenSpecTag)[]): ClassDecorator & MethodDecorator {\n  return JsonEntityFn((store, args) => {\n    switch (store.decoratorType) {\n      case DecoratorTypes.METHOD:\n        store.operation!.addTags(mapTags(tags));\n        break;\n      case DecoratorTypes.CLASS:\n        decorateMethodsOf(args[0], Tags(...tags));\n        break;\n\n      default:\n        throw new UnsupportedDecoratorType(Tags, args);\n    }\n  });\n}\n"],"names":["mapTags","tags","tag","Tags","JsonEntityFn","store","args","DecoratorTypes","decorateMethodsOf","UnsupportedDecoratorType"],"mappings":";;AAKA,SAASA,EAAQC,GAAgC;AACxC,SAAAA,EAAK,IAAI,CAACC,MACX,OAAOA,KAAQ,WACV;AAAA,IACL,MAAMA;AAAA,EACR,IAGKA,CACR;AACH;AAgCO,SAASC,KAAQF,GAAkE;AACjF,SAAAG,EAAa,CAACC,GAAOC,MAAS;AACnC,YAAQD,EAAM,eAAe;AAAA,MAC3B,KAAKE,EAAe;AAClB,QAAAF,EAAM,UAAW,QAAQL,EAAQC,CAAI,CAAC;AACtC;AAAA,MACF,KAAKM,EAAe;AAClB,QAAAC,EAAkBF,EAAK,CAAC,GAAGH,EAAK,GAAGF,CAAI,CAAC;AACxC;AAAA,MAEF;AACQ,cAAA,IAAIQ,EAAyBN,GAAMG,CAAI;AAAA,IAAA;AAAA,EACjD,CACD;AACH;"}

package/lib/browser/decorators/operations/view.js

@@ -1,8 +0,0 @@
-import { StoreSet as t } from "@tsed/core";
-function i(e, r) {
-  return t("view", { path: e, options: r });
-}
-export {
-  i as View
-};
-//# sourceMappingURL=view.js.map

package/lib/browser/decorators/operations/view.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"view.js","sources":["../../../../src/decorators/operations/view.ts"],"sourcesContent":["import {StoreSet} from \"@tsed/core\";\n\n/**\n * Use a view and sends the rendered HTML string to the client. Optional parameter:\n *\n * * viewOptions, an object whose properties define local variables for the view.\n *\n * The view argument is a string that is the file path of the view file to render.\n * This can be an absolute path, or a path relative to the views setting.\n * If the path does not contain a file extension, then the view engine setting determines the file extension.\n * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())\n * and render it using the loaded module’s __express function.\n *\n * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).\n *\n * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,\n * and as so for security reasons should not contain input from the end-user.\n *\n * @param path Relative path to the view file.\n * @param options Additional options\n * @decorator\n * @operation\n * @response\n */\nexport function View(path: string, options?: Object): MethodDecorator {\n  return StoreSet(\"view\", {path, options}) as any;\n}\n"],"names":["View","path","options","StoreSet"],"mappings":";AAwBgB,SAAAA,EAAKC,GAAcC,GAAmC;AACpE,SAAOC,EAAS,QAAQ,EAAC,MAAAF,GAAM,SAAAC,GAAQ;AACzC;"}

package/lib/browser/domain/DecoratorContext.js

@@ -1,62 +0,0 @@
-import { DecoratorTypes as o } from "@tsed/core";
-import { pascalCase as n } from "/home/runner/work/tsed/tsed/node_modules/change-case/dist/index.js";
-import { JsonEntityStore as h } from "./JsonEntityStore.js";
-class u extends Map {
-  constructor(t = {}) {
-    super(), this.actions = [], Object.entries(t).forEach(([r, i]) => {
-      this.set(r, i);
-    });
-  }
-  addAction(t) {
-    return this.actions.push(t), this;
-  }
-  build() {
-    const t = (...e) => this.bind(e, t), r = (e) => (...s) => (e(...s), t), i = (e) => r((...s) => {
-      e in this ? this[e](...s) : this.set(e, s[0]);
-    });
-    return this.methods.forEach((e) => {
-      t[n(e)] = i(e);
-    }), t;
-  }
-  toObject() {
-    return [...this.entries()].reduce((t, [r, i]) => ({
-      ...t,
-      [r]: i
-    }), {});
-  }
-  getMergedKey(t, r) {
-    let i = this.get(t) || r;
-    if (i)
-      return this.decoratorType === o.CLASS && (i = {
-        ...i,
-        ...r || {}
-      }), {
-        ...r || {},
-        ...i
-      };
-  }
-  bind(t, r) {
-    this.entity = h.from(...t), this.beforeInit(), this.onInit(t, r), this.afterInit();
-  }
-  onInit(t, r) {
-    this.forEach((i, e) => {
-      this.onMapKey(e, i);
-    });
-  }
-  onMapKey(t, r) {
-    this.entity.set(t, r);
-  }
-  runActions() {
-    return this.actions.forEach((t) => {
-      t(this);
-    }), this;
-  }
-  beforeInit() {
-  }
-  afterInit() {
-  }
-}
-export {
-  u as DecoratorContext
-};
-//# sourceMappingURL=DecoratorContext.js.map

package/lib/browser/domain/DecoratorContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecoratorContext.js","sources":["../../../src/domain/DecoratorContext.ts"],"sourcesContent":["import {DecoratorParameters, DecoratorTypes} from \"@tsed/core\";\nimport {pascalCase} from \"change-case\";\n\nimport {JsonEntityStore} from \"./JsonEntityStore.js\";\n\n/**\n * @ignore\n */\nexport interface DecoratorActionHandler {\n  (ctx: Map<string, any>): void;\n}\n\n/**\n * @ignore\n */\nexport abstract class DecoratorContext<T = any> extends Map<string, any> {\n  readonly methods: string[];\n  protected decoratorType: DecoratorTypes;\n  protected entity: JsonEntityStore;\n  protected actions: DecoratorActionHandler[] = [];\n\n  constructor(opts: any = {}) {\n    super();\n\n    Object.entries(opts).forEach(([key, value]) => {\n      this.set(key, value);\n    });\n  }\n\n  addAction(cb: DecoratorActionHandler) {\n    this.actions.push(cb);\n    return this;\n  }\n\n  build(): T {\n    const decorator: any = (...args: DecoratorParameters) => this.bind(args, decorator);\n\n    const wrap = (cb: any) => {\n      return (...args: any[]) => {\n        cb(...args);\n        return decorator;\n      };\n    };\n\n    const wrapKey = (key: string) => {\n      return wrap((...values: any[]) => {\n        key in this ? (this as any)[key](...values) : this.set(key, values[0]);\n      });\n    };\n\n    this.methods.forEach((name) => {\n      decorator[pascalCase(name)] = wrapKey(name);\n    });\n\n    return decorator as unknown as T;\n  }\n\n  toObject(): any {\n    return [...this.entries()].reduce((obj, [key, value]) => {\n      return {\n        ...obj,\n        [key]: value\n      };\n    }, {});\n  }\n\n  getMergedKey(key: string, defaultValue: any) {\n    let value = this.get(key) || defaultValue;\n\n    if (!value) {\n      return;\n    }\n\n    if (this.decoratorType === DecoratorTypes.CLASS) {\n      value = {\n        ...value,\n        ...(defaultValue || {})\n      };\n    }\n\n    return {\n      ...(defaultValue || {}),\n      ...value\n    };\n  }\n\n  protected bind(args: DecoratorParameters, decorator: any) {\n    this.entity = JsonEntityStore.from(...args);\n\n    this.beforeInit();\n    this.onInit(args, decorator);\n    this.afterInit();\n  }\n\n  protected onInit(args: DecoratorParameters, decorator: any): void {\n    this.forEach((value, key) => {\n      this.onMapKey(key, value);\n    });\n  }\n\n  protected onMapKey(key: string, value: any): void {\n    this.entity.set(key, value);\n  }\n\n  protected runActions() {\n    this.actions.forEach((action: any) => {\n      action(this);\n    });\n\n    return this;\n  }\n\n  protected beforeInit() {}\n\n  protected afterInit() {}\n}\n"],"names":["DecoratorContext","opts","key","value","cb","decorator","args","wrap","wrapKey","values","name","pascalCase","obj","defaultValue","DecoratorTypes","JsonEntityStore","action"],"mappings":";;;AAeO,MAAeA,UAAkC,IAAiB;AAAA,EAMvE,YAAYC,IAAY,IAAI;AACpB,UAAA,GAHR,KAAU,UAAoC,CAAC,GAKtC,OAAA,QAAQA,CAAI,EAAE,QAAQ,CAAC,CAACC,GAAKC,CAAK,MAAM;AACxC,WAAA,IAAID,GAAKC,CAAK;AAAA,IAAA,CACpB;AAAA,EAAA;AAAA,EAGH,UAAUC,GAA4B;AAC/B,gBAAA,QAAQ,KAAKA,CAAE,GACb;AAAA,EAAA;AAAA,EAGT,QAAW;AACT,UAAMC,IAAiB,IAAIC,MAA8B,KAAK,KAAKA,GAAMD,CAAS,GAE5EE,IAAO,CAACH,MACL,IAAIE,OACTF,EAAG,GAAGE,CAAI,GACHD,IAILG,IAAU,CAACN,MACRK,EAAK,IAAIE,MAAkB;AAChC,MAAAP,KAAO,OAAQ,KAAaA,CAAG,EAAE,GAAGO,CAAM,IAAI,KAAK,IAAIP,GAAKO,EAAO,CAAC,CAAC;AAAA,IAAA,CACtE;AAGE,gBAAA,QAAQ,QAAQ,CAACC,MAAS;AAC7B,MAAAL,EAAUM,EAAWD,CAAI,CAAC,IAAIF,EAAQE,CAAI;AAAA,IAAA,CAC3C,GAEML;AAAA,EAAA;AAAA,EAGT,WAAgB;AACd,WAAO,CAAC,GAAG,KAAK,SAAS,EAAE,OAAO,CAACO,GAAK,CAACV,GAAKC,CAAK,OAC1C;AAAA,MACL,GAAGS;AAAA,MACH,CAACV,CAAG,GAAGC;AAAA,IACT,IACC,EAAE;AAAA,EAAA;AAAA,EAGP,aAAaD,GAAaW,GAAmB;AAC3C,QAAIV,IAAQ,KAAK,IAAID,CAAG,KAAKW;AAE7B,QAAKV;AAID,aAAA,KAAK,kBAAkBW,EAAe,UAChCX,IAAA;AAAA,QACN,GAAGA;AAAA,QACH,GAAIU,KAAgB,CAAA;AAAA,MACtB,IAGK;AAAA,QACL,GAAIA,KAAgB,CAAC;AAAA,QACrB,GAAGV;AAAA,MACL;AAAA,EAAA;AAAA,EAGQ,KAAKG,GAA2BD,GAAgB;AACxD,SAAK,SAASU,EAAgB,KAAK,GAAGT,CAAI,GAE1C,KAAK,WAAW,GACX,KAAA,OAAOA,GAAMD,CAAS,GAC3B,KAAK,UAAU;AAAA,EAAA;AAAA,EAGP,OAAOC,GAA2BD,GAAsB;AAC3D,SAAA,QAAQ,CAACF,GAAOD,MAAQ;AACtB,WAAA,SAASA,GAAKC,CAAK;AAAA,IAAA,CACzB;AAAA,EAAA;AAAA,EAGO,SAASD,GAAaC,GAAkB;AAC3C,SAAA,OAAO,IAAID,GAAKC,CAAK;AAAA,EAAA;AAAA,EAGlB,aAAa;AAChB,gBAAA,QAAQ,QAAQ,CAACa,MAAgB;AACpC,MAAAA,EAAO,IAAI;AAAA,IAAA,CACZ,GAEM;AAAA,EAAA;AAAA,EAGC,aAAa;AAAA,EAAA;AAAA,EAEb,YAAY;AAAA,EAAA;AACxB;"}

package/lib/browser/domain/JsonAliasMap.js

@@ -1,7 +0,0 @@
-function c(t, n) {
-  return Object.entries(t).reduce((r, [e, u]) => (e = n.get(e) || e, r[e] = u, r), {});
-}
-export {
-  c as mapAliasedProperties
-};
-//# sourceMappingURL=JsonAliasMap.js.map

package/lib/browser/domain/JsonAliasMap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JsonAliasMap.js","sources":["../../../src/domain/JsonAliasMap.ts"],"sourcesContent":["/**\n * @ignore\n */\nexport type AliasType = string | number | symbol;\n/**\n * @ignore\n */\nexport type AliasMap = Map<AliasType, AliasType>;\n/**\n * @ignore\n */\nexport function mapAliasedProperties(value: any, alias: AliasMap) {\n  return Object.entries(value).reduce<any>((properties, [key, value]) => {\n    key = (alias.get(key) as string) || key;\n    properties[key] = value;\n\n    return properties;\n  }, {});\n}\n"],"names":["mapAliasedProperties","value","alias","properties","key"],"mappings":"AAWgB,SAAAA,EAAqBC,GAAYC,GAAiB;AACzD,SAAA,OAAO,QAAQD,CAAK,EAAE,OAAY,CAACE,GAAY,CAACC,GAAKH,CAAK,OACxDG,IAAAF,EAAM,IAAIE,CAAG,KAAgBA,GACpCD,EAAWC,CAAG,IAAIH,GAEXE,IACN,EAAE;AACP;"}