"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.processors = exports.rules = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _fs = require("fs");

var _fs2 = _interopRequireDefault(_fs);

var _path = require("path");

var _path2 = _interopRequireDefault(_path);

var _graphql = require("graphql");

var _lodash = require("lodash");

var _graphqlConfig = require("graphql-config");

var _customGraphQLValidationRules = require("./customGraphQLValidationRules");

var customRules = _interopRequireWildcard(_customGraphQLValidationRules);

var _constants = require("./constants");

var _createRule = require("./createRule");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var allGraphQLValidatorNames = _graphql.specifiedRules.map(function (rule) {
  return rule.name;
});

// Map of env name to list of rule names.
var envGraphQLValidatorNames = {
  apollo: (0, _lodash.without)(allGraphQLValidatorNames, "KnownFragmentNames", "NoUnusedFragments"),
  lokka: (0, _lodash.without)(allGraphQLValidatorNames, "KnownFragmentNames", "NoUnusedFragments"),
  fraql: (0, _lodash.without)(allGraphQLValidatorNames, "KnownFragmentNames", "NoUnusedFragments"),
  relay: (0, _lodash.without)(allGraphQLValidatorNames, "KnownDirectives", "KnownFragmentNames", "NoUndefinedVariables", "NoUnusedFragments",
  // `graphql` < 14
  "ProvidedNonNullArguments",
  // `graphql`@14
  "ProvidedRequiredArguments", "ScalarLeafs"),
  literal: (0, _lodash.without)(allGraphQLValidatorNames, "KnownFragmentNames", "NoUnusedFragments")
};

var gqlFiles = ["gql", "graphql"];

var defaultRuleProperties = {
  env: {
    enum: ["lokka", "fraql", "relay", "apollo", "literal"]
  },
  schemaJson: {
    type: "object"
  },
  schemaJsonFilepath: {
    type: "string"
  },
  schemaString: {
    type: "string"
  },
  tagName: {
    type: "string",
    pattern: "^[$_a-zA-Z$_][a-zA-Z0-9$_]+(\\.[a-zA-Z0-9$_]+)?$"
  },
  projectName: {
    type: "string"
  }
};

// schemaJson, schemaJsonFilepath, schemaString and projectName are mutually exclusive:
var schemaPropsExclusiveness = {
  oneOf: [{
    required: ["schemaJson"],
    not: { required: ["schemaString", "schemaJsonFilepath", "projectName"] }
  }, {
    required: ["schemaJsonFilepath"],
    not: { required: ["schemaJson", "schemaString", "projectName"] }
  }, {
    required: ["schemaString"],
    not: { required: ["schemaJson", "schemaJsonFilepath", "projectName"] }
  }, {
    not: {
      anyOf: [{ required: ["schemaString"] }, { required: ["schemaJson"] }, { required: ["schemaJsonFilepath"] }]
    }
  }]
};

var rules = exports.rules = {
  "template-strings": {
    meta: {
      schema: {
        type: "array",
        items: _extends({
          additionalProperties: false,
          properties: _extends({}, defaultRuleProperties, {
            validators: {
              oneOf: [{
                type: "array",
                uniqueItems: true,
                items: {
                  enum: allGraphQLValidatorNames
                }
              }, {
                enum: ["all"]
              }]
            }
          })
        }, schemaPropsExclusiveness)
      }
    },
    create: function create(context) {
      return (0, _createRule.createRule)(context, function (optionGroup) {
        return parseOptions(optionGroup, context);
      });
    }
  },
  "named-operations": {
    meta: {
      schema: {
        type: "array",
        items: _extends({
          additionalProperties: false,
          properties: _extends({}, defaultRuleProperties)
        }, schemaPropsExclusiveness)
      }
    },
    create: function create(context) {
      return (0, _createRule.createRule)(context, function (optionGroup) {
        return parseOptions(_extends({
          validators: ["OperationsMustHaveNames"]
        }, optionGroup), context);
      });
    }
  },
  "required-fields": {
    meta: {
      schema: {
        type: "array",
        minItems: 1,
        items: _extends({
          additionalProperties: false,
          properties: _extends({}, defaultRuleProperties, {
            requiredFields: {
              type: "array",
              items: {
                type: "string"
              }
            }
          }),
          required: ["requiredFields"]
        }, schemaPropsExclusiveness)
      }
    },
    create: function create(context) {
      return (0, _createRule.createRule)(context, function (optionGroup) {
        return parseOptions(_extends({
          validators: ["RequiredFields"],
          options: { requiredFields: optionGroup.requiredFields }
        }, optionGroup), context);
      });
    }
  },
  "capitalized-type-name": {
    meta: {
      schema: {
        type: "array",
        items: _extends({
          additionalProperties: false,
          properties: _extends({}, defaultRuleProperties)
        }, schemaPropsExclusiveness)
      }
    },
    create: function create(context) {
      return (0, _createRule.createRule)(context, function (optionGroup) {
        return parseOptions(_extends({
          validators: ["typeNamesShouldBeCapitalized"]
        }, optionGroup), context);
      });
    }
  },
  "no-deprecated-fields": {
    meta: {
      schema: {
        type: "array",
        items: _extends({
          additionalProperties: false,
          properties: _extends({}, defaultRuleProperties)
        }, schemaPropsExclusiveness)
      }
    },
    create: function create(context) {
      return (0, _createRule.createRule)(context, function (optionGroup) {
        return parseOptions(_extends({
          validators: ["noDeprecatedFields"]
        }, optionGroup), context);
      });
    }
  }
};

