@nattyjs/common 0.0.1-beta.0

package/README.md

@@ -0,0 +1,11 @@
+# `common`
+
+> TODO: description
+
+## Usage
+
+```
+const common = require('common');
+
+// TODO: DEMONSTRATE API
+```

package/dist/index.cjs

@@ -0,0 +1,598 @@
+'use strict';
+
+const fs = require('fs');
+const dotenv = require('dotenv');
+const dotenvExpand = require('dotenv-expand');
+const path = require('path');
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+const dotenv__namespace = /*#__PURE__*/_interopNamespaceCompat(dotenv);
+const dotenvExpand__namespace = /*#__PURE__*/_interopNamespaceCompat(dotenvExpand);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+
+const commonContainer = new class {
+  constructor() {
+    this.metadataConfig = { services: /* @__PURE__ */ new Map() };
+  }
+  setupConfig(config) {
+    const modelBinding = {
+      errorMessage: {
+        typed: {
+          number: "Invalid numeric value of '{0}'.",
+          boolean: "Invalid boolean value of '{0}'."
+        }
+      }
+    };
+    this.nattyConfig = { ...{ api: { rootPath: "api" }, modelBinding, globalConfig: {} }, ...config };
+  }
+  setupBuildOptions(options) {
+    this.buildOptions = options;
+  }
+  setEnvTsDefinition(tsDefinition) {
+    this.envTsDefinition = tsDefinition;
+  }
+  setMetadata(key, value, propName) {
+    this.metadataConfig[propName].set(key, value);
+  }
+  getMetadataValue(key, propName) {
+    return this.metadataConfig[propName].get(key);
+  }
+  get globalConfig() {
+    return this.nattyConfig.global || {};
+  }
+}();
+
+const CONTROLLER = "controller";
+const ENVIRONMENTS = "environments";
+const BLANK = "";
+const GET = "get";
+const POST = "post";
+const PUT = "put";
+const DELETE = "delete";
+const ALLOW_METHODS = [GET, POST, PUT, DELETE];
+const IGNORE_METHODS = "IGNORE:METHODS";
+const ROUTE_METHODS = "ROUTE:METHODS";
+const ROUTE_INSTANCES = "ROUTE:INSTANCES";
+const ROUTE_PATHS = "ROUTE:PATHS";
+const HTTP_METHOD_ROUTES = "HTTPMETHOD:ROUTES";
+const isConstructor = (value) => value === "constructor";
+const isFunction = (value) => typeof value === "function";
+const DEFAULT_ACTIONS = [GET, POST, PUT, DELETE];
+const MetaConfigProps = {
+  services: "services"
+};
+const DEFAULT_CHILD_PATH = "/";
+const TS_EXTENSION = ".ts";
+const BACK_SLASH_REGEX = /\\/g;
+const RIGHT_SLASH = "/";
+
+const typeContainer = new class {
+  constructor() {
+    this.controllerInfo = /* @__PURE__ */ new Map();
+    this.files = /* @__PURE__ */ new Map();
+    this.routes = {};
+  }
+  setControllerJsonSchema(classInfo) {
+    const className = this.files.get(classInfo.filePath);
+    const isChanged = !className ? false : className != classInfo.name;
+    if (isChanged)
+      this.controllerInfo.delete(className);
+    this.controllerInfo.set(classInfo.name, classInfo);
+    this.files.set(classInfo.filePath, classInfo.name);
+  }
+  getControllersJsonSchema() {
+    const items = new Array();
+    this.controllerInfo.forEach((t) => items.push(t));
+    return items;
+  }
+  getControllerRouteName(classInfo) {
+    const controllerName = classInfo.name;
+    if (classInfo.route?.route) {
+      return classInfo.route.route;
+    }
+    return controllerName.substr(0, controllerName.length - 10).toLowerCase();
+  }
+  getRoutes() {
+    const routes = {};
+    for (const key of this.controllerInfo.keys()) {
+      const classInfo = this.controllerInfo.get(key);
+      let templateInfo = {
+        path: `.${classInfo.filePath.replace(TS_EXTENSION, BLANK).replace(BACK_SLASH_REGEX, RIGHT_SLASH)}`,
+        route: this.getControllerRouteName(classInfo),
+        parameters: classInfo.constructorParameters
+      };
+      for (const method of classInfo.methods) {
+        const routeInfo = method.route = this.getRouteInfo(method);
+        let httpMethod = routeInfo?.httpMethod;
+        if (DEFAULT_ACTIONS.indexOf(method.name) > -1)
+          httpMethod = method.name;
+        if (!templateInfo[httpMethod])
+          templateInfo[httpMethod] = {};
+        let route = this.getRoutePath(method, httpMethod);
+        let parameters = [];
+        for (const parameterInfo of method.parameters) {
+          parameters.push({ name: parameterInfo.name, type: parameterInfo.type });
+        }
+        templateInfo[httpMethod][route] = { name: method.name, parameters, returnType: method.returnType };
+      }
+      routes[templateInfo.route] = templateInfo;
+    }
+    return routes;
+  }
+  getRouteInfo(methodInfo) {
+    let route = methodInfo.route;
+    const parameters = methodInfo.parameters || [];
+    if (!route && methodInfo.name == "getBy") {
+      route = {
+        httpMethod: "get",
+        route: parameters.filter((t) => t.name == "id").map((t) => `:${t.name}`).join("/")
+      };
+    } else if (!route && methodInfo.name == "put") {
+      const parameter = parameters.filter((t) => t.name == "id")[0];
+      if (parameter) {
+        route = {
+          httpMethod: "put",
+          route: ":id"
+        };
+      }
+    }
+    return route;
+  }
+  getRoutePath(method, httpMethod) {
+    const route = method.route;
+    let routePath = method.route?.route || DEFAULT_CHILD_PATH;
+    if (!route && httpMethod == DELETE && method.parameters) {
+      const parameter = method.parameters.filter((parameterInfo) => parameterInfo.name == "id")[0];
+      if (parameter)
+        routePath = ":id";
+    }
+    return routePath;
+  }
+  removeControllerInfo(path) {
+    const name = this.files.get(path);
+    if (name) {
+      this.files.delete(path);
+      this.controllerInfo.delete(name);
+    }
+  }
+  getControllerJsonSchema(name) {
+    return this.controllerInfo.get(name);
+  }
+}();
+
+function createTestServer() {
+  const test = require("./build");
+  console.log(test);
+  return test;
+}
+
+function tsDefinition(value) {
+  const definition = /^(true|false)+$/i.test(value) ? "boolean" : /^[0-9]+$/.test(value) ? "number" : "string";
+  const transformValue = definition === "boolean" ? Boolean(value) : definition === "number" ? Number(value) : value;
+  return { definition, transformValue };
+}
+
+function getEnvTsDefinition(parsed) {
+  let serverTypedDefinition = {};
+  if (parsed) {
+    const keys = Object.keys(parsed);
+    if (keys.length > 0) {
+      keys.forEach((key) => {
+        let keyName = key;
+        const { definition, transformValue } = tsDefinition(parsed[key]);
+        serverTypedDefinition[keyName] = definition;
+      });
+    }
+  }
+  return serverTypedDefinition;
+}
+
+function createPath(pathToCreate) {
+  var isNotExits = false;
+  pathToCreate.split(path__namespace.sep).reduce((prevPath, folder) => {
+    const currentPath = path__namespace.join(prevPath, folder, path__namespace.sep);
+    isNotExits = !fs__namespace.existsSync(currentPath);
+    if (isNotExits) {
+      fs__namespace.mkdirSync(currentPath);
+    }
+    return currentPath;
+  }, "");
+  return isNotExits;
+}
+
+function getPath(pathCollection, isIncludeRoot = true, isCreateFolder = false) {
+  const rootPath = isIncludeRoot ? [commonContainer.buildOptions.rootDir] : [];
+  const currentPath = path__namespace.join(...rootPath, ...pathCollection);
+  if (isCreateFolder)
+    createPath(currentPath);
+  return currentPath;
+}
+
+async function readEnv() {
+  let filePath = getPath([ENVIRONMENTS, commonContainer.buildOptions.mode && commonContainer.buildOptions.mode !== "dev" ? `.env.${commonContainer.buildOptions.mode}` : `.env`]);
+  let parsedEnvTsDefinition = {};
+  if (fs.existsSync(filePath)) {
+    const { parsed, error } = dotenv__namespace.config({
+      debug: !!process.env.DEBUG || void 0,
+      path: filePath
+    });
+    parsedEnvTsDefinition = getEnvTsDefinition(parsed);
+    commonContainer.setEnvTsDefinition(parsedEnvTsDefinition);
+    dotenvExpand__namespace.expand({ parsed });
+  }
+  return parsedEnvTsDefinition;
+}
+
+class AuthenticationFilter {
+  onFailedResponse() {
+    return {
+      type: "https://tools.ietf.org/html/rfc7235#section-3.1",
+      title: "Unauthorized"
+    };
+  }
+}
+
+class AuthorizationFilter {
+  onFailedAuthorization() {
+    return {
+      type: "https://tools.ietf.org/html/rfc7231#section-6.5.3",
+      title: "Forbidden"
+    };
+  }
+}
+
+class ActionFilter {
+  onActionExecuting(context) {
+    return;
+  }
+  onActionExecuted(context) {
+    return;
+  }
+}
+
+class Middleware {
+}
+
+class ExceptionFilter {
+}
+
+function readEnvKey(key) {
+  const definition = commonContainer.envTsDefinition[key];
+  const value = process.env[key];
+  let transformValue = value;
+  if (definition) {
+    transformValue = definition === "boolean" ? value === "true" : definition === "number" ? Number(value) : value;
+  }
+  return transformValue;
+}
+
+class UserIdentity {
+  constructor(isAuthenticate, id, claim) {
+    this.isAuthenticate = isAuthenticate;
+    this.id = id;
+    this.claim = claim;
+  }
+}
+
+function isObject(value) {
+  return !!value && typeof value === "object" && !(value instanceof Date);
+}
+function isEqual(first, second) {
+  return Object.entries(first).every(
+    ([key, value]) => isObject(value) ? isEqual(second[key], value) : second[key] === value
+  );
+}
+
+function getInstance(model, objectArguments) {
+  return Reflect.construct(model, objectArguments);
+}
+function getObject(model, objectArguments, jObject, props) {
+  let instance = getInstance(model, objectArguments);
+  Object.keys(jObject).forEach((t) => {
+    const currentPropName = t.toLowerCase();
+    if (props) {
+      const propName = props[currentPropName];
+      if (propName)
+        instance[propName] = jObject[t];
+    } else
+      instance[t] = jObject[t];
+  });
+  return instance;
+}
+
+class List {
+  constructor(values, model, props) {
+    this.model = model;
+    this.props = props;
+    this._entities = new Array();
+    this.build(values);
+  }
+  add(entity) {
+    this._entities.push(this.createObject(entity));
+  }
+  addRange(entities) {
+    for (let entity of entities)
+      this.add(entity);
+  }
+  all(predicate) {
+    return this._entities.every(predicate);
+  }
+  any(predicate) {
+    return this._entities.some(predicate);
+  }
+  average(transform) {
+    return this.sum(transform) / this.count(transform);
+  }
+  contains(element) {
+    return this._entities.some((x) => x === element);
+  }
+  concat(items) {
+    if (items) {
+      this.addRange(items);
+      return new List(this._entities, this.model);
+    }
+    return void 0;
+  }
+  count(predicate) {
+    return predicate ? this.where(predicate).count() : this._entities.length;
+  }
+  where(predicate) {
+    return new List(this._entities.filter(predicate), this.model);
+  }
+  distinct() {
+    return this.where(
+      (value, index, iter) => isObject(value) ? iter.findIndex((t) => isEqual(t, value)) == index : iter.indexOf(value) === index
+    );
+  }
+  distinctBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    return Object.keys(entityGroup).reduce((resource, key) => {
+      resource.add(entityGroup[key][0]);
+      return resource;
+    }, new List());
+  }
+  elementAt(index) {
+    if (this._entities.length > index && index >= 0)
+      return this._entities[index];
+  }
+  except(collection) {
+    return this.where((x) => !collection.contains(x));
+  }
+  first(predicate) {
+    if (this.count()) {
+      return predicate ? this.where(predicate).first() : this._entities[0];
+    } else {
+      throw new Error("No result found.");
+    }
+  }
+  firstOrDefault(predicate) {
+    return this.count() ? this.first(predicate) : void 0;
+  }
+  forEach(action) {
+    return this._entities.forEach(action);
+  }
+  aggregate(accumulator, initialValue) {
+    return this._entities.reduce(accumulator, initialValue);
+  }
+  groupBy(grouper, mapper) {
+    if (!mapper)
+      mapper = (value) => value;
+    return this.aggregate((ac, v) => (ac[grouper(v)] ? ac[grouper(v)].push(mapper(v)) : ac[grouper(v)] = [mapper(v)], ac), {});
+  }
+  insert(index, element) {
+    if (index < 0 || index > this._entities.length) {
+      throw new Error("Index is out of range.");
+    }
+    this._entities.splice(index, 0, this.createObject(element));
+  }
+  join(seperator) {
+    return this._entities ? this._entities.join(seperator) : null;
+  }
+  last(predicate) {
+    if (this.count()) {
+      return predicate ? this.where(predicate).last() : this._entities[this.count() - 1];
+    } else {
+      throw Error("No result found.");
+    }
+  }
+  lastOrDefault(predicate) {
+    return this.count() ? this.last(predicate) : void 0;
+  }
+  get length() {
+    return this._entities ? this._entities.length : 0;
+  }
+  max(predicate) {
+    if (!predicate)
+      return this.aggregate((x, y) => x > y ? x : y);
+    else
+      return Math.max(...this._entities.map(predicate));
+  }
+  maxBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    let keys = Object.keys(entityGroup);
+    let maxKey = Math.max(...keys);
+    return entityGroup[maxKey][0];
+  }
+  min(predicate) {
+    if (!predicate)
+      return this.aggregate((x, y) => x < y ? x : y);
+    else
+      return Math.min(...this._entities.map(predicate));
+  }
+  minBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    let keys = Object.keys(entityGroup);
+    let minKey = Math.min(...keys);
+    return entityGroup[minKey][0];
+  }
+  orderBy(predicate) {
+    return new List(this._entities.sort(this.customSort(predicate, false)));
+  }
+  orderByDescending(predicate) {
+    return new List(this._entities.sort(this.customSort(predicate, true)));
+  }
+  pop() {
+    return this._entities.pop();
+  }
+  indexOf(element) {
+    return this._entities.indexOf(element);
+  }
+  remove(element) {
+    return this._entities.indexOf(element) !== -1 ? (this.removeAt(this._entities.indexOf(element)), true) : false;
+  }
+  removeAll(predicate) {
+    return this.where(this._negate(predicate));
+  }
+  removeAt(index) {
+    this._entities.splice(index, 1);
+  }
+  reverse() {
+    return this._entities ? new List(this._entities.reverse(), this.model) : new List();
+  }
+  select(mapper) {
+    return this._entities.map(mapper);
+  }
+  single(predicate) {
+    if (this.count(predicate) !== 1) {
+      throw new Error("Item does not contain one element.");
+    } else {
+      return this.first(predicate);
+    }
+  }
+  singleOrDefault(predicate) {
+    return this.count() ? this.first(predicate) : void 0;
+  }
+  shift() {
+    return this._entities ? this._entities.shift() : void 0;
+  }
+  skip(amount) {
+    return new List(this._entities.slice(Math.max(0, amount)), this.model);
+  }
+  sum(transform) {
+    let result = this.select(transform);
+    if (transform) {
+      let sum = 0;
+      if (result)
+        result.forEach((t) => sum += t);
+      return sum;
+    } else
+      return this.aggregate((ac, v) => ac += +v, 0);
+  }
+  take(amount) {
+    return new List(this._entities.slice(0, Math.max(0, amount)), this.model);
+  }
+  search(value, filterColumns) {
+    var filter = [];
+    this._entities.forEach((t) => {
+      if (this.wildcardSearch(t, value, filterColumns))
+        filter.push(t);
+    });
+    return new List(filter, this.model);
+  }
+  wildcardSearch(row, prefix, filterColumns) {
+    let isMatched = false;
+    for (var i = 0, j = filterColumns.length; i < j; i++) {
+      var t = filterColumns[i];
+      var columnValue = String(row[t]);
+      if (this.isExist(columnValue, prefix)) {
+        isMatched = true;
+        break;
+      }
+    }
+    return isMatched;
+  }
+  isExist(columnValue, prefix) {
+    if (columnValue == null) {
+      return false;
+    }
+    return String(columnValue).toLowerCase().includes(String(prefix).toLowerCase());
+  }
+  get toLocaleString() {
+    return this._entities ? this._entities.toLocaleString() : null;
+  }
+  get toString() {
+    return this._entities ? this._entities.toString() : null;
+  }
+  get values() {
+    return this._entities;
+  }
+  _negate(predicate) {
+    return function() {
+      const _arg = arguments;
+      return !predicate.apply(this, _arg);
+    };
+  }
+  customSort(predicate, orderByDescending) {
+    return (a, b) => {
+      const first = predicate(a);
+      const second = predicate(b);
+      if (first > second) {
+        return !orderByDescending ? 1 : -1;
+      } else if (first < second) {
+        return !orderByDescending ? -1 : 1;
+      } else {
+        return 0;
+      }
+    };
+  }
+  build(values) {
+    if (values && values.length > 0) {
+      this.addRange(values);
+    }
+  }
+  createObject(object) {
+    if (this.model && object.constructor !== this.model)
+      return getObject(this.model, [], object, this.props);
+    return object;
+  }
+}
+
+exports.ALLOW_METHODS = ALLOW_METHODS;
+exports.ActionFilter = ActionFilter;
+exports.AuthenticationFilter = AuthenticationFilter;
+exports.AuthorizationFilter = AuthorizationFilter;
+exports.BACK_SLASH_REGEX = BACK_SLASH_REGEX;
+exports.BLANK = BLANK;
+exports.CONTROLLER = CONTROLLER;
+exports.DEFAULT_ACTIONS = DEFAULT_ACTIONS;
+exports.DEFAULT_CHILD_PATH = DEFAULT_CHILD_PATH;
+exports.DELETE = DELETE;
+exports.ENVIRONMENTS = ENVIRONMENTS;
+exports.ExceptionFilter = ExceptionFilter;
+exports.GET = GET;
+exports.HTTP_METHOD_ROUTES = HTTP_METHOD_ROUTES;
+exports.IGNORE_METHODS = IGNORE_METHODS;
+exports.List = List;
+exports.MetaConfigProps = MetaConfigProps;
+exports.Middleware = Middleware;
+exports.POST = POST;
+exports.PUT = PUT;
+exports.RIGHT_SLASH = RIGHT_SLASH;
+exports.ROUTE_INSTANCES = ROUTE_INSTANCES;
+exports.ROUTE_METHODS = ROUTE_METHODS;
+exports.ROUTE_PATHS = ROUTE_PATHS;
+exports.TS_EXTENSION = TS_EXTENSION;
+exports.UserIdentity = UserIdentity;
+exports.commonContainer = commonContainer;
+exports.createPath = createPath;
+exports.createTestServer = createTestServer;
+exports.getPath = getPath;
+exports.isConstructor = isConstructor;
+exports.isEqual = isEqual;
+exports.isFunction = isFunction;
+exports.isObject = isObject;
+exports.readEnv = readEnv;
+exports.readEnvKey = readEnvKey;
+exports.typeContainer = typeContainer;

