@venok/core 1.1.0 → 2.0.1-next.1

package/dist/services/console.service.js

@@ -0,0 +1,347 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/services/console.service.ts
+import { inspect } from "util";
+import { colors, isColorAllowed, yellow } from "../helpers/color.helper.js";
+import { isFunction, isPlainObject, isString, isUndefined } from "../helpers/shared.helper.js";
+import { Injectable } from "../decorators/injectable.decorator.js";
+import { isLogLevelEnabled } from "../helpers/is-log-level-enabled.util.js";
+import { Optional } from "../decorators/optional.decorator.js";
+var DEFAULT_DEPTH = 5;
+var DEFAULT_LOG_LEVELS = ["log", "error", "warn", "debug", "verbose", "fatal"];
+var dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+
+class ConsoleLogger {
+  options;
+  context;
+  originalContext;
+  inspectOptions;
+  static lastTimestampAt;
+  constructor(contextOrOptions, options) {
+    let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [undefined, options] : [contextOrOptions?.context, contextOrOptions];
+    opts = opts ?? {};
+    opts.logLevels ??= DEFAULT_LOG_LEVELS;
+    opts.colors ??= opts.colors ?? (opts.json ? false : isColorAllowed());
+    opts.prefix ??= "Venok";
+    this.options = opts;
+    this.inspectOptions = this.getInspectOptions();
+    if (context) {
+      this.context = context;
+      this.originalContext = context;
+    }
+  }
+  log(message, ...optionalParams) {
+    if (!this.isLevelEnabled("log")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "log");
+  }
+  error(message, ...optionalParams) {
+    if (!this.isLevelEnabled("error")) {
+      return;
+    }
+    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "error", "stderr", stack);
+    this.printStackTrace(stack);
+  }
+  warn(message, ...optionalParams) {
+    if (!this.isLevelEnabled("warn")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "warn");
+  }
+  debug(message, ...optionalParams) {
+    if (!this.isLevelEnabled("debug")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "debug");
+  }
+  verbose(message, ...optionalParams) {
+    if (!this.isLevelEnabled("verbose")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "verbose");
+  }
+  fatal(message, ...optionalParams) {
+    if (!this.isLevelEnabled("fatal")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "fatal");
+  }
+  setLogLevels(levels) {
+    if (!this.options) {
+      this.options = {};
+    }
+    this.options.logLevels = levels;
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  resetContext() {
+    this.context = this.originalContext;
+  }
+  isLevelEnabled(level) {
+    const logLevels = this.options?.logLevels;
+    return isLogLevelEnabled(level, logLevels);
+  }
+  getTimestamp() {
+    return dateTimeFormatter.format(Date.now());
+  }
+  printMessages(messages, context = "", logLevel = "log", writeStreamType, errorStack) {
+    messages.forEach((message) => {
+      if (this.options.json) {
+        this.printAsJson(message, {
+          context,
+          logLevel,
+          writeStreamType,
+          errorStack
+        });
+        return;
+      }
+      const pidMessage = this.formatPid(process.pid);
+      const contextMessage = this.formatContext(context);
+      const timestampDiff = this.updateAndGetTimestampDiff();
+      const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
+      const formattedMessage = this.formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff);
+      if (this.options.forceConsole) {
+        if (writeStreamType === "stderr") {
+          console.error(formattedMessage.trim());
+        } else {
+          console.log(formattedMessage.trim());
+        }
+      } else {
+        process[writeStreamType ?? "stdout"].write(formattedMessage);
+      }
+    });
+  }
+  printAsJson(message, options) {
+    const logObject = this.getJsonLogObject(message, options);
+    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : inspect(logObject, this.inspectOptions);
+    if (this.options.forceConsole) {
+      if (options.writeStreamType === "stderr") {
+        console.error(formattedMessage);
+      } else {
+        console.log(formattedMessage);
+      }
+    } else {
+      process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
+`);
+    }
+  }
+  getJsonLogObject(message, options) {
+    const logObject = {
+      level: options.logLevel,
+      pid: process.pid,
+      timestamp: Date.now(),
+      message
+    };
+    if (options.context) {
+      logObject.context = options.context;
+    }
+    if (options.errorStack) {
+      logObject.stack = options.errorStack;
+    }
+    return logObject;
+  }
+  formatPid(pid) {
+    return `[${this.options.prefix}] ${pid}  - `;
+  }
+  formatContext(context) {
+    if (!context) {
+      return "";
+    }
+    context = `[${context}] `;
+    return this.options.colors ? yellow(context) : context;
+  }
+  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+    const output = this.stringifyMessage(message, logLevel);
+    pidMessage = this.colorize(pidMessage, logLevel);
+    formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
+    return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
+`;
+  }
+  stringifyMessage(message, logLevel) {
+    if (isFunction(message)) {
+      const messageAsStr = Function.prototype.toString.call(message);
+      const isClass = messageAsStr.startsWith("class ");
+      if (isClass) {
+        return this.stringifyMessage(message.name, logLevel);
+      }
+      return this.stringifyMessage(message(), logLevel);
+    }
+    if (typeof message === "string") {
+      return this.colorize(message, logLevel);
+    }
+    const outputText = inspect(message, this.inspectOptions);
+    if (isPlainObject(message)) {
+      return `Object(${Object.keys(message).length}) ${outputText}`;
+    }
+    if (Array.isArray(message)) {
+      return `Array(${message.length}) ${outputText}`;
+    }
+    return outputText;
+  }
+  colorize(message, logLevel) {
+    if (!this.options.colors || this.options.json) {
+      return message;
+    }
+    const color = this.getColorByLogLevel(logLevel);
+    return color(message);
+  }
+  printStackTrace(stack) {
+    if (!stack || this.options.json) {
+      return;
+    }
+    if (this.options.forceConsole) {
+      console.error(stack);
+    } else {
+      process.stderr.write(`${stack}
+`);
+    }
+  }
+  updateAndGetTimestampDiff() {
+    const includeTimestamp = ConsoleLogger.lastTimestampAt && this.options?.timestamp;
+    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - ConsoleLogger.lastTimestampAt) : "";
+    ConsoleLogger.lastTimestampAt = Date.now();
+    return result;
+  }
+  formatTimestampDiff(timestampDiff) {
+    const formattedDiff = ` +${timestampDiff}ms`;
+    return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+  }
+  getInspectOptions() {
+    let breakLength = this.options.breakLength;
+    if (typeof breakLength === "undefined") {
+      breakLength = this.options.colors ? this.options.compact ? Infinity : undefined : this.options.compact === false ? undefined : Infinity;
+    }
+    const inspectOptions = {
+      depth: this.options.depth ?? DEFAULT_DEPTH,
+      sorted: this.options.sorted,
+      showHidden: this.options.showHidden,
+      compact: this.options.compact ?? (this.options.json ? true : false),
+      colors: this.options.colors,
+      breakLength
+    };
+    if (this.options.maxArrayLength) {
+      inspectOptions.maxArrayLength = this.options.maxArrayLength;
+    }
+    if (this.options.maxStringLength) {
+      inspectOptions.maxStringLength = this.options.maxStringLength;
+    }
+    return inspectOptions;
+  }
+  stringifyReplacer(key, value) {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value instanceof Map || value instanceof Set || value instanceof Error) {
+      return `${inspect(value, this.inspectOptions)}`;
+    }
+    return value;
+  }
+  getContextAndMessagesToPrint(args) {
+    if (args?.length <= 1) {
+      return { messages: args, context: this.context };
+    }
+    const lastElement = args[args.length - 1];
+    const isContext = isString(lastElement);
+    if (!isContext) {
+      return { messages: args, context: this.context };
+    }
+    return {
+      context: lastElement,
+      messages: args.slice(0, args.length - 1)
+    };
+  }
+  getContextAndStackAndMessagesToPrint(args) {
+    if (args.length === 2) {
+      return this.isStackFormat(args[1]) ? {
+        messages: [args[0]],
+        stack: args[1],
+        context: this.context
+      } : {
+        messages: [args[0]],
+        context: args[1]
+      };
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint(args);
+    if (messages?.length <= 1) {
+      return { messages, context };
+    }
+    const lastElement = messages[messages.length - 1];
+    const isStack = isString(lastElement);
+    if (!isStack && !isUndefined(lastElement)) {
+      return { messages, context };
+    }
+    return {
+      stack: lastElement,
+      messages: messages.slice(0, messages.length - 1),
+      context
+    };
+  }
+  isStackFormat(stack) {
+    if (!isString(stack) && !isUndefined(stack)) {
+      return false;
+    }
+    return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+  }
+  getColorByLogLevel(level) {
+    switch (level) {
+      case "debug":
+        return colors.magentaBright;
+      case "warn":
+        return colors.yellow;
+      case "error":
+        return colors.red;
+      case "verbose":
+        return colors.cyanBright;
+      case "fatal":
+        return colors.bold;
+      default:
+        return colors.green;
+    }
+  }
+}
+ConsoleLogger = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Optional()),
+  __legacyDecorateParamTS(1, Optional()),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    typeof ConsoleLoggerOptions === "undefined" ? Object : ConsoleLoggerOptions
+  ])
+], ConsoleLogger);
+export {
+  ConsoleLogger
+};

