Update deps and rewrite resolvers to not compute everything and put it in context

index.js

@@ -1,14 +1,6 @@
 import resolvers from './resolvers';
 import typeDefs from './schema';
 import {ApolloServer} from 'apollo-server';
-import {continents, countries, languages} from 'countries-list';
-
-function toArray(object) {
-  return Object.keys(object).map(code => ({
-    ...object[code],
-    code
-  }));
-}
 
 const server = new ApolloServer({
   typeDefs,
@@ -17,14 +9,6 @@ const server = new ApolloServer({
   playground: true,
   engine: {
     apiKey: process.env.ENGINE_API_KEY
-  },
-  context: {
-    continents: Object.entries(continents).map(([code, name]) => ({
-      code,
-      name
-    })),
-    countries: toArray(countries),
-    languages: toArray(languages)
   }
 });
 

package.json

@@ -8,10 +8,10 @@
     "start": "nodemon -r dotenv/config -r esm index.js"
   },
   "dependencies": {
-    "apollo-server": "^2.1.0",
+    "apollo-server": "^2.7.0",
-    "countries-list": "^2.3.2",
+    "countries-list": "^2.4.3",
-    "esm": "^3.0.84",
+    "esm": "^3.2.25",
-    "graphql": "^14.0.2"
+    "graphql": "^14.4.2"
   },
   "devDependencies": {
     "@trevorblades/eslint-config": "^6.18.0",

resolvers.js

@@ -1,25 +1,67 @@
-function byCode(code) {
+import {continents, countries, languages} from 'countries-list';
-  return item => item.code === code;
-}
 
 export default {
   Country: {
-    continent: (country, args, {continents}) =>
+    continent({continent}) {
-      continents.find(continent => continent.code === country.continent),
+      return {
-    languages: (country, args, {languages}) =>
+        code: continent,
-      languages.filter(language => country.languages.includes(language.code))
+        name: continents[continent]
+      };
+    },
+    languages(parent) {
+      return parent.languages.map(code => {
+        const language = languages[code];
+        return {
+          ...language,
+          code
+        };
+      });
+    }
   },
   Continent: {
-    countries: (continent, args, {countries}) =>
+    countries(parent) {
-      countries.filter(country => country.continent === continent.code)
+      return Object.entries(countries)
+        .filter(entry => entry[1].continent === parent.code)
+        .map(([code, country]) => ({
+          ...country,
+          code
+        }));
+    }
   },
   Query: {
-    continent: (parent, args, {continents}) =>
+    continent(parent, {code}) {
-      continents.find(byCode(args.code)),
+      return {
-    continents: (parent, args, {continents}) => continents,
+        code,
-    country: (parent, args, {countries}) => countries.find(byCode(args.code)),
+        name: continents[code]
-    countries: (parent, args, {countries}) => countries,
+      };
-    language: (parent, args, {languages}) => languages.find(byCode(args.code)),
+    },
-    languages: (parent, args, {languages}) => languages
+    continents() {
+      return Object.entries(continents).map(([code, name]) => ({
+        code,
+        name
+      }));
+    },
+    country(parent, {code}) {
+      return countries[code];
+    },
+    countries() {
+      return Object.entries(countries).map(([code, country]) => ({
+        ...country,
+        code
+      }));
+    },
+    language(parent, {code}) {
+      const language = languages[code];
+      return {
+        ...language,
+        code
+      };
+    },
+    languages() {
+      return Object.entries(languages).map(([code, language]) => ({
+        ...language,
+        code
+      }));
+    }
   }
 };