@nattyjs/core 0.0.1-beta.0

package/dist/index.mjs

@@ -0,0 +1,1233 @@
+import { commonContainer, isObject, List, BLANK as BLANK$1, RIGHT_SLASH } from '@nattyjs/common';
+import { container, injectable as injectable$1 } from 'tsyringe';
+import { match } from 'path-to-regexp';
+
+function defineNattyConfig(config) {
+  return config;
+}
+
+var RunOn = /* @__PURE__ */ ((RunOn2) => {
+  RunOn2[RunOn2["AzureFunction"] = 0] = "AzureFunction";
+  RunOn2[RunOn2["ExpressJs"] = 1] = "ExpressJs";
+  RunOn2[RunOn2["Koa"] = 2] = "Koa";
+  RunOn2[RunOn2["FastifyJs"] = 3] = "FastifyJs";
+  RunOn2[RunOn2["GoogleFunction"] = 4] = "GoogleFunction";
+  RunOn2[RunOn2["Lambda"] = 5] = "Lambda";
+  return RunOn2;
+})(RunOn || {});
+
+function route(path) {
+  return function(target, propertyKey, parameterIndex) {
+    return target;
+  };
+}
+
+const CONTROLLER = "controller";
+const INVALID_VALUE = "INVALID_VALUE";
+const BLANK = "";
+
+function get(path) {
+  return function(target, propertyKey, descriptor) {
+  };
+}
+
+function post(path) {
+  return function(target, propertyKey, descriptor) {
+  };
+}
+
+function put(path) {
+  return function(target, propertyKey, descriptor) {
+  };
+}
+
+function Delete() {
+  return function(target, propertyKey, descriptor) {
+  };
+}
+
+const _StaticContainer = class {
+  setup(types) {
+    _StaticContainer.types = types;
+  }
+};
+let StaticContainer = _StaticContainer;
+StaticContainer.types = void 0;
+const nattyContainer = new class {
+  constructor() {
+    this.container = /* @__PURE__ */ new Map();
+    this.containerState = /* @__PURE__ */ new Map();
+  }
+  setup(config, routes, types) {
+    this.config = config;
+    this.routes = routes;
+    this.types = types;
+  }
+  getTypes() {
+    return StaticContainer.types;
+  }
+  getControllerInfo(target) {
+    return this.container.get(target);
+  }
+  getOrCreateControllerInfo(target) {
+    let controllerInfo = this.getControllerInfo(target);
+    if (!controllerInfo)
+      controllerInfo = this.registerController(target, { path: "" });
+    return controllerInfo;
+  }
+  registerController(target, routeInfo) {
+    console.log("controller", target);
+    let controllerInfo = this.getControllerInfo(target);
+    let controllerName = target.name;
+    const passed = controllerName.length > 10 && controllerName.substr(controllerName.length - 10, controllerName.length).toLowerCase() == CONTROLLER;
+    if (!controllerInfo && passed) {
+      if (!routeInfo.path)
+        routeInfo.path = controllerName.length > 10 ? controllerName.substr(0, controllerName.length - 10).toLowerCase() : BLANK;
+      controllerInfo = { route: routeInfo, actions: {} };
+      this.container.set(target, controllerInfo);
+    } else if (!passed)
+      console.warn(
+        `${target.name} is not register for http request.`
+      );
+    return controllerInfo;
+  }
+  registerAction(target, action, actionInfo) {
+    const controllerInfo = this.getOrCreateControllerInfo(target);
+    if (controllerInfo) {
+      const aInfo = controllerInfo.actions[actionInfo.route.path];
+      console.log("actions", controllerInfo.actions);
+      actionInfo = { ...{ action }, ...actionInfo };
+      if (!aInfo)
+        controllerInfo.actions[actionInfo.route.path] = [actionInfo];
+      else if (aInfo.filter((t) => t.requestMethod == actionInfo.requestMethod).length == 0)
+        aInfo.push(actionInfo);
+    }
+  }
+  getControllerRoutePath(instance) {
+    let routePath = null;
+    let controllerName = instance.name;
+    const passed = controllerName.length > 10 && controllerName.substr(controllerName.length - 10, controllerName.length).toLowerCase() == CONTROLLER;
+    return routePath ? routePath : passed ? controllerName.substr(0, controllerName.length - 10).toLowerCase() : BLANK;
+  }
+}();
+
+function init(config, appConfig) {
+  commonContainer.setupConfig(config);
+  commonContainer.setEnvTsDefinition(appConfig.envTsDefinition);
+  nattyContainer.setup(config, appConfig.routes, appConfig.types);
+  initializeModule(config);
+  return appConfig.routes;
+}
+function initializeModule(config) {
+  if (config.app) {
+    config.app.init(config);
+  }
+}
+
+function getPreResponseBody(body) {
+  let bodyInfo;
+  if (body) {
+    if (isObject(body) || Array.isArray(body))
+      bodyInfo = { json: body };
+    const typeText = typeof body;
+    switch (typeText) {
+      case "string":
+        bodyInfo = { string: body };
+        break;
+      case "number":
+        bodyInfo = { number: body };
+        break;
+      case "boolean":
+        bodyInfo = { boolean: body };
+        break;
+    }
+  }
+  return bodyInfo;
+}
+
+class HttpResponse {
+  constructor(response) {
+    this._cookies = new Array();
+    this._headers = new Headers();
+    this.setValues(response);
+  }
+  setValues(responseInit) {
+    if (responseInit) {
+      if (responseInit.headers)
+        for (const [key, value] of Object.entries(responseInit.headers))
+          this.headers.append(key, value);
+      if (responseInit.cookies)
+        for (const cookie of responseInit.cookies)
+          this.addCookie(cookie);
+      if (responseInit.status)
+        this.status = responseInit.status;
+      if (responseInit.body)
+        this.body = responseInit.body;
+    }
+  }
+  addCookie(cookie) {
+    this._cookies.push(cookie);
+  }
+  get cookies() {
+    return this._cookies;
+  }
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    this._status = value;
+  }
+  get headers() {
+    return this._headers;
+  }
+  get body() {
+    return this._body;
+  }
+  set body(value) {
+    this._body = getPreResponseBody(value);
+  }
+  write(responseInit) {
+    this.setValues(responseInit);
+  }
+}
+
+class HttpException {
+  constructor(response) {
+    this.httpResponse = new HttpResponse(response);
+  }
+  getResponse() {
+    return this.httpResponse;
+  }
+}
+
+var RequestPipeline = /* @__PURE__ */ ((RequestPipeline2) => {
+  RequestPipeline2[RequestPipeline2["onAuthentication"] = 0] = "onAuthentication";
+  RequestPipeline2[RequestPipeline2["onAuthorization"] = 1] = "onAuthorization";
+  return RequestPipeline2;
+})(RequestPipeline || {});
+
+function isBoolean(value) {
+  return typeof value === "boolean" || value === "1" || value === "true" || value === "0" || value === "false";
+}
+function isNumeric(value) {
+  return value - parseFloat(value) + 1 >= 0;
+}
+function isNotBlank(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+
+function trim(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.trim();
+  }
+  return value;
+}
+function ltrim(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(/^\s+/g, "");
+  }
+  return value;
+}
+function rtrim(value) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(/\s+$/g, "");
+  }
+  return value;
+}
+function blacklist(value, chars) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(new RegExp("[$" + chars + "]+", "g"), "");
+  }
+  return value;
+}
+function stripLow(value, keepNewLines) {
+  let chars = keepNewLines === true ? "\0-	\v\f-\x7F" : "\0-\x7F";
+  return blacklist(value, chars);
+}
+function toBoolean(value, strict) {
+  if (isNotBlank(value)) {
+    if (strict) {
+      return value === "1" || value === "true" || value === true;
+    }
+    return value !== 0 && value !== "0" && value !== "false" && value !== "" && value !== false;
+  }
+  return value;
+}
+function toInt(value, radix = 0) {
+  if (isNotBlank(value)) {
+    if (isNumeric(value))
+      return parseInt(value, radix || 10);
+  }
+  return null;
+}
+function toString(value) {
+  if (isNotBlank(value))
+    return String(value);
+  return value;
+}
+function whitelist(value, chars) {
+  if (isNotBlank(value)) {
+    if (typeof value === "string")
+      return value.replace(new RegExp(`[^${chars}]+`, "g"), "");
+  }
+  return value;
+}
+function escape(value) {
+  if (isNotBlank(value))
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\//g, "&#x2F;").replace(/\\/g, "&#x5C;").replace(/`/g, "&#96;");
+  return value;
+}
+function prefix(value, text) {
+  if (isNotBlank(value))
+    return `${text}${value}`;
+  return value;
+}
+function suffix(value, text) {
+  if (isNotBlank(value))
+    return `${value}${text}`;
+  return value;
+}
+const SANITIZERS = {
+  trim,
+  ltrim,
+  rtrim,
+  blacklist,
+  stripLow,
+  boolean: toBoolean,
+  number: toInt,
+  "string": toString,
+  whitelist,
+  escape,
+  prefix,
+  suffix
+};
+
+class HttpBadRequestException extends HttpException {
+  constructor(data) {
+    super({
+      ...{
+        body: data
+      },
+      ...{ status: 400 }
+    });
+  }
+}
+
+class HttpNotFoundException extends HttpException {
+  constructor(data) {
+    super({ ...{ body: data, status: 404 } });
+  }
+}
+
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["success"] = 200] = "success";
+  HttpStatusCode2[HttpStatusCode2["created"] = 201] = "created";
+  HttpStatusCode2[HttpStatusCode2["noContent"] = 204] = "noContent";
+  HttpStatusCode2[HttpStatusCode2["notFound"] = 404] = "notFound";
+  HttpStatusCode2[HttpStatusCode2["unAuthorized"] = 401] = "unAuthorized";
+  HttpStatusCode2[HttpStatusCode2["forbiddenAccess"] = 403] = "forbiddenAccess";
+  HttpStatusCode2[HttpStatusCode2["badRequest"] = 400] = "badRequest";
+  HttpStatusCode2[HttpStatusCode2["serverError"] = 500] = "serverError";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+
+class BaseResult {
+  constructor(response, responseHeaders) {
+    this.response = response;
+    if (responseHeaders)
+      this.response = { ...this.response, ...responseHeaders };
+  }
+  getResponse() {
+    return this.response;
+  }
+}
+
+function getResponseBodyObject(body, props) {
+  if (body instanceof List)
+    return getResponseBodyObject(body.values, body.props);
+  if (Array.isArray(body)) {
+    const responseBody = [];
+    body.forEach((item) => {
+      responseBody.push(getResponseBodyObject(item, props));
+    });
+    return responseBody;
+  } else if (isObject(body)) {
+    const jObject = {};
+    const keys = Object.keys(body);
+    const getterProps = props ? Object.keys(props).map((key) => props[key]) : [];
+    for (const key of [...keys, ...getterProps])
+      jObject[key] = getResponseBodyObject(body[key]);
+    return jObject;
+  }
+  return body;
+}
+
+class BaseResponse {
+  badRequest() {
+    throw new HttpBadRequestException(
+      { message: "Invalid parameters" }
+    );
+  }
+  success(body) {
+    let httpResponseInit;
+    if (body instanceof BaseResult)
+      httpResponseInit = body.getResponse();
+    else
+      httpResponseInit = { body: getResponseBodyObject(body), status: HttpStatusCode.success };
+    this.httpContext.response.write(httpResponseInit);
+    return this.httpContext.response;
+  }
+  notFound() {
+    throw new HttpNotFoundException({});
+  }
+}
+
+function getTypedErrorMessage(type, value) {
+  const message = commonContainer.nattyConfig.modelBinding.errorMessage.typed[type];
+  return parseMessage(message, [value]);
+}
+function parseMessage(message, value) {
+  value.forEach((item, index) => {
+    message = message.replace(`{${index}}`, item);
+  });
+  return message;
+}
+
+const entityContainer = new class {
+  constructor() {
+    this.entityConfig = {};
+  }
+  register(config) {
+    const params = config.decoratorParams;
+    const name = config.decoratorParams.target.name || config.decoratorParams.target.constructor.name;
+    let entityInfo = this.entityConfig[name] || null;
+    let propertyInfo = null;
+    if (!this.entityConfig[name])
+      entityInfo = this.entityConfig[name] = { target: config.decoratorParams.target, properties: {} };
+    if (config.modelConfig) {
+      entityInfo.modelInfo = config.modelConfig;
+    } else {
+      propertyInfo = entityInfo.properties[params.propertyKey];
+      if (!propertyInfo)
+        propertyInfo = entityInfo.properties[params.propertyKey] = { validators: {} };
+      if (!propertyInfo.propConfig && config.propConfig)
+        propertyInfo.propConfig = {};
+      if (config.propConfig)
+        propertyInfo.propConfig = { ...config.propConfig, ...propertyInfo.propConfig };
+      if (config.validatorConfig)
+        propertyInfo.validators[config.validatorConfig.name] = config.validatorConfig;
+    }
+  }
+  getTarget(entityName) {
+    const entityInfo = this.entityConfig[entityName];
+    return entityInfo ? entityInfo.target : null;
+  }
+  getModelConfig(entityName) {
+    const entityInfo = this.entityConfig[entityName];
+    return entityInfo ? entityInfo.modelInfo : null;
+  }
+  getPrimaryKeys(entityName) {
+    const primaryKeys = new Array();
+    const entityInfo = this.entityConfig[entityName];
+    if (entityInfo) {
+      for (const [key, value] of Object.entries(entityInfo.properties)) {
+        if (value.propConfig?.db?.isPrimaryKey)
+          primaryKeys.push(key);
+      }
+    }
+    return primaryKeys;
+  }
+  getPropsDbConfig(entityName) {
+    const props = /* @__PURE__ */ new Map();
+    const entityInfo = this.entityConfig[entityName];
+    if (entityInfo) {
+      for (const [key, value] of Object.entries(entityInfo.properties)) {
+        if (value.propConfig?.db)
+          props.set(key, value.propConfig?.db);
+      }
+    }
+    return props;
+  }
+  getPropertyValidators(entityName, propName) {
+    const entityInfo = this.entityConfig[entityName];
+    const propertyInfo = entityInfo.properties[propName];
+    return propertyInfo ? propertyInfo.validators : {};
+  }
+  getProperties(entityName) {
+    const typeInfo = nattyContainer.types[entityName];
+    return typeInfo.props;
+  }
+}();
+
+class ParameterTypeConverter extends BaseResponse {
+  constructor() {
+    super(...arguments);
+    this.sanitizer = {
+      number: (value) => isNotBlank(value) ? isNumeric(value) ? SANITIZERS.number(value) : INVALID_VALUE : value,
+      boolean: (value) => isNotBlank(value) ? isBoolean(value) ? SANITIZERS.boolean(value) : INVALID_VALUE : value,
+      string: (value) => isNotBlank(value) ? SANITIZERS.string(value) : value,
+      date: (value) => isNotBlank(value) ? new Date(value) : value
+    };
+  }
+  get types() {
+    return nattyContainer.types;
+  }
+  getObjectTypeInfo(typeName) {
+    return this.types[typeName];
+  }
+  isArrayType(typeName) {
+    return typeName.indexOf("[]") > 0;
+  }
+  getTypeName(typeName) {
+    const extractor = /<([^>]+)>/g;
+    const replacer = /[<>[\]]/g;
+    const matches = typeName.match(extractor);
+    let name = typeName.replace(replacer, BLANK$1);
+    if (matches)
+      matches.forEach((match) => {
+        name = match.replace(replacer, BLANK$1);
+      });
+    return name;
+  }
+  castObject(requestBody, properties) {
+    const body = {};
+    const invalidProps = {};
+    for (const property of properties) {
+      const typeName = this.getTypeName(property.type);
+      const objectTypeInfo = this.types[typeName];
+      const value = requestBody[property.name];
+      if (value !== void 0 && value != null) {
+        if (objectTypeInfo) {
+          if (this.isArrayType(property.type) && Array.isArray(value)) {
+            let arrayValue = body[property.name] = [];
+            let arrayInvalidProps = [];
+            const index = 0;
+            for (const item of value) {
+              const { body: body2, invalidProps: invalidProps2 } = this.castObject(item, objectTypeInfo.props);
+              arrayValue.push(body2);
+              if (Object.keys(invalidProps2).length > 0)
+                arrayInvalidProps.push({ ...invalidProps2, index });
+            }
+            if (arrayInvalidProps.length > 0)
+              invalidProps[property.name] = arrayInvalidProps;
+          } else if (objectTypeInfo) {
+            const result = this.castObject(requestBody[property.name], objectTypeInfo.props);
+            body[property.name] = result.body;
+            if (Object.keys(result.invalidProps).length > 0)
+              invalidProps[property.name] = result.invalidProps;
+          }
+        } else {
+          if (this.isArrayType(property.type) && Array.isArray(value)) {
+            let arrayValue = body[property.name] = [];
+            let arrayInvalidProps = invalidProps[property.name] = [];
+            for (const item of value) {
+              const sanitizeValue = this.sanitizer[property.type.toLowerCase()] ? this.sanitizer[property.type.toLowerCase()](item) : item;
+              if (sanitizeValue === INVALID_VALUE)
+                arrayInvalidProps.push(property);
+              else
+                arrayValue.push(sanitizeValue);
+            }
+          } else
+            this.setValue(value, property, { body, invalidProps });
+        }
+      }
+    }
+    return { body, invalidProps };
+  }
+  setValue(value, property, json) {
+    const sanitizeValue = this.sanitizer[property.type.toLowerCase()] ? this.sanitizer[property.type.toLowerCase()](value) : value;
+    if (sanitizeValue === INVALID_VALUE)
+      json.invalidProps[property.name] = getTypedErrorMessage(property.type, value);
+    else
+      json.body[property.name] = sanitizeValue;
+  }
+  convert(methodInfo, jObject) {
+    for (const parameterInfo of methodInfo.parameters) {
+      const value = jObject[parameterInfo.name];
+      if (value !== void 0) {
+        jObject[parameterInfo.name] = SANITIZERS[parameterInfo.type](value);
+      }
+    }
+    return jObject;
+  }
+  convertToInstance(entityName, data) {
+    const typesInfo = this.types[entityName];
+    const target = this.getClassTarget(typesInfo.path) || entityContainer.getTarget(entityName);
+    let instance = null;
+    if (target) {
+      instance = new target();
+      this.mapToInstanceProperties(data, instance, typesInfo.props);
+    } else
+      instance = data;
+    return instance;
+  }
+  getClassTarget(resolver) {
+    if (resolver) {
+      const classInfo = resolver();
+      const name = Object.keys(classInfo)[0];
+      return classInfo[name];
+    }
+    return void 0;
+  }
+  mapToInstanceProperties(requestBody, instance, properties) {
+    for (const property of properties) {
+      const typeName = this.getTypeName(property.type);
+      const objectTypeInfo = this.types[typeName];
+      const value = requestBody[property.name];
+      if (value !== void 0) {
+        if (objectTypeInfo) {
+          if (this.isArrayType(property.type) && Array.isArray(value)) {
+            const items = new Array();
+            for (const item of value)
+              items.push(this.convertToInstance(typeName, item));
+            instance[property.name] = items;
+          } else {
+            instance[property.name] = this.convertToInstance(typeName, value);
+          }
+        } else {
+          instance[property.name] = value;
+        }
+      }
+    }
+  }
+}
+
+class RouteParser extends ParameterTypeConverter {
+  constructor(httpContext) {
+    super();
+    this.httpContext = httpContext;
+    this.init();
+  }
+  get httpMethod() {
+    return this.httpContext.request.method.toLowerCase();
+  }
+  get appRoutes() {
+    return nattyContainer.routes;
+  }
+  init() {
+    const isMatched = this.matchRoute();
+    if (!isMatched)
+      this.notFound();
+  }
+  getController(controllerRoute) {
+    const controllerInfo = controllerRoute.controller();
+    const name = Object.keys(controllerInfo)[0];
+    return controllerInfo[name];
+  }
+  matchRoute() {
+    let isMatched = false;
+    const requestPathname = this.getRequestPathname();
+    for (const [key, value] of Object.entries(this.appRoutes)) {
+      const rootPath = key;
+      const routeConfig = value;
+      const childRoutes = routeConfig[this.httpMethod];
+      if (childRoutes) {
+        for (const [key2, value2] of Object.entries(childRoutes)) {
+          const childPath = key2.indexOf(RIGHT_SLASH) == 0 ? key2 === RIGHT_SLASH ? BLANK$1 : key2 : `/${key2}`;
+          const methodInfo = value2;
+          const configuredRoutePath = `${rootPath}${childPath}`;
+          const routeMatch = match(`${rootPath}${childPath}`, { decode: decodeURIComponent });
+          const matched = routeMatch(requestPathname);
+          if (matched) {
+            isMatched = true;
+            this.routeInfo = {
+              path: `${commonContainer.nattyConfig.api.rootPath}/${requestPathname}`,
+              configuredRoutePath: `${commonContainer.nattyConfig.api.rootPath}/${configuredRoutePath}`,
+              controller: this.getController(routeConfig),
+              parameters: routeConfig.parameters,
+              methodInfo,
+              params: this.convert(methodInfo, matched.params),
+              queryParams: this.getQueryParams()
+            };
+            break;
+          }
+        }
+      }
+    }
+    return isMatched;
+  }
+  getRequestPathname() {
+    const apiRootPath = commonContainer.nattyConfig.api.rootPath;
+    const url = new URL(this.httpContext.request.url);
+    let splitUrl = url.pathname.split(`${apiRootPath}/`);
+    if (splitUrl.length > 1)
+      return splitUrl[1];
+    return url.pathname;
+  }
+  getQueryParams() {
+    const url = new URL(this.httpContext.request.url);
+    const queryParams = {};
+    for (const param of url.searchParams.keys())
+      queryParams[param] = url.searchParams.get(param);
+    return queryParams;
+  }
+}
+
+class UnauthorizedAccessException extends HttpException {
+  constructor(data) {
+    super({
+      body: data,
+      status: 401
+    });
+  }
+}
+
+const decoratorStateContainer = new class {
+  constructor() {
+    this.controllerConfig = {};
+  }
+  register(params, type, additionalConfig) {
+    const name = params.target.name || params.target.constructor.name;
+    let controllerInfo = this.controllerConfig[name] || null;
+    let controllerMethodInfo = null;
+    if (!this.controllerConfig[name])
+      controllerInfo = this.controllerConfig[name] = { config: {}, methods: {} };
+    if (params.propertyKey) {
+      controllerMethodInfo = controllerInfo.methods[params.propertyKey] || null;
+      if (!controllerInfo.methods[params.propertyKey])
+        controllerMethodInfo = controllerInfo.methods[params.propertyKey] = {};
+      controllerMethodInfo[type] = additionalConfig;
+    } else
+      controllerInfo.config[type] = additionalConfig;
+  }
+  getInfo(controllerName, methodName, type) {
+    const controllerInfo = this.controllerConfig[controllerName];
+    const methodInfo = controllerInfo && methodName ? controllerInfo.methods[methodName] : null;
+    let methodConfig = void 0;
+    let controllerConfig = void 0;
+    if (controllerInfo && controllerInfo.config)
+      controllerConfig = controllerInfo.config[type];
+    if (methodInfo)
+      methodConfig = methodInfo[type];
+    return { controllerConfig, methodConfig };
+  }
+}();
+
+var DecoratorType = /* @__PURE__ */ ((DecoratorType2) => {
+  DecoratorType2[DecoratorType2["anonymous"] = 0] = "anonymous";
+  DecoratorType2[DecoratorType2["get"] = 1] = "get";
+  DecoratorType2[DecoratorType2["post"] = 2] = "post";
+  DecoratorType2[DecoratorType2["put"] = 3] = "put";
+  DecoratorType2[DecoratorType2["delete"] = 4] = "delete";
+  DecoratorType2[DecoratorType2["route"] = 5] = "route";
+  DecoratorType2[DecoratorType2["authenticationOnly"] = 6] = "authenticationOnly";
+  DecoratorType2[DecoratorType2["authorize"] = 7] = "authorize";
+  DecoratorType2[DecoratorType2["useFilter"] = 8] = "useFilter";
+  DecoratorType2[DecoratorType2["onException"] = 9] = "onException";
+  return DecoratorType2;
+})(DecoratorType || {});
+
+class ForbiddenAccessException extends HttpException {
+  constructor(data) {
+    super({
+      body: data,
+      status: 403
+    });
+  }
+}
+
+class AbstractExecutionContext {
+  constructor(context, routeInfo) {
+    this.context = context;
+    this.routeInfo = routeInfo;
+  }
+  resolveService(instance) {
+    return container.resolve(instance);
+  }
+  get request() {
+    return this.context.request;
+  }
+  get user() {
+    return this.context.user;
+  }
+  get result() {
+    return this._result;
+  }
+  set result(value) {
+    this._result = value;
+  }
+}
+
+class ActionExecutingContext extends AbstractExecutionContext {
+  constructor(models, context, routeInfo) {
+    super(context, routeInfo);
+    this.models = models;
+  }
+}
+
+function CreateProblemDetail(modelName, detail) {
+  return {
+    type: "https://tools.ietf.org/html/rfc7231#section-6.5.1",
+    title: `The specified ${modelName} model props are invalid.`,
+    detail
+  };
+}
+
+function runValidators(entityName, value) {
+  const typeInfo = nattyContainer.types[entityName];
+  let errors = {};
+  if (typeInfo) {
+    for (const propertyInfo of typeInfo.props) {
+      const childEntityName = getTypeName(propertyInfo.type);
+      const childEntity = nattyContainer.types[childEntityName];
+      const validators = entityContainer.getPropertyValidators(entityName, propertyInfo.name);
+      if (childEntity) {
+        const propValue = value[propertyInfo.name];
+        if (propValue) {
+          if (Array.isArray(propValue)) {
+            let index = 0;
+            let arrayPropErrors = [];
+            for (const item of propValue) {
+              let errors2 = runValidators(childEntityName, item);
+              if (errors2)
+                arrayPropErrors.push({ ...errors2, index });
+            }
+            errors[propertyInfo.name] = arrayPropErrors.length > 0 ? arrayPropErrors : null;
+          } else
+            errors[propertyInfo.name] = runValidators(childEntityName, propValue);
+          if (Array.isArray(errors[propertyInfo.name]) && errors[propertyInfo.name].length == 0 || Object.keys(errors[propertyInfo.name]).length == 0)
+            errors[propertyInfo.name] = null;
+        }
+      } else {
+        errors[propertyInfo.name] = runPropertyValidators(validators, { value: value[propertyInfo.name], current: value, root: this });
+      }
+      if (!errors[propertyInfo.name])
+        delete errors[propertyInfo.name];
+    }
+  }
+  return Object.keys(errors).length === 0 ? null : errors;
+}
+function runPropertyValidators(validators, params) {
+  for (const key of Object.keys(validators)) {
+    const validatorConfig = validators[key];
+    const errors = validatorConfig.validator(validatorConfig.config, params);
+    return errors;
+  }
+  return null;
+}
+function getTypeName(typeName) {
+  return typeName.replace("[]", BLANK);
+}
+
+class ModelBindingContext extends ParameterTypeConverter {
+  constructor(type, typeInfo, data) {
+    super();
+    this.type = type;
+    this.typeInfo = typeInfo;
+    this.data = data;
+    this.serialize();
+  }
+  serialize() {
+    const { body, invalidProps } = this.castObject(this.data, this.typeInfo);
+    if (Object.keys(invalidProps).length > 0)
+      throw new HttpBadRequestException(CreateProblemDetail(this.type, invalidProps));
+    else
+      this.data = body;
+    this.instance = this.convertToInstance(this.type, this.data);
+  }
+  get isValid() {
+    const errors = runValidators(this.type, this.instance);
+    return errors === null;
+  }
+  get errors() {
+    const errors = runValidators(this.type, this.instance);
+    return errors;
+  }
+}
+
+class ActionExecutedContext extends AbstractExecutionContext {
+  constructor(content, httpContext, routeInfo) {
+    super(httpContext, routeInfo);
+    this.content = content;
+  }
+}
+
+class RequestProcessor extends RouteParser {
+  constructor() {
+    super(...arguments);
+    this.actionFilterInstances = new Array();
+  }
+  async runPipeline(requestPipeline) {
+    switch (requestPipeline) {
+      case RequestPipeline.onAuthentication:
+        await this.onAuthentication();
+        break;
+      case RequestPipeline.onAuthorization:
+        await this.onAuthorization();
+        break;
+    }
+  }
+  resolveFilter(instance) {
+    return container.resolve(instance);
+  }
+  getAuthenticationClass() {
+    let authentication = void 0;
+    const instanceLevelAuthenticationFilter = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.useFilter);
+    if (instanceLevelAuthenticationFilter.methodConfig?.authentication)
+      authentication = instanceLevelAuthenticationFilter.methodConfig?.authentication;
+    else if (instanceLevelAuthenticationFilter.controllerConfig?.authentication)
+      authentication = instanceLevelAuthenticationFilter.controllerConfig?.authentication;
+    else
+      authentication = commonContainer.globalConfig.authentication;
+    return authentication;
+  }
+  async onAuthentication() {
+    const authentication = this.getAuthenticationClass();
+    const authenticationFilter = authentication ? this.resolveFilter(authentication) : void 0;
+    const anonymousInfo = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.anonymous);
+    if (authenticationFilter) {
+      const result = await authenticationFilter.onAuthentication(this.httpContext);
+      this.httpContext.user = result;
+      if (!result.isAuthenticate && !anonymousInfo.controllerConfig && !anonymousInfo.methodConfig)
+        throw new UnauthorizedAccessException(authenticationFilter.onFailedResponse());
+      await this.onAuthorization();
+    }
+  }
+  async onAuthorization() {
+    const authorization = commonContainer.globalConfig.authorization;
+    const authorizationFilter = authorization ? this.resolveFilter(authorization) : void 0;
+    const authorizeConfig = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.authorize);
+    const authenticationOnly = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.authenticationOnly);
+    if (this.httpContext.user?.isAuthenticate && authorizationFilter && (!authenticationOnly.controllerConfig && !authenticationOnly.methodConfig)) {
+      const result = await authorizationFilter.onAuthorization(this.httpContext, authorizeConfig.methodConfig || authorizeConfig.controllerConfig);
+      if (!result)
+        throw new ForbiddenAccessException(authorizationFilter.onFailedAuthorization());
+    }
+  }
+  async onActionExecuting(methodParameters) {
+    let actionFilters = commonContainer.globalConfig.actionFilters || [];
+    const actionFiltersConfig = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.useFilter);
+    actionFilters = [...actionFilters, ...actionFiltersConfig.controllerConfig?.actionFilters || [], ...actionFiltersConfig.methodConfig?.actionFilters || []];
+    const actionExecutingContext = new ActionExecutingContext(
+      methodParameters.filter((t) => t instanceof ModelBindingContext),
+      this.httpContext,
+      this.routeInfo
+    );
+    for (const actionFilter of actionFilters) {
+      const filter = this.resolveFilter(actionFilter);
+      this.actionFilterInstances.push(filter);
+      await filter.onActionExecuting(actionExecutingContext);
+      if (actionExecutingContext.result) {
+        return actionExecutingContext.result;
+      }
+    }
+    return null;
+  }
+  async onActionExecuted(content) {
+    const executedContext = new ActionExecutedContext(content, this.httpContext, this.routeInfo);
+    for (const actionFilter of this.actionFilterInstances) {
+      await actionFilter.onActionExecuted(executedContext);
+      if (executedContext.result)
+        return executedContext.result;
+    }
+    return null;
+  }
+}
+
+class Resolver extends RequestProcessor {
+  constructor(httpContext) {
+    super(httpContext);
+  }
+  getControllerInstance() {
+    const controller = this.routeInfo.controller;
+    const parameters = this.resolveConstructorParameters();
+    const instance = new controller(...parameters);
+    return instance;
+  }
+  resolveClass(classConstruct) {
+    return container.resolve(classConstruct);
+  }
+  resolveConstructorParameters() {
+    let parameters = [];
+    for (const parameter of this.routeInfo.parameters) {
+      const classConstruct = this.getClass(parameter.type);
+      if (classConstruct)
+        parameters.push(this.resolveClass(classConstruct));
+    }
+    return parameters;
+  }
+  getMethodParameters() {
+    const parameters = new Array();
+    for (const parameter of this.routeInfo.methodInfo.parameters) {
+      const params = this.routeInfo.params;
+      const queryParams = this.routeInfo.queryParams;
+      const typeInfo = this.getObjectTypeInfo(parameter.type);
+      if (params[parameter.name] !== void 0)
+        parameters.push(params[parameter.name]);
+      else if (queryParams[parameter.name] !== void 0)
+        parameters.push(queryParams[parameter.name]);
+      else if (typeInfo && this.httpContext.request.body.json) {
+        const context = new ModelBindingContext(parameter.type, typeInfo.props, this.httpContext.request.body.json);
+        parameters.push(context);
+      }
+    }
+    return parameters;
+  }
+  get onException() {
+    return commonContainer.globalConfig.onException;
+  }
+  async invoke() {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (this.routeInfo.controller && this.routeInfo.methodInfo) {
+          await this.runPipeline(RequestPipeline.onAuthentication);
+          const instance = this.getControllerInstance();
+          instance.httpContext = this.httpContext;
+          const methodParameters = this.getMethodParameters();
+          let result = null;
+          result = await this.onActionExecuting(methodParameters);
+          if (!result)
+            result = instance[this.routeInfo.methodInfo.name](...methodParameters.map((t) => {
+              if (t instanceof ModelBindingContext)
+                return t.instance;
+              return t;
+            }));
+          if (result && result.then) {
+            let content = await result;
+            let actionResult = await this.onActionExecuted(content);
+            resolve(actionResult || this.success(content));
+            return content;
+          } else {
+            let actionResult = await this.onActionExecuted(result);
+            resolve(actionResult || this.success(result));
+            return result;
+          }
+        } else {
+        }
+      } catch (ex) {
+        resolve(this.exceptionResult(ex));
+      }
+    });
+  }
+  exceptionResult(ex) {
+    let result = ex;
+    if (ex instanceof HttpException) {
+      result = ex.getResponse();
+    } else {
+      let onException = this.onException;
+      const { controllerConfig, methodConfig } = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.onException);
+      onException = methodConfig || controllerConfig || onException;
+      if (onException) {
+        const instance = this.resolveClass(onException);
+        if (instance.onException)
+          result = instance.onException({
+            error: ex,
+            request: this.httpContext.request,
+            routeInfo: this.routeInfo
+          });
+      } else
+        result = new HttpException({
+          body: getPreResponseBody({ message: ex.message, stack: ex.stack }),
+          status: HttpStatusCode.serverError
+        }).getResponse();
+    }
+    return result;
+  }
+  getClass(className) {
+    return commonContainer.getMetadataValue(className, "services");
+  }
+}
+
+class RequestHandler extends Resolver {
+  constructor(httpContext) {
+    super(httpContext);
+  }
+  async onRequest() {
+    try {
+      const result = await this.invoke();
+      return result;
+    } catch (ex) {
+      if (ex instanceof HttpException)
+        return ex.getResponse();
+      let onException = this.onException;
+      const { controllerConfig, methodConfig } = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.onException);
+      onException = methodConfig || controllerConfig || onException;
+      if (onException) {
+        const instance = this.resolveClass(onException);
+        if (instance.onException)
+          return instance.onException({
+            error: ex,
+            request: this.httpContext.request,
+            routeInfo: this.routeInfo
+          });
+      } else
+        return new HttpException({
+          body: ex,
+          status: HttpStatusCode.serverError
+        });
+    }
+  }
+}
+
+class HttpHandler {
+  constructor() {
+  }
+  async processRequest(httpContext) {
+    const requestProcessor = new RequestHandler(httpContext);
+    const result = await requestProcessor.onRequest();
+    return result;
+  }
+}
+
+class HttpRequest {
+  constructor(http) {
+    this.httpRequest = http;
+  }
+  get cookies() {
+    return this.httpRequest.cookies;
+  }
+  get url() {
+    return this.httpRequest.url;
+  }
+  get method() {
+    return this.httpRequest.method;
+  }
+  get headers() {
+    return this.httpRequest.headers;
+  }
+  get user() {
+    return null;
+  }
+  get body() {
+    return this.httpRequest.body;
+  }
+}
+
+class HttpContext {
+  constructor(request, context) {
+    this.request = new HttpRequest(request);
+    this.response = new HttpResponse();
+    this.context = context;
+  }
+}
+
+function injectable(options = {}) {
+  return (targetConstructor) => {
+    injectable$1()(targetConstructor);
+    commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
+  };
+}
+
+function $request(request) {
+  if (!request.url)
+    request.url = `${request.host || "http://127.0.0.1/"}${request.pathName}`;
+  return commonContainer.nattyConfig.testModule.onRequest(request);
+}
+
+function filter(config) {
+  return (targetConstructor) => {
+    injectable$1()(targetConstructor);
+  };
+}
+
+function registerDecorator(config) {
+  entityContainer.register(config);
+}
+
+class AbstractModelState {
+  constructor() {
+    this._errors = {};
+  }
+  get isValid() {
+    this._errors = this.runValidators(this.constructor.name, this);
+    return this._errors === null;
+  }
+  get errors() {
+    this._errors = this.runValidators(this.constructor.name, this);
+    return this._errors;
+  }
+  runValidators(entityName, value) {
+    return runValidators(entityName, value);
+  }
+}
+
+class BaseController {
+}
+
+class OkResult extends BaseResult {
+  constructor(value, response) {
+    super({ ...{ body: getResponseBodyObject(value) }, ...{ status: HttpStatusCode.success } }, response);
+    this.value = value;
+  }
+}
+function ok(value, response) {
+  return new OkResult(value || BLANK$1, response);
+}
+
+class NotFoundResult extends BaseResult {
+  constructor(response) {
+    super({ ...{ body: BLANK$1 }, ...{ status: HttpStatusCode.notFound } }, response);
+  }
+}
+function notFound(response) {
+  return new NotFoundResult(response);
+}
+
+class NoContentResult extends BaseResult {
+  constructor(response) {
+    super({ ...{ body: BLANK$1 }, ...{ status: HttpStatusCode.noContent } }, response);
+  }
+}
+function noContent(response) {
+  return new NoContentResult(response);
+}
+
+class ForbiddenAccessInfoResult extends BaseResult {
+  constructor(value, response) {
+    super({ ...{ body: value }, ...{ status: HttpStatusCode.forbiddenAccess } }, response);
+  }
+}
+function forbiddenAccessInfo(value, response) {
+  return new ForbiddenAccessInfoResult(value, response);
+}
+
+class CreatedResult extends BaseResult {
+  constructor(response) {
+    super({ ...{ body: BLANK$1 }, ...{ status: HttpStatusCode.created } }, response);
+  }
+}
+function created(response) {
+  return new CreatedResult(response);
+}
+
+class BadRequestResult extends BaseResult {
+  constructor(value, response) {
+    super({ ...{ body: value }, ...{ status: HttpStatusCode.badRequest } }, response);
+    this.value = value;
+  }
+}
+function badRequest(value, response) {
+  return new BadRequestResult(value || BLANK$1, response);
+}
+
+function base(params, type, additionaConfig) {
+  decoratorStateContainer.register(params, type, additionaConfig);
+}
+
+function useFilter(config) {
+  return function(target, propertyKey, descriptor) {
+    base({ target, propertyKey, descriptor }, DecoratorType.useFilter, config);
+  };
+}
+
+function anonymous() {
+  return function(target, propertyKey, descriptor) {
+    base({ target, propertyKey, descriptor }, DecoratorType.anonymous, true);
+  };
+}
+
+function authenticationOnly() {
+  return function(target, propertyKey, descriptor) {
+    base({
+      target,
+      propertyKey,
+      descriptor
+    }, DecoratorType.authenticationOnly, true);
+  };
+}
+
+export { $request, AbstractModelState, BadRequestResult, BaseController, CreatedResult, Delete, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpContext, HttpException, HttpHandler, HttpNotFoundException, HttpResponse, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, RunOn, UnauthorizedAccessException, anonymous, authenticationOnly, badRequest, created, defineNattyConfig, entityContainer, filter, forbiddenAccessInfo, get, init, injectable, noContent, notFound, ok, post, put, registerDecorator, route, useFilter };