lancetw/react-isomorphic-bundle

View on GitHub
src/server/services/v1/users.js

Summary

Maintainability
C
1 day
Test Coverage

Function create has 37 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  create: function *(next) {
    const body = yield parse(this)
    const rule = {
      name: { type: 'string', required: false, allowEmpty: true },
      password: { type: 'password', compare: 'passwordCheck' },
Severity: Minor
Found in src/server/services/v1/users.js - About 1 hr to fix

    Function update has 26 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      update: [ RestAuth, function *(next) {
        const body = yield parse(this)
    
        const rule = {
          name: { type: 'string', required: false, allowEmpty: true },
    Severity: Minor
    Found in src/server/services/v1/users.js - About 1 hr to fix

      Missing space after *.
      Open

        create: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Missing space after *.
      Open

        update: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Expected method shorthand.
      Open

        create: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Require Object Literal Shorthand Syntax (object-shorthand)

      EcmaScript 6 provides a concise form for defining object literal methods and properties. This syntax can make defining complex object literals much cleaner.

      Here are a few common examples using the ES5 syntax:

      // properties
      var foo = {
          x: x,
          y: y,
          z: z,
      };
      
      // methods
      var foo = {
          a: function() {},
          b: function() {}
      };

      Now here are ES6 equivalents:

      /*eslint-env es6*/
      
      // properties
      var foo = {x, y, z};
      
      // methods
      var foo = {
          a() {},
          b() {}
      };

      Rule Details

      This rule enforces the use of the shorthand syntax. This applies to all methods (including generators) defined in object literals and any properties defined where the key name matches name of the assigned variable.

      Each of the following properties would warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w: function() {},
          x: function *() {},
          [y]: function() {},
          z: z
      };

      In that case the expected syntax would have been:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w() {},
          *x() {},
          [y]() {},
          z
      };

      This rule does not flag arrow functions inside of object literals. The following will not warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          x: (y) => y
      };

      Options

      The rule takes an option which specifies when it should be applied. It can be set to one of the following values:

      • "always" (default) expects that the shorthand will be used whenever possible.
      • "methods" ensures the method shorthand is used (also applies to generators).
      • "properties" ensures the property shorthand is used (where the key and variable name match).
      • "never" ensures that no property or method shorthand is used in any object literal.
      • "consistent" ensures that either all shorthand or all longform will be used in an object literal.
      • "consistent-as-needed" ensures that either all shorthand or all longform will be used in an object literal, but ensures all shorthand whenever possible.

      You can set the option in configuration like this:

      {
          "object-shorthand": ["error", "always"]
      }

      Additionally, the rule takes an optional object configuration:

      • "avoidQuotes": true indicates that longform syntax is preferred whenever the object key is a string literal (default: false). Note that this option can only be enabled when the string option is set to "always", "methods", or "properties".
      • "ignoreConstructors": true can be used to prevent the rule from reporting errors for constructor functions. (By default, the rule treats constructors the same way as other functions.) Note that this option can only be enabled when the string option is set to "always" or "methods".
      • "avoidExplicitReturnArrows": true indicates that methods are preferred over explicit-return arrow functions for function properties. (By default, the rule allows either of these.) Note that this option can only be enabled when the string option is set to "always" or "methods".

      avoidQuotes

      {
          "object-shorthand": ["error", "always", { "avoidQuotes": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz"() {}
      };

      Example of correct code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz": function() {},
          "qux": qux
      };

      ignoreConstructors

      {
          "object-shorthand": ["error", "always", { "ignoreConstructors": true }]
      }

      Example of correct code for this rule with the "always", { "ignoreConstructors": true } option:

      /*eslint object-shorthand: ["error", "always", { "ignoreConstructors": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          ConstructorFunction: function() {}
      };

      avoidExplicitReturnArrows

      {
          "object-shorthand": ["error", "always", { "avoidExplicitReturnArrows": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo: (bar, baz) => {
          return bar + baz;
        },
      
        qux: (foobar) => {
          return foobar * 2;
        }
      };

      Example of correct code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo(bar, baz) {
          return bar + baz;
        },
      
        qux: foobar => foobar * 2
      };

      Example of incorrect code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a,
          b: "foo",
      };

      Examples of correct code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: "foo"
      };
      
      var bar = {
          a,
          b,
      };

      Example of incorrect code with the "consistent-as-needed" option, which is very similar to "consistent":

      /*eslint object-shorthand: [2, "consistent-as-needed"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: b,
      };

      When Not To Use It

      Anyone not yet in an ES6 environment would not want to apply this rule. Others may find the terseness of the shorthand syntax harder to read and may not want to encourage it with this rule.

      Further Reading

      Object initializer - MDN Source: http://eslint.org/docs/rules/

      Unexpected space before *.
      Open

        edit: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Missing space after *.
      Open

        edit: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Unexpected space before *.
      Open

        destroy: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      This generator function does not have 'yield'.
      Open

        index: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Disallow generator functions that do not have yield (require-yield)

      Rule Details

      This rule generates warnings for generator functions that do not have the yield keyword.

      Examples

      Examples of incorrect code for this rule:

      /*eslint require-yield: "error"*/
      /*eslint-env es6*/
      
      function* foo() {
        return 10;
      }

      Examples of correct code for this rule:

      /*eslint require-yield: "error"*/
      /*eslint-env es6*/
      
      function* foo() {
        yield 5;
        return 10;
      }
      
      function foo() {
        return 10;
      }
      
      // This rule does not warn on empty generator functions.
      function* foo() { }

      When Not To Use It

      If you don't want to notify generator functions that have no yield expression, then it's safe to disable this rule.

      Related Rules

      Missing space after *.
      Open

        destroy: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Missing space after *.
      Open

        index: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Unexpected require().
      Open

              secret: require('config').ReCAPTCHA.SECRET,
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce require() on the top-level module scope (global-require)

      In Node.js, module dependencies are included using the require() function, such as:

      var fs = require("fs");

      While require() may be called anywhere in code, some style guides prescribe that it should be called only in the top level of a module to make it easier to identify dependencies. For instance, it's arguably harder to identify dependencies when they are deeply nested inside of functions and other statements:

      function foo() {
      
          if (condition) {
              var fs = require("fs");
          }
      }

      Since require() does a synchronous load, it can cause performance problems when used in other locations.

      Further, ES6 modules mandate that import and export statements can only occur in the top level of the module's body.

      Rule Details

      This rule requires all calls to require() to be at the top level of the module, similar to ES6 import and export statements, which also can occur only at the top level.

      Examples of incorrect code for this rule:

      /*eslint global-require: "error"*/
      /*eslint-env es6*/
      
      // calling require() inside of a function is not allowed
      function readFile(filename, callback) {
          var fs = require('fs');
          fs.readFile(filename, callback)
      }
      
      // conditional requires like this are also not allowed
      if (DEBUG) { require('debug'); }
      
      // a require() in a switch statement is also flagged
      switch(x) { case '1': require('1'); break; }
      
      // you may not require() inside an arrow function body
      var getModule = (name) => require(name);
      
      // you may not require() inside of a function body as well
      function getModule(name) { return require(name); }
      
      // you may not require() inside of a try/catch block
      try {
          require(unsafeModule);
      } catch(e) {
          console.log(e);
      }

      Examples of correct code for this rule:

      /*eslint global-require: "error"*/
      
      // all these variations of require() are ok
      require('x');
      var y = require('y');
      var z;
      z = require('z').initialize();
      
      // requiring a module and using it in a function is ok
      var fs = require('fs');
      function readFile(filename, callback) {
          fs.readFile(filename, callback)
      }
      
      // you can use a ternary to determine which module to require
      var logger = DEBUG ? require('dev-logger') : require('logger');
      
      // if you want you can require() at the end of your module
      function doSomethingA() {}
      function doSomethingB() {}
      var x = require("x"),
          z = require("z");

      When Not To Use It

      If you have a module that must be initialized with information that comes from the file-system or if a module is only used in very rare situations and will cause significant overhead to load it may make sense to disable the rule. If you need to require() an optional dependency inside of a try/catch, you can disable this rule for just that dependency using the // eslint-disable-line global-require comment. Source: http://eslint.org/docs/rules/

      Unexpected space before *.
      Open

        index: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Expected method shorthand.
      Open

        index: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Require Object Literal Shorthand Syntax (object-shorthand)

      EcmaScript 6 provides a concise form for defining object literal methods and properties. This syntax can make defining complex object literals much cleaner.

      Here are a few common examples using the ES5 syntax:

      // properties
      var foo = {
          x: x,
          y: y,
          z: z,
      };
      
      // methods
      var foo = {
          a: function() {},
          b: function() {}
      };

      Now here are ES6 equivalents:

      /*eslint-env es6*/
      
      // properties
      var foo = {x, y, z};
      
      // methods
      var foo = {
          a() {},
          b() {}
      };

      Rule Details

      This rule enforces the use of the shorthand syntax. This applies to all methods (including generators) defined in object literals and any properties defined where the key name matches name of the assigned variable.

      Each of the following properties would warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w: function() {},
          x: function *() {},
          [y]: function() {},
          z: z
      };

      In that case the expected syntax would have been:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w() {},
          *x() {},
          [y]() {},
          z
      };

      This rule does not flag arrow functions inside of object literals. The following will not warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          x: (y) => y
      };

      Options

      The rule takes an option which specifies when it should be applied. It can be set to one of the following values:

      • "always" (default) expects that the shorthand will be used whenever possible.
      • "methods" ensures the method shorthand is used (also applies to generators).
      • "properties" ensures the property shorthand is used (where the key and variable name match).
      • "never" ensures that no property or method shorthand is used in any object literal.
      • "consistent" ensures that either all shorthand or all longform will be used in an object literal.
      • "consistent-as-needed" ensures that either all shorthand or all longform will be used in an object literal, but ensures all shorthand whenever possible.

      You can set the option in configuration like this:

      {
          "object-shorthand": ["error", "always"]
      }

      Additionally, the rule takes an optional object configuration:

      • "avoidQuotes": true indicates that longform syntax is preferred whenever the object key is a string literal (default: false). Note that this option can only be enabled when the string option is set to "always", "methods", or "properties".
      • "ignoreConstructors": true can be used to prevent the rule from reporting errors for constructor functions. (By default, the rule treats constructors the same way as other functions.) Note that this option can only be enabled when the string option is set to "always" or "methods".
      • "avoidExplicitReturnArrows": true indicates that methods are preferred over explicit-return arrow functions for function properties. (By default, the rule allows either of these.) Note that this option can only be enabled when the string option is set to "always" or "methods".

      avoidQuotes

      {
          "object-shorthand": ["error", "always", { "avoidQuotes": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz"() {}
      };

      Example of correct code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz": function() {},
          "qux": qux
      };

      ignoreConstructors

      {
          "object-shorthand": ["error", "always", { "ignoreConstructors": true }]
      }

      Example of correct code for this rule with the "always", { "ignoreConstructors": true } option:

      /*eslint object-shorthand: ["error", "always", { "ignoreConstructors": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          ConstructorFunction: function() {}
      };

      avoidExplicitReturnArrows

      {
          "object-shorthand": ["error", "always", { "avoidExplicitReturnArrows": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo: (bar, baz) => {
          return bar + baz;
        },
      
        qux: (foobar) => {
          return foobar * 2;
        }
      };

      Example of correct code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo(bar, baz) {
          return bar + baz;
        },
      
        qux: foobar => foobar * 2
      };

      Example of incorrect code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a,
          b: "foo",
      };

      Examples of correct code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: "foo"
      };
      
      var bar = {
          a,
          b,
      };

      Example of incorrect code with the "consistent-as-needed" option, which is very similar to "consistent":

      /*eslint object-shorthand: [2, "consistent-as-needed"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: b,
      };

      When Not To Use It

      Anyone not yet in an ES6 environment would not want to apply this rule. Others may find the terseness of the shorthand syntax harder to read and may not want to encourage it with this rule.

      Further Reading

      Object initializer - MDN Source: http://eslint.org/docs/rules/

      Unexpected space before *.
      Open

        create: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Unexpected space before *.
      Open

        show: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Unexpected require().
      Open

          const sitekey = require('config').ReCAPTCHA.KEY
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce require() on the top-level module scope (global-require)

      In Node.js, module dependencies are included using the require() function, such as:

      var fs = require("fs");

      While require() may be called anywhere in code, some style guides prescribe that it should be called only in the top level of a module to make it easier to identify dependencies. For instance, it's arguably harder to identify dependencies when they are deeply nested inside of functions and other statements:

      function foo() {
      
          if (condition) {
              var fs = require("fs");
          }
      }

      Since require() does a synchronous load, it can cause performance problems when used in other locations.

      Further, ES6 modules mandate that import and export statements can only occur in the top level of the module's body.

      Rule Details

      This rule requires all calls to require() to be at the top level of the module, similar to ES6 import and export statements, which also can occur only at the top level.

      Examples of incorrect code for this rule:

      /*eslint global-require: "error"*/
      /*eslint-env es6*/
      
      // calling require() inside of a function is not allowed
      function readFile(filename, callback) {
          var fs = require('fs');
          fs.readFile(filename, callback)
      }
      
      // conditional requires like this are also not allowed
      if (DEBUG) { require('debug'); }
      
      // a require() in a switch statement is also flagged
      switch(x) { case '1': require('1'); break; }
      
      // you may not require() inside an arrow function body
      var getModule = (name) => require(name);
      
      // you may not require() inside of a function body as well
      function getModule(name) { return require(name); }
      
      // you may not require() inside of a try/catch block
      try {
          require(unsafeModule);
      } catch(e) {
          console.log(e);
      }

      Examples of correct code for this rule:

      /*eslint global-require: "error"*/
      
      // all these variations of require() are ok
      require('x');
      var y = require('y');
      var z;
      z = require('z').initialize();
      
      // requiring a module and using it in a function is ok
      var fs = require('fs');
      function readFile(filename, callback) {
          fs.readFile(filename, callback)
      }
      
      // you can use a ternary to determine which module to require
      var logger = DEBUG ? require('dev-logger') : require('logger');
      
      // if you want you can require() at the end of your module
      function doSomethingA() {}
      function doSomethingB() {}
      var x = require("x"),
          z = require("z");

      When Not To Use It

      If you have a module that must be initialized with information that comes from the file-system or if a module is only used in very rare situations and will cause significant overhead to load it may make sense to disable the rule. If you need to require() an optional dependency inside of a try/catch, you can disable this rule for just that dependency using the // eslint-disable-line global-require comment. Source: http://eslint.org/docs/rules/

      Missing space after *.
      Open

        show: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      Expected property shorthand.
      Open

          this.body = { sitekey: sitekey }
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Require Object Literal Shorthand Syntax (object-shorthand)

      EcmaScript 6 provides a concise form for defining object literal methods and properties. This syntax can make defining complex object literals much cleaner.

      Here are a few common examples using the ES5 syntax:

      // properties
      var foo = {
          x: x,
          y: y,
          z: z,
      };
      
      // methods
      var foo = {
          a: function() {},
          b: function() {}
      };

      Now here are ES6 equivalents:

      /*eslint-env es6*/
      
      // properties
      var foo = {x, y, z};
      
      // methods
      var foo = {
          a() {},
          b() {}
      };

      Rule Details

      This rule enforces the use of the shorthand syntax. This applies to all methods (including generators) defined in object literals and any properties defined where the key name matches name of the assigned variable.

      Each of the following properties would warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w: function() {},
          x: function *() {},
          [y]: function() {},
          z: z
      };

      In that case the expected syntax would have been:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w() {},
          *x() {},
          [y]() {},
          z
      };

      This rule does not flag arrow functions inside of object literals. The following will not warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          x: (y) => y
      };

      Options

      The rule takes an option which specifies when it should be applied. It can be set to one of the following values:

      • "always" (default) expects that the shorthand will be used whenever possible.
      • "methods" ensures the method shorthand is used (also applies to generators).
      • "properties" ensures the property shorthand is used (where the key and variable name match).
      • "never" ensures that no property or method shorthand is used in any object literal.
      • "consistent" ensures that either all shorthand or all longform will be used in an object literal.
      • "consistent-as-needed" ensures that either all shorthand or all longform will be used in an object literal, but ensures all shorthand whenever possible.

      You can set the option in configuration like this:

      {
          "object-shorthand": ["error", "always"]
      }

      Additionally, the rule takes an optional object configuration:

      • "avoidQuotes": true indicates that longform syntax is preferred whenever the object key is a string literal (default: false). Note that this option can only be enabled when the string option is set to "always", "methods", or "properties".
      • "ignoreConstructors": true can be used to prevent the rule from reporting errors for constructor functions. (By default, the rule treats constructors the same way as other functions.) Note that this option can only be enabled when the string option is set to "always" or "methods".
      • "avoidExplicitReturnArrows": true indicates that methods are preferred over explicit-return arrow functions for function properties. (By default, the rule allows either of these.) Note that this option can only be enabled when the string option is set to "always" or "methods".

      avoidQuotes

      {
          "object-shorthand": ["error", "always", { "avoidQuotes": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz"() {}
      };

      Example of correct code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz": function() {},
          "qux": qux
      };

      ignoreConstructors

      {
          "object-shorthand": ["error", "always", { "ignoreConstructors": true }]
      }

      Example of correct code for this rule with the "always", { "ignoreConstructors": true } option:

      /*eslint object-shorthand: ["error", "always", { "ignoreConstructors": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          ConstructorFunction: function() {}
      };

      avoidExplicitReturnArrows

      {
          "object-shorthand": ["error", "always", { "avoidExplicitReturnArrows": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo: (bar, baz) => {
          return bar + baz;
        },
      
        qux: (foobar) => {
          return foobar * 2;
        }
      };

      Example of correct code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo(bar, baz) {
          return bar + baz;
        },
      
        qux: foobar => foobar * 2
      };

      Example of incorrect code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a,
          b: "foo",
      };

      Examples of correct code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: "foo"
      };
      
      var bar = {
          a,
          b,
      };

      Example of incorrect code with the "consistent-as-needed" option, which is very similar to "consistent":

      /*eslint object-shorthand: [2, "consistent-as-needed"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: b,
      };

      When Not To Use It

      Anyone not yet in an ES6 environment would not want to apply this rule. Others may find the terseness of the shorthand syntax harder to read and may not want to encourage it with this rule.

      Further Reading

      Object initializer - MDN Source: http://eslint.org/docs/rules/

      Expected method shorthand.
      Open

        edit: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Require Object Literal Shorthand Syntax (object-shorthand)

      EcmaScript 6 provides a concise form for defining object literal methods and properties. This syntax can make defining complex object literals much cleaner.

      Here are a few common examples using the ES5 syntax:

      // properties
      var foo = {
          x: x,
          y: y,
          z: z,
      };
      
      // methods
      var foo = {
          a: function() {},
          b: function() {}
      };

      Now here are ES6 equivalents:

      /*eslint-env es6*/
      
      // properties
      var foo = {x, y, z};
      
      // methods
      var foo = {
          a() {},
          b() {}
      };

      Rule Details

      This rule enforces the use of the shorthand syntax. This applies to all methods (including generators) defined in object literals and any properties defined where the key name matches name of the assigned variable.

      Each of the following properties would warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w: function() {},
          x: function *() {},
          [y]: function() {},
          z: z
      };

      In that case the expected syntax would have been:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          w() {},
          *x() {},
          [y]() {},
          z
      };

      This rule does not flag arrow functions inside of object literals. The following will not warn:

      /*eslint object-shorthand: "error"*/
      /*eslint-env es6*/
      
      var foo = {
          x: (y) => y
      };

      Options

      The rule takes an option which specifies when it should be applied. It can be set to one of the following values:

      • "always" (default) expects that the shorthand will be used whenever possible.
      • "methods" ensures the method shorthand is used (also applies to generators).
      • "properties" ensures the property shorthand is used (where the key and variable name match).
      • "never" ensures that no property or method shorthand is used in any object literal.
      • "consistent" ensures that either all shorthand or all longform will be used in an object literal.
      • "consistent-as-needed" ensures that either all shorthand or all longform will be used in an object literal, but ensures all shorthand whenever possible.

      You can set the option in configuration like this:

      {
          "object-shorthand": ["error", "always"]
      }

      Additionally, the rule takes an optional object configuration:

      • "avoidQuotes": true indicates that longform syntax is preferred whenever the object key is a string literal (default: false). Note that this option can only be enabled when the string option is set to "always", "methods", or "properties".
      • "ignoreConstructors": true can be used to prevent the rule from reporting errors for constructor functions. (By default, the rule treats constructors the same way as other functions.) Note that this option can only be enabled when the string option is set to "always" or "methods".
      • "avoidExplicitReturnArrows": true indicates that methods are preferred over explicit-return arrow functions for function properties. (By default, the rule allows either of these.) Note that this option can only be enabled when the string option is set to "always" or "methods".

      avoidQuotes

      {
          "object-shorthand": ["error", "always", { "avoidQuotes": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz"() {}
      };

      Example of correct code for this rule with the "always", { "avoidQuotes": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidQuotes": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          "bar-baz": function() {},
          "qux": qux
      };

      ignoreConstructors

      {
          "object-shorthand": ["error", "always", { "ignoreConstructors": true }]
      }

      Example of correct code for this rule with the "always", { "ignoreConstructors": true } option:

      /*eslint object-shorthand: ["error", "always", { "ignoreConstructors": true }]*/
      /*eslint-env es6*/
      
      var foo = {
          ConstructorFunction: function() {}
      };

      avoidExplicitReturnArrows

      {
          "object-shorthand": ["error", "always", { "avoidExplicitReturnArrows": true }]
      }

      Example of incorrect code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo: (bar, baz) => {
          return bar + baz;
        },
      
        qux: (foobar) => {
          return foobar * 2;
        }
      };

      Example of correct code for this rule with the "always", { "avoidExplicitReturnArrows": true } option:

      /*eslint object-shorthand: ["error", "always", { "avoidExplicitReturnArrows": true }]*/
      /*eslint-env es6*/
      
      var foo = {
        foo(bar, baz) {
          return bar + baz;
        },
      
        qux: foobar => foobar * 2
      };

      Example of incorrect code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a,
          b: "foo",
      };

      Examples of correct code for this rule with the "consistent" option:

      /*eslint object-shorthand: [2, "consistent"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: "foo"
      };
      
      var bar = {
          a,
          b,
      };

      Example of incorrect code with the "consistent-as-needed" option, which is very similar to "consistent":

      /*eslint object-shorthand: [2, "consistent-as-needed"]*/
      /*eslint-env es6*/
      
      var foo = {
          a: a,
          b: b,
      };

      When Not To Use It

      Anyone not yet in an ES6 environment would not want to apply this rule. Others may find the terseness of the shorthand syntax harder to read and may not want to encourage it with this rule.

      Further Reading

      Object initializer - MDN Source: http://eslint.org/docs/rules/

      Unexpected space before *.
      Open

        update: [ RestAuth, function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Enforce spacing around the * in generator functions (generator-star-spacing)

      Generators are a new type of function in ECMAScript 6 that can return multiple values over time. These special functions are indicated by placing an * after the function keyword.

      Here is an example of a generator function:

      /*eslint-env es6*/
      
      function* generator() {
          yield "44";
          yield "55";
      }

      This is also valid:

      /*eslint-env es6*/
      
      function *generator() {
          yield "44";
          yield "55";
      }

      This is valid as well:

      /*eslint-env es6*/
      
      function * generator() {
          yield "44";
          yield "55";
      }

      To keep a sense of consistency when using generators this rule enforces a single position for the *.

      Rule Details

      This rule aims to enforce spacing around the * of generator functions.

      Options

      The rule takes one option, an object, which has two keys before and after having boolean values true or false.

      • before enforces spacing between the * and the function keyword. If it is true, a space is required, otherwise spaces are disallowed.

      In object literal shorthand methods, spacing before the * is not checked, as they lack a function keyword.

      • after enforces spacing between the * and the function name (or the opening parenthesis for anonymous generator functions). If it is true, a space is required, otherwise spaces are disallowed.

      The default is {"before": true, "after": false}.

      An example configuration:

      "generator-star-spacing": ["error", {"before": true, "after": false}]

      And the option has shorthand as a string keyword:

      • {"before": true, "after": false}"before"
      • {"before": false, "after": true}"after"
      • {"before": true, "after": true}"both"
      • {"before": false, "after": false}"neither"

      An example of shorthand configuration:

      "generator-star-spacing": ["error", "after"]

      Examples

      before

      Examples of correct code for this rule with the "before" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
      /*eslint-env es6*/
      
      function *generator() {}
      
      var anonymous = function *() {};
      
      var shorthand = { *generator() {} };

      after

      Examples of correct code for this rule with the "after" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
      /*eslint-env es6*/
      
      function* generator() {}
      
      var anonymous = function* () {};
      
      var shorthand = { * generator() {} };

      both

      Examples of correct code for this rule with the "both" option:

      /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
      /*eslint-env es6*/
      
      function * generator() {}
      
      var anonymous = function * () {};
      
      var shorthand = { * generator() {} };

      neither

      Examples of correct code for this rule with the "neither" option:

      /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
      /*eslint-env es6*/
      
      function*generator() {}
      
      var anonymous = function*() {};
      
      var shorthand = { *generator() {} };

      When Not To Use It

      If your project will not be using generators or you are not concerned with spacing consistency, you do not need this rule.

      Further Reading

      This generator function does not have 'yield'.
      Open

        edit: function *(next) {
      Severity: Minor
      Found in src/server/services/v1/users.js by eslint

      Disallow generator functions that do not have yield (require-yield)

      Rule Details

      This rule generates warnings for generator functions that do not have the yield keyword.

      Examples

      Examples of incorrect code for this rule:

      /*eslint require-yield: "error"*/
      /*eslint-env es6*/
      
      function* foo() {
        return 10;
      }

      Examples of correct code for this rule:

      /*eslint require-yield: "error"*/
      /*eslint-env es6*/
      
      function* foo() {
        yield 5;
        return 10;
      }
      
      function foo() {
        return 10;
      }
      
      // This rule does not warn on empty generator functions.
      function* foo() { }

      When Not To Use It

      If you don't want to notify generator functions that have no yield expression, then it's safe to disable this rule.

      Related Rules

      Similar blocks of code found in 3 locations. Consider refactoring.
      Open

        show: [ RestAuth, function *(next) {
          try {
            if (hashids.decode(this.params.user) !== +this.user.id) {
              throw new Error('user check failed')
            }
      Severity: Major
      Found in src/server/services/v1/users.js and 2 other locations - About 6 hrs to fix
      src/server/services/admin/v1/admins.js on lines 112..128
      src/server/services/v1/usersInfo.js on lines 40..56

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 173.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      Similar blocks of code found in 2 locations. Consider refactoring.
      Open

          try {
            const user = yield User.create(body)
            this.type = 'json'
            this.status = 201
            this.body = hashids.encodeJson(user)
      Severity: Major
      Found in src/server/services/v1/users.js and 1 other location - About 3 hrs to fix
      src/server/services/admin/v1/promotions.js on lines 48..57

      Duplicated Code

      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

      Tuning

      This issue has a mass of 105.

      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

      Refactorings

      Further Reading

      There are no issues that match your filters.

      Category
      Status