package/dist/services/logger.service.js

@@ -0,0 +1,276 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/services/logger.service.ts
+import { ConsoleLogger } from "../services/console.service.js";
+import { Injectable } from "../decorators/injectable.decorator.js";
+import { isLogLevelEnabled } from "../helpers/is-log-level-enabled.util.js";
+import { isObject } from "../helpers/shared.helper.js";
+var LOG_LEVELS = ["verbose", "debug", "log", "warn", "error", "fatal"];
+var DEFAULT_LOGGER = new ConsoleLogger;
+var dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+
+class Logger {
+  context;
+  options;
+  static logBuffer = new Array;
+  static staticInstanceRef = DEFAULT_LOGGER;
+  static logLevels;
+  static isBufferAttached;
+  localInstanceRef;
+  static WrapBuffer = (target, propertyKey, descriptor) => {
+    const originalFn = descriptor.value;
+    descriptor.value = function(...args) {
+      if (Logger.isBufferAttached) {
+        Logger.logBuffer.push({
+          methodRef: originalFn.bind(this),
+          arguments: args
+        });
+        return;
+      }
+      return originalFn.call(this, ...args);
+    };
+  };
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
+  }
+  get localInstance() {
+    if (Logger.staticInstanceRef === DEFAULT_LOGGER) {
+      return this.registerLocalInstanceRef();
+    } else if (Logger.staticInstanceRef instanceof Logger) {
+      const prototype = Object.getPrototypeOf(Logger.staticInstanceRef);
+      if (prototype.constructor === Logger) {
+        return this.registerLocalInstanceRef();
+      }
+    }
+    return Logger.staticInstanceRef;
+  }
+  error(message, ...optionalParams) {
+    optionalParams = this.context ? (optionalParams.length ? optionalParams : [undefined]).concat(this.context) : optionalParams;
+    this.localInstance?.error(message, ...optionalParams);
+  }
+  log(message, ...optionalParams) {
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    this.localInstance?.log(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    this.localInstance?.warn(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    this.localInstance?.debug?.(message, ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    this.localInstance?.verbose?.(message, ...optionalParams);
+  }
+  fatal(message, ...optionalParams) {
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    this.localInstance?.fatal?.(message, ...optionalParams);
+  }
+  static error(message, ...optionalParams) {
+    this.staticInstanceRef?.error(message, ...optionalParams);
+  }
+  static log(message, ...optionalParams) {
+    this.staticInstanceRef?.log(message, ...optionalParams);
+  }
+  static warn(message, ...optionalParams) {
+    this.staticInstanceRef?.warn(message, ...optionalParams);
+  }
+  static debug(message, ...optionalParams) {
+    this.staticInstanceRef?.debug?.(message, ...optionalParams);
+  }
+  static verbose(message, ...optionalParams) {
+    this.staticInstanceRef?.verbose?.(message, ...optionalParams);
+  }
+  static fatal(message, ...optionalParams) {
+    this.staticInstanceRef?.fatal?.(message, ...optionalParams);
+  }
+  static flush() {
+    this.isBufferAttached = false;
+    this.logBuffer.forEach((item) => item.methodRef(...item.arguments));
+    this.logBuffer = [];
+  }
+  static attachBuffer() {
+    this.isBufferAttached = true;
+  }
+  static detachBuffer() {
+    this.isBufferAttached = false;
+  }
+  static getTimestamp() {
+    return dateTimeFormatter.format(Date.now());
+  }
+  static overrideLogger(logger) {
+    if (Array.isArray(logger)) {
+      Logger.logLevels = logger;
+      return this.staticInstanceRef?.setLogLevels?.(logger);
+    }
+    if (isObject(logger)) {
+      if (logger instanceof Logger && logger.constructor !== Logger) {
+        const errorMessage = `Using the "extends Logger" instruction is not allowed in Nest v9. Please, use "extends ConsoleLogger" instead.`;
+        this.staticInstanceRef?.error(errorMessage);
+        throw new Error(errorMessage);
+      }
+      this.staticInstanceRef = logger;
+    } else {
+      this.staticInstanceRef = undefined;
+    }
+  }
+  static isLevelEnabled(level) {
+    const logLevels = Logger.logLevels;
+    return isLogLevelEnabled(level, logLevels);
+  }
+  registerLocalInstanceRef() {
+    if (this.localInstanceRef) {
+      return this.localInstanceRef;
+    }
+    this.localInstanceRef = new ConsoleLogger(this.context, {
+      timestamp: this.options?.timestamp,
+      logLevels: Logger.logLevels
+    });
+    return this.localInstanceRef;
+  }
+}
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "error", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "log", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "warn", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "debug", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "verbose", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger.prototype, "fatal", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "error", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "log", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "warn", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "debug", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "verbose", null);
+__legacyDecorateClassTS([
+  Logger.WrapBuffer,
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    Object,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", undefined)
+], Logger, "fatal", null);
+Logger = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    String,
+    Object
+  ])
+], Logger);
+export {
+  Logger,
+  LOG_LEVELS
+};

