Rename varsMap to argsMap (#23)

* Pass variableValues into the query handler (rather than root args)

Previously the `vars` that were being passed down from the query mock
were in fact the args for the root query selection and therefore already
massaged by the GraphQL executor to have the correct names. This means
that variables to be used further down the graph could either be missing
or have the wrong names.

This is tricky to explain succintly, please see the test case for a
concrete example. In the test case, we are dealing with a scenario where
the variable is used in both the root of the query *and* further down
with a different name. If it were used further down and *not* in the
root query then the variable would simply be absent prior to this patch.

Co-authored-by: Chad Carbert <chadcarbert@me.com>

* Rename varsMap to argsMap and clarify behavior

Previously this option worked with variable names rather than argument
names. We believe mapping argument names is more useful and more likely
to be the expected behavior. This patch removes any notion of mapping
variable names and focuses strictly on argument names whilst also
renaming the option to make it clearer what is being mapped.

Closes #22

Co-authored-by: Chad Carbert <chadcarbert@me.com>

Author: 2 people

DEPRECATIONS.md

@@ -0,0 +1,7 @@
+# Deprecations
+
+## varsMap (since 0.0.9)
+
+This option has been renamed to `argsMap` and now explicitly provides support
+for custom mapping of *argument* names in filters and mutations (rather than
+*variable* names).

README.md

@@ -104,7 +104,7 @@ You may pass in options when creating a request handler. The options take the fo
 
     1. The table from Mirage's database that corresponds to the return
     type of the mutation.
-    2. The mutation variables. These will be mapped per the varsMap
+    2. The mutation arguments. These will be mapped per the argsMap
     option, by the return type, if appropriate.
     3. Mirage's database.
 
@@ -113,28 +113,29 @@ You may pass in options when creating a request handler. The options take the fo
     functionality, if feasible.
    */
   mutations: {
-    updatePerson: (people, vars, db) => {
-      let { id, personAttributes } = vars;
+    updatePerson: (people, args, db) => {
+      let { id, personAttributes } = args;
 
       return [ people.update(id, personAttributes) ];
     }
   },
   /*
-    varsMap is used if you need to map request variables defined
-    in your GraphQL queries. The value you specify in the map can
-    be a string or a function.
+    argsMap is used if you need to map arguments defined in your GraphQL
+    queries to something other than the corresponding field name on the
+    mirage record. The value you specify in the map can be a string or a
+    function.
 
     The addon uses the variables to filter records of the given
     type from Mirage's database.
 
-    String values will be used to map variable names to field names
-    in case the variable name differs.
+    String values will be used to map argument names to field names
+    in case the argument name differs.
 
     Function values will be used to filter records. The function
-    will be passed an array of records, the variable name (key)
-    and the variable value.
+    will be passed an array of records, the argument name (key)
+    and the argument value.
    */
-  varsMap: {
+  argsMap: {
     Person: { // variables are mapped on a per-type basis
       pageSize: (records, _, pageSize) => records.slice(0, pageSize)
     }

addon/fields/args.js

@@ -1,6 +1,11 @@
 export const getArgsForField = (field) =>
   field.arguments.map(({ name, value }) => ({
     kind: value.kind,
-    name: value.name && value.name.value || name.value,
-    value: value.value
+    name: name.value,
+    value: value.value,
+    variableName: value.name && value.name.value
  }));
+
+
+export const resolveArgName = (name, argsMap = {}) =>
+  name in argsMap ? argsMap[name] : name;

addon/filter/create.js

@@ -1,38 +1,37 @@
 import Filter from './model';
 import sortFilters from './sort';
 import { isFunction, partial } from '../utils';
-import { resolveVarName } from './vars';
+import { resolveArgName } from '../fields/args';
 import { set, setProperties } from '@ember/object';
 import { spliceRelayFilters } from '../relay/filters';
 
-export const composeMapArgsToFilters = (resolveVarName) =>
-  (vars, varsMapForType = {}, { kind, name, value }) => {
+export const composeMapArgsToFilters = (resolveArgName) =>
+  (vars, argsMapForType = {}, { kind, name, value, variableName }) => {
     let filter = Filter.create({ name, value });
+    let resolvedName = resolveArgName(name, argsMapForType);
 
-    if (kind === 'Variable') {
-      let resolvedName = resolveVarName(name, varsMapForType);
-
-      filter.set('value', vars[name]);
+    isFunction(resolvedName)
+      ? setProperties(filter, { hasFnValue: true, fn: resolvedName })
+      : set(filter, 'resolvedName', resolvedName);
 
-      isFunction(resolvedName)
-        ? setProperties(filter, { hasFnValue: true, fn: resolvedName })
-        : set(filter, 'resolvedName', resolvedName);
+    if (kind === 'Variable') {
+      filter.set('value', vars[variableName]);
     }
 
     return filter;
   };
 
-const mapArgsToFilters = composeMapArgsToFilters(resolveVarName);
+const mapArgsToFilters = composeMapArgsToFilters(resolveArgName);
 
-const createFiltersByArgs = (args, vars, varsMap) =>
-  args.map(partial(mapArgsToFilters, vars, varsMap));
+const createFiltersByArgs = (args, vars, argsMap) =>
+  args.map(partial(mapArgsToFilters, vars, argsMap));
 
 export const composeCreateFilters =
   (createFiltersByArgs, sortFilters, spliceRelayFilters) =>
-    (field, vars, { varsMap = {} } = {}) => {
+    (field, vars, { argsMap = {} } = {}) => {
       let { args, type } = field;
-      let varsMapForType = varsMap[type.name];
-      let filters = createFiltersByArgs(args, vars, varsMapForType)
+      let argsMapForType = argsMap[type.name];
+      let filters = createFiltersByArgs(args, vars, argsMapForType)
         .sort(sortFilters);
 
       if (field.isRelayEdges) {

addon/filter/vars.js

@@ -3,6 +3,7 @@ import {
   addInterfaceTypeResolversToSchema,
   createSchema
 } from './schema';
+import { deprecate } from '@ember/debug';
 import { graphql } from 'graphql';
 
 export const composeCreateGraphQLHandler =
@@ -12,6 +13,20 @@ export const composeCreateGraphQLHandler =
         let { query, variables } = parseRequest(request.requestBody);
         let schema = createSchema(rawSchema);
 
+        if (options.varsMap) {
+          deprecate('ember-cli-mirage-graphql varsMap is deprecated, please use argsMap instead', false, {
+            id: 'ember-cli-mirage-graphql.vars-map',
+            until: '1.0.0',
+            url: 'https://github.com/kloeckner-i/ember-cli-mirage-graphql/blob/master/DEPRECATIONS.md'
+          });
+
+          if (!options.argsMap) {
+            options.argsMap = options.varsMap;
+          }
+
+          delete options.varsMap;
+        }
+
         addMocksToSchema(schema, db, options);
         addInterfaceTypeResolversToSchema(schema);
 

addon/handler.js

@@ -1,31 +1,31 @@
 import { contextSet, isFunction, reduceKeys, unwrapNonNull } from '../utils';
 import { getRecords } from '../db';
-import { resolveVarName } from '../filter/vars';
+import { resolveArgName } from '../fields/args';
 
-export const composeMapVars = (resolveVarName) =>
-  (vars, varsMap = {}) =>
-    reduceKeys(vars, (mappedVars, key) =>
-      contextSet(mappedVars, resolveVarName(key, varsMap), vars[key]), {});
+export const composeMapArgs = (resolveArgName) =>
+  (args, argsMap = {}) =>
+    reduceKeys(args, (mappedArgs, key) =>
+      contextSet(mappedArgs, resolveArgName(key, argsMap), args[key]), {});
 
-const mapVars = composeMapVars(resolveVarName);
+const mapArgs = composeMapArgs(resolveArgName);
 
-export const composeMockMutation = (getRecords, mapVars) =>
-  (db, options = {}, _, vars, __, { fieldName, returnType }) => {
+export const composeMockMutation = (getRecords, mapArgs) =>
+  (db, options = {}, _, args, __, { fieldName, returnType }) => {
     returnType = unwrapNonNull(returnType);
 
-    let { mutations = {}, varsMap = {} } = options;
+    let { mutations = {}, argsMap = {} } = options;
     let mutation = mutations[fieldName];
     let records = getRecords(db, returnType.name);
 
     if (isFunction(mutation)) {
-      let mappedVars = mapVars(vars, varsMap[returnType.name]);
+      let mappedArgs = mapArgs(args, argsMap[returnType.name]);
 
-      records = mutation(records, mappedVars, db);
+      records = mutation(records, mappedArgs, db);
     }
 
     return records;
   };
 
-const mockMutation = composeMockMutation(getRecords, mapVars);
+const mockMutation = composeMockMutation(getRecords, mapArgs);
 
 export default mockMutation;

addon/mocks/mutation.js

@@ -7,7 +7,9 @@ import { partial } from '../utils';
 
 export const composeMockQuery =
   (getTypeForField, getFieldNameAndAlias, createFieldInfo, resolveFieldInfo, getIsInterface, logError) =>
-    (db, options, _, vars, __, { fieldNodes, fragments, returnType, schema }) => {
+    (db, options, _, __, ___, info) => {
+      const { fieldNodes, fragments, returnType, schema, variableValues } = info;
+
       try {
         let getType = partial(getTypeForField, schema._typeMap);
         let [rootField] = fieldNodes;
@@ -19,7 +21,7 @@ export const composeMockQuery =
           [rootFieldName]: createFieldInfo(rootField, fieldInfoName, returnType,
             fragments, getType)
         };
-        let records = resolveFieldInfo(fieldInfo, db, vars, options);
+        let records = resolveFieldInfo(fieldInfo, db, variableValues, options);
 
         return isInterface ? records : records[fieldName];
       } catch(ex) {

addon/mocks/query.js

@@ -0,0 +1,20 @@
+import { module, test } from 'qunit';
+import { setupApplicationTest } from 'ember-qunit';
+import { visit } from '@ember/test-helpers';
+
+module('Acceptance | variables', function(hooks) {
+  setupApplicationTest(hooks);
+
+  test('variable values are passed correctly at multiple depths', async function(assert) {
+    let person = this.server.create('person', { firstName: 'Alice', surname: 'Example' });
+
+    this.server.create('animal', { person, type: 'dog', name: 'Bob' });
+    this.server.create('animal', { person, type: 'dog', name: 'Alice' });
+
+    await visit('/people/same-name-as-pets');
+
+    assert.dom('h2').containsText('Alice');
+    assert.dom('li').containsText('Alice');
+    assert.dom('li').doesNotContainText('Bob');
+  });
+});

tests/acceptance/variables-test.js

@@ -0,0 +1,9 @@
+query PeopleSameNameAsPets($name: String!) {
+  people(firstName: $name) {
+    firstName
+    lastName
+    pets(name: $name) {
+      name
+    }
+  }
+}