Fix last Flow type issues with Express

.flowconfig

@@ -16,11 +16,11 @@
 <PROJECT_ROOT>/services/rest2tasks/
 <PROJECT_ROOT>/services/webhook-handler/
 <PROJECT_ROOT>/services/webhooks2tasks/
-<PROJECT_ROOT>/node-packages/commons/
 
 [include]
 
 [libs]
+flow-typed
 cli/flow-typed
 services/api/flow-typed
 services/auth-server/flow-typed

.prettierignore

@@ -1 +1,2 @@
-package.json
+package.json
+**/flow-typed/**

flow-typed/custom/express_v4.16.x.js

@@ -0,0 +1,311 @@
+// flow-typed signature: 106bbf49ff0c0b351c95d483d617ffba
+// flow-typed version: 7fe23c8e85/express_v4.16.x/flow_>=v0.32.x
+
+import type { Server } from "http";
+import type { Socket } from "net";
+
+declare type express$RouterOptions = {
+  caseSensitive?: boolean,
+  mergeParams?: boolean,
+  strict?: boolean
+};
+
+declare class express$RequestResponseBase {
+  app: express$Application;
+  get(field: string): string | void;
+}
+
+declare type express$RequestParams = {
+  [param: string]: string
+};
+
+declare class express$Request extends http$IncomingMessage mixins express$RequestResponseBase {
+  baseUrl: string;
+  body: mixed;
+  cookies: { [cookie: string]: string };
+  connection: Socket;
+  fresh: boolean;
+  hostname: string;
+  ip: string;
+  ips: Array<string>;
+  method: string;
+  originalUrl: string;
+  params: express$RequestParams;
+  path: string;
+  protocol: "https" | "http";
+  query: { [name: string]: string | Array<string> };
+  route: string;
+  secure: boolean;
+  signedCookies: { [signedCookie: string]: string };
+  stale: boolean;
+  subdomains: Array<string>;
+  xhr: boolean;
+  accepts(types: string): string | false;
+  accepts(types: Array<string>): string | false;
+  acceptsCharsets(...charsets: Array<string>): string | false;
+  acceptsEncodings(...encoding: Array<string>): string | false;
+  acceptsLanguages(...lang: Array<string>): string | false;
+  header(field: string): string | void;
+  is(type: string): boolean;
+  param(name: string, defaultValue?: string): string | void;
+}
+
+declare type express$CookieOptions = {
+  domain?: string,
+  encode?: (value: string) => string,
+  expires?: Date,
+  httpOnly?: boolean,
+  maxAge?: number,
+  path?: string,
+  secure?: boolean,
+  signed?: boolean
+};
+
+declare type express$Path = string | RegExp;
+
+declare type express$RenderCallback = (
+  err: Error | null,
+  html?: string
+) => mixed;
+
+declare type express$SendFileOptions = {
+  maxAge?: number,
+  root?: string,
+  lastModified?: boolean,
+  headers?: { [name: string]: string },
+  dotfiles?: "allow" | "deny" | "ignore"
+};
+
+declare class express$Response extends http$ServerResponse mixins express$RequestResponseBase {
+  headersSent: boolean;
+  locals: { [name: string]: mixed };
+  append(field: string, value?: string): this;
+  attachment(filename?: string): this;
+  cookie(name: string, value: string, options?: express$CookieOptions): this;
+  clearCookie(name: string, options?: express$CookieOptions): this;
+  download(
+    path: string,
+    filename?: string,
+    callback?: (err?: ?Error) => void
+  ): this;
+  format(typesObject: { [type: string]: Function }): this;
+  json(body?: mixed): this;
+  jsonp(body?: mixed): this;
+  links(links: { [name: string]: string }): this;
+  location(path: string): this;
+  redirect(url: string, ...args: Array<void>): this;
+  redirect(status: number, url: string, ...args: Array<void>): this;
+  render(
+    view: string,
+    locals?: { [name: string]: mixed },
+    callback?: express$RenderCallback
+  ): this;
+  send(body?: mixed): this;
+  sendFile(
+    path: string,
+    options?: express$SendFileOptions,
+    callback?: (err?: ?Error) => mixed
+  ): this;
+  sendStatus(statusCode: number): this;
+  header(field: string, value?: string): this;
+  header(headers: { [name: string]: string }): this;
+  set(field: string, value?: string | string[]): this;
+  set(headers: { [name: string]: string }): this;
+  status(statusCode: number): this;
+  type(type: string): this;
+  vary(field: string): this;
+  req: express$Request;
+}
+
+// Lagoon addition: extend Error to have status property (for auth-server)
+declare interface express$LagoonErrorWithStatus extends Error {
+  status: number;
+}
+
+declare type express$NextFunction = (err?: ?Error | "route") => mixed;
+declare type express$Middleware =
+  | ((
+      req: $Subtype<express$Request>,
+      res: express$Response,
+      next: express$NextFunction
+    ) => mixed)
+  | ((
+      // Lagoon change: extend Error to have status property (for auth-server). Original:
+      // error: Error,
+      error: express$LagoonErrorWithStatus,
+      req: $Subtype<express$Request>,
+      res: express$Response,
+      next: express$NextFunction
+    ) => mixed);
+declare interface express$RouteMethodType<T> {
+  (middleware: express$Middleware): T;
+  (...middleware: Array<express$Middleware>): T;
+  (
+    path: express$Path | express$Path[],
+    ...middleware: Array<express$Middleware>
+  ): T;
+}
+declare class express$Route {
+  all: express$RouteMethodType<this>;
+  // Lagoon change: Type relaxed to allow for modifying the context. (for api)
+  // Original:
+  // get: express$RouteMethodType<this>;
+  get: Function;
+  post: express$RouteMethodType<this>;
+  put: express$RouteMethodType<this>;
+  head: express$RouteMethodType<this>;
+  delete: express$RouteMethodType<this>;
+  options: express$RouteMethodType<this>;
+  trace: express$RouteMethodType<this>;
+  copy: express$RouteMethodType<this>;
+  lock: express$RouteMethodType<this>;
+  mkcol: express$RouteMethodType<this>;
+  move: express$RouteMethodType<this>;
+  purge: express$RouteMethodType<this>;
+  propfind: express$RouteMethodType<this>;
+  proppatch: express$RouteMethodType<this>;
+  unlock: express$RouteMethodType<this>;
+  report: express$RouteMethodType<this>;
+  mkactivity: express$RouteMethodType<this>;
+  checkout: express$RouteMethodType<this>;
+  merge: express$RouteMethodType<this>;
+
+  // @TODO Missing 'm-search' but get flow illegal name error.
+
+  notify: express$RouteMethodType<this>;
+  subscribe: express$RouteMethodType<this>;
+  unsubscribe: express$RouteMethodType<this>;
+  patch: express$RouteMethodType<this>;
+  search: express$RouteMethodType<this>;
+  connect: express$RouteMethodType<this>;
+}
+
+declare class express$Router extends express$Route {
+  constructor(options?: express$RouterOptions): void;
+  route(path: string): express$Route;
+  static (options?: express$RouterOptions): express$Router;
+  use(middleware: express$Middleware): this;
+  use(...middleware: Array<express$Middleware>): this;
+  use(
+    path: express$Path | express$Path[],
+    ...middleware: Array<express$Middleware>
+  ): this;
+  use(path: string, router: express$Router): this;
+  handle(
+    req: http$IncomingMessage,
+    res: http$ServerResponse,
+    next: express$NextFunction
+  ): void;
+  param(
+    param: string,
+    callback: (
+      req: $Subtype<express$Request>,
+      res: express$Response,
+      next: express$NextFunction,
+      id: string
+    ) => mixed
+  ): void;
+
+  // Can't use regular callable signature syntax due to https://github.com/facebook/flow/issues/3084
+  $call: (
+    req: http$IncomingMessage,
+    res: http$ServerResponse,
+    next?: ?express$NextFunction
+  ) => void;
+}
+
+/*
+With flow-bin ^0.59, express app.listen() is deemed to return any and fails flow type coverage.
+Which is ironic because https://github.com/facebook/flow/blob/master/Changelog.md#misc-2 (release notes for 0.59)
+says "Improves typings for Node.js HTTP server listen() function."  See that?  IMPROVES!
+To work around this issue, we changed Server to ?Server here, so that our invocations of express.listen() will
+not be deemed to lack type coverage.
+*/
+
+declare class express$Application extends express$Router mixins events$EventEmitter {
+  constructor(): void;
+  locals: { [name: string]: mixed };
+  mountpath: string;
+  listen(
+    port: number,
+    hostname?: string,
+    backlog?: number,
+    callback?: (err?: ?Error) => mixed
+  ): ?Server;
+  listen(
+    port: number,
+    hostname?: string,
+    callback?: (err?: ?Error) => mixed
+  ): ?Server;
+  listen(port: number, callback?: (err?: ?Error) => mixed): ?Server;
+  listen(path: string, callback?: (err?: ?Error) => mixed): ?Server;
+  listen(handle: Object, callback?: (err?: ?Error) => mixed): ?Server;
+  disable(name: string): void;
+  disabled(name: string): boolean;
+  enable(name: string): express$Application;
+  enabled(name: string): boolean;
+  engine(name: string, callback: Function): void;
+  /**
+   * Mixed will not be taken as a value option. Issue around using the GET http method name and the get for settings.
+   */
+  //   get(name: string): mixed;
+  set(name: string, value: mixed): mixed;
+  render(
+    name: string,
+    optionsOrFunction: { [name: string]: mixed },
+    callback: express$RenderCallback
+  ): void;
+  handle(
+    req: http$IncomingMessage,
+    res: http$ServerResponse,
+    next?: ?express$NextFunction
+  ): void;
+}
+
+declare type JsonOptions = {
+  inflate?: boolean,
+  limit?: string | number,
+  reviver?: (key: string, value: mixed) => mixed,
+  strict?: boolean,
+  type?: string | Array<string> | ((req: express$Request) => boolean),
+  verify?: (
+    req: express$Request,
+    res: express$Response,
+    buf: Buffer,
+    encoding: string
+  ) => mixed
+};
+
+declare type express$UrlEncodedOptions = {
+  extended?: boolean,
+  inflate?: boolean,
+  limit?: string | number,
+  parameterLimit?: number,
+  type?: string | Array<string> | ((req: express$Request) => boolean),
+  verify?: (
+    req: express$Request,
+    res: express$Response,
+    buf: Buffer,
+    encoding: string
+  ) => mixed,
+}
+
+declare module "express" {
+  declare export type RouterOptions = express$RouterOptions;
+  declare export type CookieOptions = express$CookieOptions;
+  declare export type Middleware = express$Middleware;
+  declare export type NextFunction = express$NextFunction;
+  declare export type RequestParams = express$RequestParams;
+  declare export type $Response = express$Response;
+  declare export type $Request = express$Request;
+  declare export type $Application = express$Application;
+  declare export type LagoonErrorWithStatus = express$LagoonErrorWithStatus;
+
+  declare module.exports: {
+    (): express$Application, // If you try to call like a function, it will use this signature
+    json: (opts: ?JsonOptions) => express$Middleware,
+    static: (root: string, options?: Object) => express$Middleware, // `static` property on the function
+    Router: typeof express$Router, // `Router` property on the function
+    urlencoded: (opts: ?express$UrlEncodedOptions) => express$Middleware,
+  };
+}

