huncwot/index.js

// Copyright 2019 Zaiste & contributors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

const debug = require('debug')('huncwot:index'); // eslint-disable-line no-unused-vars

const http = require('http');
const Stream = require('stream');
const querystring = require('querystring');
const { join } = require('path');
const { parse } = require('url');
const Busboy = require('busboy');
const Router = require('trek-router');
const httpstatus = require('http-status');

const { serve, security } = require('./middleware');
const { build, translate } = require('./controller');
const { NotFound } = require('./response');
const Logger = require('./logger');
const HTMLifiedError = require('./error');

const cwd = process.cwd();
const handlerDir = join(cwd, '.build');

const isObject = _ => !!_ && _.constructor === Object;
const compose = (...functions) => args =>
  functions.reduceRight((arg, fn) => fn(arg), args);

class Middleware extends Array {
  async next(context, last, current, done, called, func) {
    if ((done = current > this.length)) return;

    func = this[current] || last;

    return (
      func &&
      func(context, async () => {
        if (called) throw new Error('next() already called');
        called = true;
        return await this.next(context, last, current + 1);
      })
    );
  }

  async compose(context, last) {
    return await this.next(context, last, 0);
  }
}

class Huncwot {
  constructor({
    staticDir = join(cwd, 'static'),
    securityOptions = {
      dnsPrefetchControl: false,
      poweredBy: false
    },
    graphql = false,
    implicitControllers = true,
    _verbose = false
  } = {}) {
    this.middlewareList = new Middleware();
    this.router = new Router();

    if (graphql) {
      try {
        const { typeDefs, resolvers } = require(join(cwd, 'graphql'));
        const { graphql, graphiql, makeSchema } = require('./graphql');

        const schema = makeSchema({ typeDefs, resolvers });

        this.post('/graphql', graphql({ schema }));
        this.get('/graphql', graphql({ schema }));
        this.get('/graphiql', graphiql({ endpointURL: 'graphql' }));
      } catch (error) {
        switch (error.code) {
          case 'MODULE_NOT_FOUND':
            console.log('GraphQL is not set up.');
            break;
          default:
            console.error(error);
            break;
        }
      }
    }

    if (implicitControllers) {
      const handlers = build();
      for (let { resource, operation, path } of handlers) {
        try {
          const handler = require(join(handlerDir, path));
          let { method, route } = translate(operation, resource);

          console.log('-->', method, route);

          if (Array.isArray(handler)) {
            this.add(method, route, ...handler);
          } else {
            this.add(method, route, handler);
          }
        } catch (error) {
          console.error(error);
        }
      }
    }

    // this.add('GET', '/', [ serve(staticDir) ]);
    // this.add('GET', '/', [ security(securityOptions) ]);
    this.add('GET', '/', async _request => 'Hello, Huncwot'); // TODO remove that, properly handle non-existent HTML in public/
  }

  async setup() {
    // TODO
  }

  use(middleware) {
    if (typeof middleware !== 'function')
      throw new TypeError('middleware must be a function!');
    this.middlewareList.push(middleware);

    return this;
  }

  add(method, path, ...fns) {
    const action = fns.pop();

    // pipeline is a handler composed over middlewares,
    // `action` function must be explicitly extracted from the pipeline
    // as it has different signature, thus cannot be composed
    const pipeline = fns.length === 0 ? action : compose(...fns)(action);

    this.router.add(method.toUpperCase(), path, pipeline);

    return this;
  }