var schemaCache = {};
var projectCache = {};

function parseOptions(optionGroup, context) {
  var schemaJson = optionGroup.schemaJson,
      schemaJsonFilepath = optionGroup.schemaJsonFilepath,
      schemaString = optionGroup.schemaString,
      env = optionGroup.env,
      projectName = optionGroup.projectName,
      tagNameOption = optionGroup.tagName,
      validatorNamesOption = optionGroup.validators;


  var cacheHit = schemaCache[JSON.stringify(optionGroup)];
  if (cacheHit && env !== "literal") {
    return cacheHit;
  }

  // Validate and unpack schema
  var schema = void 0;
  if (schemaJson) {
    schema = initSchema(schemaJson);
  } else if (schemaJsonFilepath) {
    schema = initSchemaFromFile(schemaJsonFilepath);
  } else if (schemaString) {
    schema = initSchemaFromString(schemaString);
  } else {
    try {
      var config = (0, _graphqlConfig.getGraphQLConfig)(_path2.default.dirname(context.getFilename()));
      var projectConfig = void 0;
      if (projectName) {
        projectConfig = config.getProjects()[projectName];
        if (!projectConfig) {
          throw new Error("Project with name \"" + projectName + "\" not found in " + config.configPath + ".");
        }
      } else {
        projectConfig = config.getConfigForFile(context.getFilename());
      }
      if (projectConfig) {
        var key = config.configPath + "[" + projectConfig.projectName + "]";
        schema = projectCache[key];
        if (!schema) {
          schema = projectConfig.getSchema();
          projectCache[key] = schema;
        }
      }
      if (cacheHit) {
        return _extends({}, cacheHit, { schema: schema });
      }
    } catch (e) {
      if (e instanceof _graphqlConfig.ConfigNotFoundError) {
        throw new Error("Must provide .graphqlconfig file or pass in `schemaJson` option " + "with schema object or `schemaJsonFilepath` with absolute path to the json file.");
      }
      throw e;
    }
  }

  // Validate env
  if (env && env !== "lokka" && env !== "fraql" && env !== "relay" && env !== "apollo" && env !== "literal") {
    throw new Error("Invalid option for env, only `apollo`, `lokka`, `fraql`, `relay`, and `literal` supported.");
  }

  // Validate tagName and set default
  var tagName = void 0;
  if (tagNameOption) {
    tagName = tagNameOption;
  } else if (env === "relay") {
    tagName = "Relay.QL";
  } else if (env === "literal") {
    tagName = _constants.internalTag;
  } else {
    tagName = "gql";
  }

  // The validator list may be:
  //    The string 'all' to use all rules.
  //    An array of rule names.
  //    null/undefined to use the default rule set of the environment, or all rules.
  var validatorNames = void 0;
  if (validatorNamesOption === "all") {
    validatorNames = allGraphQLValidatorNames;
  } else if (validatorNamesOption) {
    validatorNames = validatorNamesOption;
  } else {
    validatorNames = envGraphQLValidatorNames[env] || allGraphQLValidatorNames;
  }

  var validators = validatorNames.map(function (name) {
    if (name in customRules) {
      return customRules[name];
    } else {
      return require("graphql/validation/rules/" + name)[name];
    }
  });
  var results = { schema: schema, env: env, tagName: tagName, validators: validators };
  schemaCache[JSON.stringify(optionGroup)] = results;
  return results;
}

function initSchema(json) {
  var unpackedSchemaJson = json.data ? json.data : json;
  if (!unpackedSchemaJson.__schema) {
    throw new Error("Please pass a valid GraphQL introspection query result.");
  }
  return (0, _graphql.buildClientSchema)(unpackedSchemaJson);
}

function initSchemaFromFile(jsonFile) {
  return initSchema(JSON.parse(_fs2.default.readFileSync(jsonFile, "utf8")));
}

function initSchemaFromString(source) {
  return (0, _graphql.buildSchema)(source);
}

var gqlProcessor = {
  preprocess: function preprocess(text) {
    // Wrap the text in backticks and prepend the internal tag. First the text
    // must be escaped, because of the three sequences that have special
    // meaning in JavaScript template literals, and could change the meaning of
    // the text or cause syntax errors.
    // https://tc39.github.io/ecma262/#prod-TemplateCharacter
    //
    // - "`" would end the template literal.
    // - "\" would start an escape sequence.
    // - "${" would start an interpolation.
    var escaped = text.replace(/[`\\]|\$\{/g, "\\$&");
    return [_constants.internalTag + "`" + escaped + "`"];
  },
  postprocess: function postprocess(messages) {
    // only report graphql-errors
    return (0, _lodash.flatten)(messages).filter(function (message) {
      return (0, _lodash.includes)((0, _lodash.keys)(rules).map(function (key) {
        return "graphql/" + key;
      }), message.ruleId);
    });
  }
};

var processors = exports.processors = (0, _lodash.reduce)(gqlFiles, function (result, value) {
  return _extends({}, result, _defineProperty({}, "." + value, gqlProcessor));
}, {});

exports.default = {
  rules: rules,
  processors: processors
};