package/dist/index.d.ts

@@ -0,0 +1,203 @@
+import { RequestRouteInfo, IHttpResult, IModelBindingContext, ProblemDetail, IExceptionContext, HttpResponseInit, NattyTestModule, ModelBinding, BuildOptions, ClassTypeInfo } from '@nattyjs/types';
+
+interface ClassType<T> extends Function {
+    new (...args: any[]): T;
+}
+
+declare class UserIdentity<T> {
+    isAuthenticate: boolean;
+    id?: any;
+    claim?: T;
+    constructor(isAuthenticate: boolean, id?: any, claim?: T);
+}
+
+interface IExecutionContext {
+    resolveService<T>(instance: ClassType<T>): T;
+    routeInfo: RequestRouteInfo;
+    get request(): any;
+    get user(): UserIdentity<any>;
+    result: IHttpResult;
+}
+
+interface IActionExecutedContext extends IExecutionContext {
+    content: any;
+}
+
+interface IActionExecutingContext extends IExecutionContext {
+    models: IModelBindingContext[];
+}
+
+declare abstract class ActionFilter {
+    onActionExecuting(context: IActionExecutingContext): Promise<void>;
+    onActionExecuted(context: IActionExecutedContext): Promise<void>;
+}
+
+declare abstract class AuthenticationFilter {
+    abstract onAuthentication(context: any): Promise<UserIdentity<any>>;
+    onFailedResponse(): ProblemDetail;
+}
+
+declare abstract class AuthorizationFilter {
+    abstract onAuthorization(httpContext: any, permissionRequirement: any): Promise<boolean>;
+    onFailedAuthorization(): ProblemDetail;
+}
+
+declare abstract class ExceptionFilter {
+    abstract onException(context: IExceptionContext): HttpResponseInit;
+}
+
+interface GlobalConfig {
+    authentication?: ClassType<AuthenticationFilter>;
+    authorization?: ClassType<AuthorizationFilter>;
+    actionFilters?: ClassType<ActionFilter>[];
+    onException?: ClassType<ExceptionFilter>;
+}
+
+interface NattyConfig {
+    app: any;
+    testModule?: NattyTestModule;
+    api?: {
+        rootPath: string;
+    };
+    modelBinding?: ModelBinding;
+    global?: GlobalConfig;
+}
+
+declare const commonContainer: {
+    setupConfig(config?: NattyConfig): void;
+    setupBuildOptions(options: BuildOptions): any;
+    get nattyConfig(): NattyConfig;
+    get buildOptions(): BuildOptions;
+    get envTsDefinition(): {
+        [key: string]: string;
+    };
+    setEnvTsDefinition(tsDefinition: {
+        [key: string]: string;
+    }): void;
+    setMetadata(key: string, value: any, propName: string): void;
+    getMetadataValue(key: string, propName: string): any;
+    get globalConfig(): GlobalConfig;
+};
+
+declare const typeContainer: {
+    setControllerJsonSchema(classInfo: ClassTypeInfo): void;
+    getControllersJsonSchema(): ClassTypeInfo[];
+    getRoutes(): any;
+    getControllerJsonSchema(name: string): ClassTypeInfo;
+    removeControllerInfo(path: string): void;
+};
+
+declare function createTestServer(): any;
+
+declare const CONTROLLER: string;
+declare const ENVIRONMENTS: string;
+declare const BLANK: string;
+declare const GET: string;
+declare const POST: string;
+declare const PUT: string;
+declare const DELETE: string;
+declare const ALLOW_METHODS: string[];
+declare const IGNORE_METHODS: string;
+declare const ROUTE_METHODS: string;
+declare const ROUTE_INSTANCES: string;
+declare const ROUTE_PATHS: string;
+declare const HTTP_METHOD_ROUTES: string;
+declare const isConstructor: (value: any) => boolean;
+declare const isFunction: (value: any) => boolean;
+declare const DEFAULT_ACTIONS: string[];
+declare const MetaConfigProps: {
+    services: string;
+};
+declare const DEFAULT_CHILD_PATH: string;
+declare const TS_EXTENSION: string;
+declare const BACK_SLASH_REGEX: RegExp;
+declare const RIGHT_SLASH: string;
+
+declare function readEnv(): Promise<{
+    [key: string]: any;
+}>;
+
+declare abstract class Middleware {
+    abstract use(httpContext: any): Boolean | Promise<Boolean>;
+}
+
+declare function getPath(pathCollection: string[], isIncludeRoot?: boolean, isCreateFolder?: boolean): string;
+
+declare function readEnvKey(key: string): any;
+
+declare function createPath(pathToCreate: any): boolean;
+
+interface Claim {
+    key: string;
+    value: any;
+}
+
+declare class List<T> {
+    private model?;
+    props?: {
+        [key: string]: string;
+    };
+    private _entities;
+    constructor(values?: T[] | any[], model?: ClassType<T>, props?: {
+        [key: string]: string;
+    });
+    add(entity: T): void;
+    addRange(entities: T[]): void;
+    all(predicate: (value?: T, index?: number, list?: T[]) => boolean): boolean;
+    any(predicate: (value?: T, index?: number, list?: T[]) => boolean): boolean;
+    average(transform?: (value?: T, index?: number, list?: T[]) => any): number;
+    contains(element: T): boolean;
+    concat(items: T[] | any[]): List<T>;
+    count(predicate?: (value?: T, index?: number, list?: T[]) => boolean): number;
+    where(predicate: (value?: T, index?: number, list?: T[]) => boolean): List<T>;
+    distinct(): List<T>;
+    distinctBy(keySelector: (key: T) => string | number): List<T>;
+    elementAt(index: number): T;
+    except(collection: List<T>): List<T>;
+    first(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
+    firstOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
+    forEach(action: (value?: T, index?: number, list?: T[]) => any): void;
+    aggregate<U>(accumulator: (accum: U, value?: T, index?: number, list?: T[]) => any, initialValue?: U): any;
+    groupBy(grouper: (key: T) => any, mapper?: (element: T) => any): any;
+    insert(index: number, element: T): void | Error;
+    join(seperator?: string): string;
+    last(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T;
+    lastOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | Error;
+    get length(): number;
+    max(): number;
+    max(predicate: (value: T, index: number, list: T[]) => number): number;
+    maxBy(keySelector: (key: T) => number): T;
+    min(): number;
+    min(predicate: (value: T, index: number, list: T[]) => number): number;
+    minBy(keySelector: (key: T) => number): T;
+    orderBy(predicate: (key: T) => any): List<T>;
+    orderByDescending(predicate: (key: T) => any): List<T>;
+    pop(): T | undefined;
+    indexOf(element: T): number;
+    remove(element: T): boolean;
+    removeAll(predicate: (value?: T, index?: number, list?: T[]) => boolean): List<T>;
+    removeAt(index: number): void;
+    reverse(): List<T>;
+    select(mapper: (value?: T, index?: number, list?: T[]) => any): any;
+    single(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | Error;
+    singleOrDefault(predicate?: (value?: T, index?: number, list?: T[]) => boolean): T | Error;
+    shift(): T | undefined;
+    skip(amount: number): List<T>;
+    sum(transform?: (value?: T, index?: number, list?: T[]) => number): number;
+    take(amount: number): List<T>;
+    search(value: any, filterColumns: string[]): List<T>;
+    private wildcardSearch;
+    private isExist;
+    get toLocaleString(): string;
+    get toString(): string;
+    get values(): T[];
+    private _negate;
+    private customSort;
+    private build;
+    private createObject;
+}
+
+declare function isObject(value: any): boolean;
+declare function isEqual(first: any, second: any): boolean;
+
+export { ALLOW_METHODS, ActionFilter, AuthenticationFilter, AuthorizationFilter, BACK_SLASH_REGEX, BLANK, CONTROLLER, Claim, ClassType, DEFAULT_ACTIONS, DEFAULT_CHILD_PATH, DELETE, ENVIRONMENTS, ExceptionFilter, GET, GlobalConfig, HTTP_METHOD_ROUTES, IActionExecutedContext, IActionExecutingContext, IExecutionContext, IGNORE_METHODS, List, MetaConfigProps, Middleware, NattyConfig, POST, PUT, RIGHT_SLASH, ROUTE_INSTANCES, ROUTE_METHODS, ROUTE_PATHS, TS_EXTENSION, UserIdentity, commonContainer, createPath, createTestServer, getPath, isConstructor, isEqual, isFunction, isObject, readEnv, readEnvKey, typeContainer };

package/dist/index.mjs

@@ -0,0 +1,544 @@
+import * as fs from 'fs';
+import { existsSync } from 'fs';
+import * as dotenv from 'dotenv';
+import * as dotenvExpand from 'dotenv-expand';
+import * as path from 'path';
+
+const commonContainer = new class {
+  constructor() {
+    this.metadataConfig = { services: /* @__PURE__ */ new Map() };
+  }
+  setupConfig(config) {
+    const modelBinding = {
+      errorMessage: {
+        typed: {
+          number: "Invalid numeric value of '{0}'.",
+          boolean: "Invalid boolean value of '{0}'."
+        }
+      }
+    };
+    this.nattyConfig = { ...{ api: { rootPath: "api" }, modelBinding, globalConfig: {} }, ...config };
+  }
+  setupBuildOptions(options) {
+    this.buildOptions = options;
+  }
+  setEnvTsDefinition(tsDefinition) {
+    this.envTsDefinition = tsDefinition;
+  }
+  setMetadata(key, value, propName) {
+    this.metadataConfig[propName].set(key, value);
+  }
+  getMetadataValue(key, propName) {
+    return this.metadataConfig[propName].get(key);
+  }
+  get globalConfig() {
+    return this.nattyConfig.global || {};
+  }
+}();
+
+const CONTROLLER = "controller";
+const ENVIRONMENTS = "environments";
+const BLANK = "";
+const GET = "get";
+const POST = "post";
+const PUT = "put";
+const DELETE = "delete";
+const ALLOW_METHODS = [GET, POST, PUT, DELETE];
+const IGNORE_METHODS = "IGNORE:METHODS";
+const ROUTE_METHODS = "ROUTE:METHODS";
+const ROUTE_INSTANCES = "ROUTE:INSTANCES";
+const ROUTE_PATHS = "ROUTE:PATHS";
+const HTTP_METHOD_ROUTES = "HTTPMETHOD:ROUTES";
+const isConstructor = (value) => value === "constructor";
+const isFunction = (value) => typeof value === "function";
+const DEFAULT_ACTIONS = [GET, POST, PUT, DELETE];
+const MetaConfigProps = {
+  services: "services"
+};
+const DEFAULT_CHILD_PATH = "/";
+const TS_EXTENSION = ".ts";
+const BACK_SLASH_REGEX = /\\/g;
+const RIGHT_SLASH = "/";
+
+const typeContainer = new class {
+  constructor() {
+    this.controllerInfo = /* @__PURE__ */ new Map();
+    this.files = /* @__PURE__ */ new Map();
+    this.routes = {};
+  }
+  setControllerJsonSchema(classInfo) {
+    const className = this.files.get(classInfo.filePath);
+    const isChanged = !className ? false : className != classInfo.name;
+    if (isChanged)
+      this.controllerInfo.delete(className);
+    this.controllerInfo.set(classInfo.name, classInfo);
+    this.files.set(classInfo.filePath, classInfo.name);
+  }
+  getControllersJsonSchema() {
+    const items = new Array();
+    this.controllerInfo.forEach((t) => items.push(t));
+    return items;
+  }
+  getControllerRouteName(classInfo) {
+    const controllerName = classInfo.name;
+    if (classInfo.route?.route) {
+      return classInfo.route.route;
+    }
+    return controllerName.substr(0, controllerName.length - 10).toLowerCase();
+  }
+  getRoutes() {
+    const routes = {};
+    for (const key of this.controllerInfo.keys()) {
+      const classInfo = this.controllerInfo.get(key);
+      let templateInfo = {
+        path: `.${classInfo.filePath.replace(TS_EXTENSION, BLANK).replace(BACK_SLASH_REGEX, RIGHT_SLASH)}`,
+        route: this.getControllerRouteName(classInfo),
+        parameters: classInfo.constructorParameters
+      };
+      for (const method of classInfo.methods) {
+        const routeInfo = method.route = this.getRouteInfo(method);
+        let httpMethod = routeInfo?.httpMethod;
+        if (DEFAULT_ACTIONS.indexOf(method.name) > -1)
+          httpMethod = method.name;
+        if (!templateInfo[httpMethod])
+          templateInfo[httpMethod] = {};
+        let route = this.getRoutePath(method, httpMethod);
+        let parameters = [];
+        for (const parameterInfo of method.parameters) {
+          parameters.push({ name: parameterInfo.name, type: parameterInfo.type });
+        }
+        templateInfo[httpMethod][route] = { name: method.name, parameters, returnType: method.returnType };
+      }
+      routes[templateInfo.route] = templateInfo;
+    }
+    return routes;
+  }
+  getRouteInfo(methodInfo) {
+    let route = methodInfo.route;
+    const parameters = methodInfo.parameters || [];
+    if (!route && methodInfo.name == "getBy") {
+      route = {
+        httpMethod: "get",
+        route: parameters.filter((t) => t.name == "id").map((t) => `:${t.name}`).join("/")
+      };
+    } else if (!route && methodInfo.name == "put") {
+      const parameter = parameters.filter((t) => t.name == "id")[0];
+      if (parameter) {
+        route = {
+          httpMethod: "put",
+          route: ":id"
+        };
+      }
+    }
+    return route;
+  }
+  getRoutePath(method, httpMethod) {
+    const route = method.route;
+    let routePath = method.route?.route || DEFAULT_CHILD_PATH;
+    if (!route && httpMethod == DELETE && method.parameters) {
+      const parameter = method.parameters.filter((parameterInfo) => parameterInfo.name == "id")[0];
+      if (parameter)
+        routePath = ":id";
+    }
+    return routePath;
+  }
+  removeControllerInfo(path) {
+    const name = this.files.get(path);
+    if (name) {
+      this.files.delete(path);
+      this.controllerInfo.delete(name);
+    }
+  }
+  getControllerJsonSchema(name) {
+    return this.controllerInfo.get(name);
+  }
+}();
+
+function createTestServer() {
+  const test = require("./build");
+  console.log(test);
+  return test;
+}
+
+function tsDefinition(value) {
+  const definition = /^(true|false)+$/i.test(value) ? "boolean" : /^[0-9]+$/.test(value) ? "number" : "string";
+  const transformValue = definition === "boolean" ? Boolean(value) : definition === "number" ? Number(value) : value;
+  return { definition, transformValue };
+}
+
+function getEnvTsDefinition(parsed) {
+  let serverTypedDefinition = {};
+  if (parsed) {
+    const keys = Object.keys(parsed);
+    if (keys.length > 0) {
+      keys.forEach((key) => {
+        let keyName = key;
+        const { definition, transformValue } = tsDefinition(parsed[key]);
+        serverTypedDefinition[keyName] = definition;
+      });
+    }
+  }
+  return serverTypedDefinition;
+}
+
+function createPath(pathToCreate) {
+  var isNotExits = false;
+  pathToCreate.split(path.sep).reduce((prevPath, folder) => {
+    const currentPath = path.join(prevPath, folder, path.sep);
+    isNotExits = !fs.existsSync(currentPath);
+    if (isNotExits) {
+      fs.mkdirSync(currentPath);
+    }
+    return currentPath;
+  }, "");
+  return isNotExits;
+}
+
+function getPath(pathCollection, isIncludeRoot = true, isCreateFolder = false) {
+  const rootPath = isIncludeRoot ? [commonContainer.buildOptions.rootDir] : [];
+  const currentPath = path.join(...rootPath, ...pathCollection);
+  if (isCreateFolder)
+    createPath(currentPath);
+  return currentPath;
+}
+
+async function readEnv() {
+  let filePath = getPath([ENVIRONMENTS, commonContainer.buildOptions.mode && commonContainer.buildOptions.mode !== "dev" ? `.env.${commonContainer.buildOptions.mode}` : `.env`]);
+  let parsedEnvTsDefinition = {};
+  if (existsSync(filePath)) {
+    const { parsed, error } = dotenv.config({
+      debug: !!process.env.DEBUG || void 0,
+      path: filePath
+    });
+    parsedEnvTsDefinition = getEnvTsDefinition(parsed);
+    commonContainer.setEnvTsDefinition(parsedEnvTsDefinition);
+    dotenvExpand.expand({ parsed });
+  }
+  return parsedEnvTsDefinition;
+}
+
+class AuthenticationFilter {
+  onFailedResponse() {
+    return {
+      type: "https://tools.ietf.org/html/rfc7235#section-3.1",
+      title: "Unauthorized"
+    };
+  }
+}
+
+class AuthorizationFilter {
+  onFailedAuthorization() {
+    return {
+      type: "https://tools.ietf.org/html/rfc7231#section-6.5.3",
+      title: "Forbidden"
+    };
+  }
+}
+
+class ActionFilter {
+  onActionExecuting(context) {
+    return;
+  }
+  onActionExecuted(context) {
+    return;
+  }
+}
+
+class Middleware {
+}
+
+class ExceptionFilter {
+}
+
+function readEnvKey(key) {
+  const definition = commonContainer.envTsDefinition[key];
+  const value = process.env[key];
+  let transformValue = value;
+  if (definition) {
+    transformValue = definition === "boolean" ? value === "true" : definition === "number" ? Number(value) : value;
+  }
+  return transformValue;
+}
+
+class UserIdentity {
+  constructor(isAuthenticate, id, claim) {
+    this.isAuthenticate = isAuthenticate;
+    this.id = id;
+    this.claim = claim;
+  }
+}
+
+function isObject(value) {
+  return !!value && typeof value === "object" && !(value instanceof Date);
+}
+function isEqual(first, second) {
+  return Object.entries(first).every(
+    ([key, value]) => isObject(value) ? isEqual(second[key], value) : second[key] === value
+  );
+}
+
+function getInstance(model, objectArguments) {
+  return Reflect.construct(model, objectArguments);
+}
+function getObject(model, objectArguments, jObject, props) {
+  let instance = getInstance(model, objectArguments);
+  Object.keys(jObject).forEach((t) => {
+    const currentPropName = t.toLowerCase();
+    if (props) {
+      const propName = props[currentPropName];
+      if (propName)
+        instance[propName] = jObject[t];
+    } else
+      instance[t] = jObject[t];
+  });
+  return instance;
+}
+
+class List {
+  constructor(values, model, props) {
+    this.model = model;
+    this.props = props;
+    this._entities = new Array();
+    this.build(values);
+  }
+  add(entity) {
+    this._entities.push(this.createObject(entity));
+  }
+  addRange(entities) {
+    for (let entity of entities)
+      this.add(entity);
+  }
+  all(predicate) {
+    return this._entities.every(predicate);
+  }
+  any(predicate) {
+    return this._entities.some(predicate);
+  }
+  average(transform) {
+    return this.sum(transform) / this.count(transform);
+  }
+  contains(element) {
+    return this._entities.some((x) => x === element);
+  }
+  concat(items) {
+    if (items) {
+      this.addRange(items);
+      return new List(this._entities, this.model);
+    }
+    return void 0;
+  }
+  count(predicate) {
+    return predicate ? this.where(predicate).count() : this._entities.length;
+  }
+  where(predicate) {
+    return new List(this._entities.filter(predicate), this.model);
+  }
+  distinct() {
+    return this.where(
+      (value, index, iter) => isObject(value) ? iter.findIndex((t) => isEqual(t, value)) == index : iter.indexOf(value) === index
+    );
+  }
+  distinctBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    return Object.keys(entityGroup).reduce((resource, key) => {
+      resource.add(entityGroup[key][0]);
+      return resource;
+    }, new List());
+  }
+  elementAt(index) {
+    if (this._entities.length > index && index >= 0)
+      return this._entities[index];
+  }
+  except(collection) {
+    return this.where((x) => !collection.contains(x));
+  }
+  first(predicate) {
+    if (this.count()) {
+      return predicate ? this.where(predicate).first() : this._entities[0];
+    } else {
+      throw new Error("No result found.");
+    }
+  }
+  firstOrDefault(predicate) {
+    return this.count() ? this.first(predicate) : void 0;
+  }
+  forEach(action) {
+    return this._entities.forEach(action);
+  }
+  aggregate(accumulator, initialValue) {
+    return this._entities.reduce(accumulator, initialValue);
+  }
+  groupBy(grouper, mapper) {
+    if (!mapper)
+      mapper = (value) => value;
+    return this.aggregate((ac, v) => (ac[grouper(v)] ? ac[grouper(v)].push(mapper(v)) : ac[grouper(v)] = [mapper(v)], ac), {});
+  }
+  insert(index, element) {
+    if (index < 0 || index > this._entities.length) {
+      throw new Error("Index is out of range.");
+    }
+    this._entities.splice(index, 0, this.createObject(element));
+  }
+  join(seperator) {
+    return this._entities ? this._entities.join(seperator) : null;
+  }
+  last(predicate) {
+    if (this.count()) {
+      return predicate ? this.where(predicate).last() : this._entities[this.count() - 1];
+    } else {
+      throw Error("No result found.");
+    }
+  }
+  lastOrDefault(predicate) {
+    return this.count() ? this.last(predicate) : void 0;
+  }
+  get length() {
+    return this._entities ? this._entities.length : 0;
+  }
+  max(predicate) {
+    if (!predicate)
+      return this.aggregate((x, y) => x > y ? x : y);
+    else
+      return Math.max(...this._entities.map(predicate));
+  }
+  maxBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    let keys = Object.keys(entityGroup);
+    let maxKey = Math.max(...keys);
+    return entityGroup[maxKey][0];
+  }
+  min(predicate) {
+    if (!predicate)
+      return this.aggregate((x, y) => x < y ? x : y);
+    else
+      return Math.min(...this._entities.map(predicate));
+  }
+  minBy(keySelector) {
+    const entityGroup = this.groupBy(keySelector);
+    let keys = Object.keys(entityGroup);
+    let minKey = Math.min(...keys);
+    return entityGroup[minKey][0];
+  }
+  orderBy(predicate) {
+    return new List(this._entities.sort(this.customSort(predicate, false)));
+  }
+  orderByDescending(predicate) {
+    return new List(this._entities.sort(this.customSort(predicate, true)));
+  }
+  pop() {
+    return this._entities.pop();
+  }
+  indexOf(element) {
+    return this._entities.indexOf(element);
+  }
+  remove(element) {
+    return this._entities.indexOf(element) !== -1 ? (this.removeAt(this._entities.indexOf(element)), true) : false;
+  }
+  removeAll(predicate) {
+    return this.where(this._negate(predicate));
+  }
+  removeAt(index) {
+    this._entities.splice(index, 1);
+  }
+  reverse() {
+    return this._entities ? new List(this._entities.reverse(), this.model) : new List();
+  }
+  select(mapper) {
+    return this._entities.map(mapper);
+  }
+  single(predicate) {
+    if (this.count(predicate) !== 1) {
+      throw new Error("Item does not contain one element.");
+    } else {
+      return this.first(predicate);
+    }
+  }
+  singleOrDefault(predicate) {
+    return this.count() ? this.first(predicate) : void 0;
+  }
+  shift() {
+    return this._entities ? this._entities.shift() : void 0;
+  }
+  skip(amount) {
+    return new List(this._entities.slice(Math.max(0, amount)), this.model);
+  }
+  sum(transform) {
+    let result = this.select(transform);
+    if (transform) {
+      let sum = 0;
+      if (result)
+        result.forEach((t) => sum += t);
+      return sum;
+    } else
+      return this.aggregate((ac, v) => ac += +v, 0);
+  }
+  take(amount) {
+    return new List(this._entities.slice(0, Math.max(0, amount)), this.model);
+  }
+  search(value, filterColumns) {
+    var filter = [];
+    this._entities.forEach((t) => {
+      if (this.wildcardSearch(t, value, filterColumns))
+        filter.push(t);
+    });
+    return new List(filter, this.model);
+  }
+  wildcardSearch(row, prefix, filterColumns) {
+    let isMatched = false;
+    for (var i = 0, j = filterColumns.length; i < j; i++) {
+      var t = filterColumns[i];
+      var columnValue = String(row[t]);
+      if (this.isExist(columnValue, prefix)) {
+        isMatched = true;
+        break;
+      }
+    }
+    return isMatched;
+  }
+  isExist(columnValue, prefix) {
+    if (columnValue == null) {
+      return false;
+    }
+    return String(columnValue).toLowerCase().includes(String(prefix).toLowerCase());
+  }
+  get toLocaleString() {
+    return this._entities ? this._entities.toLocaleString() : null;
+  }
+  get toString() {
+    return this._entities ? this._entities.toString() : null;
+  }
+  get values() {
+    return this._entities;
+  }
+  _negate(predicate) {
+    return function() {
+      const _arg = arguments;
+      return !predicate.apply(this, _arg);
+    };
+  }
+  customSort(predicate, orderByDescending) {
+    return (a, b) => {
+      const first = predicate(a);
+      const second = predicate(b);
+      if (first > second) {
+        return !orderByDescending ? 1 : -1;
+      } else if (first < second) {
+        return !orderByDescending ? -1 : 1;
+      } else {
+        return 0;
+      }
+    };
+  }
+  build(values) {
+    if (values && values.length > 0) {
+      this.addRange(values);
+    }
+  }
+  createObject(object) {
+    if (this.model && object.constructor !== this.model)
+      return getObject(this.model, [], object, this.props);
+    return object;
+  }
+}
+
+export { ALLOW_METHODS, ActionFilter, AuthenticationFilter, AuthorizationFilter, BACK_SLASH_REGEX, BLANK, CONTROLLER, DEFAULT_ACTIONS, DEFAULT_CHILD_PATH, DELETE, ENVIRONMENTS, ExceptionFilter, GET, HTTP_METHOD_ROUTES, IGNORE_METHODS, List, MetaConfigProps, Middleware, POST, PUT, RIGHT_SLASH, ROUTE_INSTANCES, ROUTE_METHODS, ROUTE_PATHS, TS_EXTENSION, UserIdentity, commonContainer, createPath, createTestServer, getPath, isConstructor, isEqual, isFunction, isObject, readEnv, readEnvKey, typeContainer };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@nattyjs/common",
+  "version": "0.0.1-beta.0",
+  "description": "Now I’m the model of a modern major general / The venerated Virginian veteran whose men are all / Lining up, to put me up on a pedestal / Writin’ letters to relatives / Embellishin’ my elegance and eloquence / But the elephant is in the room / The truth is in ya face when ya hear the British cannons go / BOOM",
+  "keywords": [],
+  "author": "ajayojha <ojhaajay@outlook.com>",
+  "license": "ISC",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild"
+  },
+  "devDependencies": {
+    "@types/node": "20.3.1",
+    "@nattyjs/types": "0.0.1-beta.0",
+    "unbuild": "1.2.1",
+    "dotenv-expand": "10.0.0"
+  }
+}