  start({ routes = {}, port = 5544, fn = () => {} }) {
    for (let [method, route] of Object.entries(routes)) {
      for (let [path, handler] of Object.entries(route)) {
        if (Array.isArray(handler)) {
          this.add(method, path, ...handler);
        } else {
          this.add(method, path, handler);
        }
      }
    }

    const RouterMiddleware = async (context, next) => {
      const method = context.request.method;
      const { pathname, query } = parse(context.request.url, true); // TODO Test perf vs RegEx

      const [handler, dynamicRoutes] = this.router.find(method, pathname);

      const params = {};
      for (let r of dynamicRoutes) {
        params[r.name] = r.value;
      }

      if (handler !== undefined) {
        await handleRequest(context);
        context.params = { ...context.params, ...query, ...params };
        return await handler(context);
      } else {
        return await next();
      }
    };

    this.middlewareList.push(RouterMiddleware);

    // append 404 middleware handler: it must be put at the end and only once
    // TODO Move to `catch` for pattern matching ?
    this.middlewareList.push(() => NotFound());

    const server = http.createServer((request, response) => {
      const context = { params: {}, headers: {}, request, response };

      this.middlewareList
        .compose(context)
        .then(handle(context))
        .then(() => Logger.printRequestResponse(context))
        .catch(error => {
          response.statusCode = 500;
          error.status = `500 ${httpstatus[500]}`;

          // TODO remove at runtime in `production`, keep only in `development`
          Logger.printRequestResponse(context);
          Logger.printError(error, 'HTTP');

          const htmlifiedError = new HTMLifiedError(error, request);

          htmlifiedError.generate().then(html => {
            response.writeHead(500, { 'Content-Type': 'text/html' }).end(html);
          });
        });
    }).on('error', error => {
      Logger.printError(error);
      process.exit(1);
    });

    return server.listen(port, fn);
  }
}

const handle = context => result => {
  if (null === result || undefined === result)
    throw new Error('No return statement in the handler');

  let { response } = context;

  let body, headers, type, encoding;

  if (typeof result === 'string' || result instanceof Stream) {
    body = result;
  } else {
    body = result.body;
    headers = result.headers;
    type = result.type;
    encoding = result.encoding;
  }

  response.statusCode = result.statusCode || 200;

  for (var key in headers) {
    response.setHeader(key, headers[key]);
  }

  if (encoding) response.setHeader('Content-Encoding', encoding);

  if (Buffer.isBuffer(body)) {
    response.setHeader('Content-Type', type || 'application/octet-stream');
    response.setHeader('Content-Length', body.length);
    response.end(body);
    return;
  }

  if (body instanceof Stream) {
    if (!response.getHeader('Content-Type'))
      response.setHeader('Content-Type', type || 'text/html');

    body.pipe(response);
    return;
  }

  let str = body;

  if (typeof body === 'object' || typeof body === 'number') {
    str = JSON.stringify(body);
    response.setHeader('Content-Type', 'application/json');
  } else {
    if (!response.getHeader('Content-Type'))
      response.setHeader('Content-Type', type || 'text/plain');
  }

  response.setHeader('Content-Length', Buffer.byteLength(str));
  response.end(str);
};

const handleRequest = async context => {
  const { headers } = context.request;

  context.headers = headers;
  context.cookies = parseCookies(headers.cookie);

  const buffer = await streamToString(context.request);
  if (buffer.length > 0) {
    const contentType = headers['content-type'].split(';')[0];

    switch (contentType) {
      case 'application/x-www-form-urlencoded':
        Object.assign(context.params, querystring.parse(buffer));
        break;
      case 'application/json': {
        const result = JSON.parse(buffer);
        if (isObject(result)) {
          Object.assign(context.params, result);
        }
        break;
      }
      case 'multipart/form-data': {
        context.files = {};

        const busboy = new Busboy({ headers });

        busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
          file.on('data', data => {
            context.files = {
              ...context.files,
              [fieldname]: {
                name: filename,
                length: data.length,
                data,
                encoding,
                mimetype
              }
            };
          });
          file.on('end', () => {});
        });
        busboy.on('field', (fieldname, val) => {
          context.params = { ...context.params, [fieldname]: val };
        });
        busboy.end(buffer);

        await new Promise(resolve => busboy.on('finish', resolve));

        break;
      }
      default:
    }
  }
};

const streamToString = async stream => {
  let chunks = '';

  return new Promise((resolve, reject) => {
    stream.on('data', chunk => (chunks += chunk));
    stream.on('error', reject);
    stream.on('end', () => resolve(chunks));
  });
};

const parseCookies = (cookieHeader = '') => {
  const cookies = cookieHeader.split(/; */);
  const decode = decodeURIComponent;

  if (cookies[0] === '') return {};

  const result = {};
  for (let cookie of cookies) {
    const isKeyValue = cookie.includes('=');

    if (!isKeyValue) {
      result[cookie.trim()] = true;
      continue;
    }

    let [key, value] = cookie.split('=');

    key.trim();
    value.trim();

    if ('"' === value[0]) value = value.slice(1, -1);

    try {
      value = decode(value);
    } catch (error) {
      // neglect
    }

    result[key] = value;
  }

  return result;
};

module.exports = Huncwot;