package/dist/services/reflector.service.js

@@ -0,0 +1,82 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/services/reflector.service.ts
+import { uid } from "uid";
+import { SetMetadata } from "../decorators/set-metadata.decorator.js";
+import { isEmpty, isObject } from "../helpers/shared.helper.js";
+
+class Reflector {
+  static reflector = new Reflector;
+  static createDecorator(options = {}) {
+    const metadataKey = options.key ?? uid(21);
+    const decoratorFn = (metadataValue) => (target, key, descriptor) => {
+      const value = options.transform ? options.transform(metadataValue) : metadataValue;
+      SetMetadata(metadataKey, value ?? undefined, options.type)(target, key, descriptor);
+    };
+    decoratorFn.KEY = metadataKey;
+    return decoratorFn;
+  }
+  static createMetadataDecorator(options) {
+    const metadataKey = options.key ?? uid(21);
+    const decoratorFn = (metadataValue) => (target, key, descriptor) => {
+      const value = options.transform(metadataValue);
+      for (const [additionalKey, additionalValue] of Object.entries(value)) {
+        SetMetadata(additionalKey, additionalValue ?? undefined, options.type)(target, key, descriptor);
+      }
+      SetMetadata(metadataKey, true, options.type)(target, key, descriptor);
+    };
+    decoratorFn.KEY = metadataKey;
+    return decoratorFn;
+  }
+  constructor() {}
+  has(metadataKeyOrDecorator, target) {
+    const metadataKey = metadataKeyOrDecorator.KEY ?? metadataKeyOrDecorator;
+    return Reflect.hasMetadata(metadataKey, target);
+  }
+  get(metadataKeyOrDecorator, target) {
+    const metadataKey = metadataKeyOrDecorator.KEY ?? metadataKeyOrDecorator;
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getAll(metadataKeyOrDecorator, targets) {
+    return (targets || []).map((target) => this.get(metadataKeyOrDecorator, target));
+  }
+  getAllAndMerge(metadataKeyOrDecorator, targets) {
+    const metadataCollection = this.getAll(metadataKeyOrDecorator, targets).filter(Boolean);
+    if (isEmpty(metadataCollection))
+      return metadataCollection;
+    return metadataCollection.reduce((a, b) => {
+      if (Array.isArray(a))
+        return a.concat(b);
+      if (isObject(a) && isObject(b))
+        return { ...a, ...b };
+      return [a, b];
+    });
+  }
+  getAllAndOverride(metadataKeyOrDecorator, targets) {
+    for (const target of targets) {
+      const result = this.get(metadataKeyOrDecorator, target);
+      if (result !== undefined)
+        return result;
+    }
+    return;
+  }
+}
+export {
+  Reflector
+};