node-packages/.eslintrc.js

@@ -0,0 +1,45 @@
+module.exports = {
+  extends: ['airbnb-base', 'plugin:flowtype/recommended'],
+  plugins: ['flowtype'],
+  env: { es6: true, jest: true, node: true },
+  rules: {
+    // Disable stylistic rule
+    camelcase: 'off',
+    // Rule to enforce function return types. We disable this because Flow will check our function return types.
+    'consistent-return': 'off',
+    // Fix issue with the way Prettier formats types
+    'flowtype/generic-spacing': 'off',
+    // Fix issue with the way Prettier formats types
+    'flowtype/space-after-type-colon': 'off',
+    // Fix issue with the way Prettier formats function calls
+    'function-paren-newline': 'off',
+    // Disable stylistic rule
+    'global-require': 'off',
+    // Code style rule to enforce import ordering. We disable this because we use absolute imports for types sometimes after relative imports.
+    'import/first': 'off',
+    // Code style rule to prefer a default export instead of a single named export, currently we disable this to allow this behavior. We can decide later to turn this on again if we want.
+    'import/prefer-default-export': 'off',
+    // Prettier works better with its default 80 character max-length
+    'max-len': 'off',
+    // Conflicts with Prettier's stripping of unnecessary parentheses
+    'no-confusing-arrow': 'off',
+    // Rule to restrict usage of confusing code style with mixed boolean operators. We disable this because Prettier removes "unnecessary parentheses" here and breaks this.
+    'no-mixed-operators': 'off',
+    // Disable stylistic rule
+    'no-multi-assign': 'off',
+    // Disable stylistic rule
+    'no-param-reassign': 'off',
+    // Disable stylistic rule
+    'no-plusplus': 'off',
+    // Disable stylistic rule
+    'no-restricted-globals': 'off',
+    // Rule to prevent prefixing of underscores on variable names. We disable this because we use some underscore prefixes in our code.
+    'no-underscore-dangle': 'off',
+    // Disable stylistic rule
+    'no-use-before-define': 'off',
+    // Disable stylistic rule
+    'prefer-destructuring': 'off',
+    // Disable stylistic rule
+    radix: 'off',
+  },
+};

node-packages/commons/package.json

@@ -8,6 +8,10 @@
     "test": "jest"
   },
   "devDependencies": {
+    "eslint": "4.9.0",
+    "eslint-config-airbnb-base": "^12.1.0",
+    "eslint-plugin-flowtype": "^2.41.0",
+    "eslint-plugin-import": "^2.7.0",
     "jest": "^21.2.1",
     "prettier": "^1.5.3"
   },
@@ -25,6 +29,7 @@
     "jsonwebtoken": "^8.0.1",
     "lokka": "^1.7.0",
     "lokka-transport-http": "^1.6.1",
+    "prettier-eslint": "^8.8.1",
     "ramda": "^0.24.1",
     "sshpk": "^1.13.1",
     "winston": "^2.4.0",