types.ts

import { RouterContext, Status } from "./deps.ts";

// Copyright 2020 Liam Tan. All rights reserved. MIT license.
export enum HttpMethod {
  GET = "get",
  POST = "post",
  PUT = "put",
  PATCH = "patch",
  DELETE = "delete",
}
/**
 * All parameter decorator types. When a route argument is declared
 * using a parameter decorator, the correct `ArgsType` is assigned
 * so that at runtime `Router` can determine where to retreive the
 * data from
 */
export enum ArgsType {
  PARAM = "param",
  BODY = "body",
  QUERY = "query",
  HEADER = "header",
  CONTEXT = "context",
  REQUEST = "request",
  RESPONSE = "response",
  COOKIE = "cookie",
  INJECT = "inject",
}

/**
 * Metadata shape describing a controller and its
 * subsidiary routes. Includes all data in addtion
 * to routes like controller action args, response
 * codes
 */
export interface ControllerMetadata {
  prefix: string | null;
  scope: EInjectionScope;
  routes: Map<string | Symbol, RouteDefinition>;
  defaultResponseCodes: Map<string | Symbol, number>;
  args: RouteArgument[];
  beforeFns: Map<string, Array<Function>>;
}

/**
 * Route definition metadata, as mapped to a controller
 * action. Consumed in `ControllerMetadata` to build
 * routes that oak understands
 */
export interface RouteDefinition {
  path: string;
  requestMethod: HttpMethod;
  methodName: string | Symbol;
}
/**
 * Definition for a parameter decorator on a controller
 * action.
 */
export interface RouteArgument {
  type: ArgsType;
  index: number;
  key: string | undefined;
  argFor: string | Symbol;
}
/**
 * Definition for parameter decorator to apply a `@Before`
 * function to be called before action is executed
 */
export interface BeforeDefinition {
  functionFor: string | Symbol;
  fn: Function;
}
/**
 * Root config for the `Application` class.
 */
export interface ApplicationConfig {
  controllers: Array<Newable<any>>;
  injectables: Array<Newable<any>>;
}
/**
 * Definition for a class.
 */
export interface Newable<T> {
  new (...args: any[]): T;
}
/**
 * Structure of callback to be applied to Oak
 * router
 */
export type ControllerCallback = (context: RouterContext) => Promise<void>;

/**
 * Injection scope. Used by the `@Injectable` decorator
 * to determine lifetime of dependency
 */
export enum EInjectionScope {
  SINGLETON = "singleton",
  TRANSIENT = "transient",
  REQUEST = "request",
}

/**
 * Definition consumable by `DependencyContainer` class
 */
export interface DependencyDefinition {
  scope: EInjectionScope;
  newable: Newable<any>;
}
/**
 * Result of execution container
 */
export interface ExecutionResult {
  success: boolean;
  body: any;
  status: Status;
}
export interface RequestLifetime {
  requestId: string;
  resolve: (key: string) => any | null;
  end: () => void;
}