Acceptance Test for Decomposed Sequence

[superkhau]

From @ritch on April 13, 2017 17:39

@bajtos lets get on the same page for the following:

• overriding params
• augmenting the response / result
• customizing which router method is invoked
• url rewriting

and capture it as an acceptance test together.

Copied from original issue: strongloop-internal/scrum-asteroid#97

Related: #113

[ritch]

This is blocking the authentication package...

// in the router (loopback core) (@bajtos)
const methodToInvoke = controller[operationName];
ctx.bind('methodToInvoke').to(methodToInvoke);

// authentication ext does this (@siddhi)
app.bind('authentication.required').to((@inject('methodToInvoke') methodToInvoke) => {
  return Reflect.getMetadata(methodToInvoke, 'authenticate');
});

// authentication ext (@siddhi)
function authenticate(methodToInvoke) {
  Reflect.defineMetadata(methodToInvoke, 'authenticate', true);
}

// middleware design + router decomp. @bajtos @ritch @superkhau

[ritch]

Here is some notes from the spike:

1. should be able to write extensions that provide wholesale controller like functionality
2. the authentication component


app.bind('middleware').to((@inject('controllerName') controllerName) => {
  return new MyMiddleware();
});

class MyController {
  constructor(public @inject('middleware') middleware) {
  }
}

// accept req
// create a frozen ctx (no binding customization)
// allow binding to resolve
// call run()

class PublicCtrlMiddleware extends BaseMiddleware {
  authenticate() {
    // suppose to be empty
  }
  authorize() {
    // suppose to be empty
  }
  cache() {
    // custom impl here
  }
}

function redirect(ctx) {
  const m = new Middleware();
  m.bind(ctx);
  m.run();
}

class Middleware {
  run(invoke) {
    // call reject or respond
    // use invoke to call the controller method to get the result
  }
  reject(rejection) {
    // call send() with a standard error based on rejection
  }
  respond(body) {
    // call send() 
  }
}


class BaseMiddleware extends Middleware {
  constructor(
      public @inject('auditor') audit
      ) {
  }

  private _invoke : function;

  run() {
    let result;
    this.logger.start();
    try {
      const {credentials, authenticated} = await this.authenticate();
      await this.authorize(credentials, authenticated);
      const result = await this.cache() || this.invoke();
    } catch(e) {
      return this.reject({type: 'UNCAUGHT_ERROR', error: e});
    }

    return this.respond(result);
  }

  invoke() {
    this._invoke(this.methodName(), this.controller, this.args);
  }

  authenticate(@inject('authentication.authenticated') authenticated, @inject('authentication.credentials') credentials) {
    this.audit.add('they tried auth');
    return {
      credentials: credentials,
      authenticated: authenticated
    };
  }

  authorize(credentials, authenticated, @inject('authenticated.required') required) {
    if (required && !authenticated) return this.reject({type: 'AUTHENTICATION_REQUIRED'});
  }

  reject(rejection) {
    switch(rejection.type) {
      case 'AUTHENTICATION_REQUIRED':
        return this.authenticationRequired()
      break;
    }
  }

  respond(result) {
    await this.write(result);
    await
  }

  respond(body) {
    const ctx = this.ctx.toJSON();

    if ('HEAD' == ctx.method) {
      if (!res.headersSent && isJSON(body)) {
        ctx.length = Buffer.byteLength(JSON.stringify(body));
      }
      return res.end();
    }

    // status body
    if (null == body) {
      body = ctx.message || String(code);
      if (!res.headersSent) {
        ctx.type = 'text';
        ctx.length = Buffer.byteLength(body);
      }
      return res.end(body);
    }

    // responses
    if (Buffer.isBuffer(body)) return res.end(body);
    if ('string' == typeof body) return res.end(body);
    if (body instanceof Stream) return body.pipe(res);

    // body: json
    body = JSON.stringify(body);
    if (!res.headersSent) {
      ctx.length = Buffer.byteLength(body);
    }
    res.end(body);
}