Merge pull request #238 from the-hideout/more-location-info

add location information for lots of things

.gitignore

@@ -5,3 +5,4 @@ dist/
 .env
 .vscode/
 tmp/
+kv/

datasources/maps.js

@@ -88,6 +88,48 @@ class MapAPI extends WorkerKV {
             return false;
         });
     }
+
+    async getLootContainer(context, id) {
+        await this.init(context);
+        return this.cache.LootContainer[id];
+    }
+
+    async getAllLootContainers(context) {
+        await this.init(context);
+        return Object.values(this.cache.LootContainer);
+    }
+
+    async getExtract(context, id) {
+        await this.init(context);
+        return this.cache.Map.reduce((found, current) => {
+            if (found) {
+                return found;
+            }
+            found = current.extracts.find(e => e.id === id);
+            return found;
+        }, false);
+    }
+
+    async getSwitch(context, id) {
+        await this.init(context);
+        return this.cache.Map.reduce((found, current) => {
+            if (found) {
+                return found;
+            }
+            found = current.switches.find(e => e.id === id);
+            return found;
+        }, false);
+    }
+
+    async getStationaryWeapon(context, id) {
+        await this.init(context);
+        return this.cache.StationaryWeapon[id];
+    }
+
+    async getAllStationaryWeapons(context) {
+        await this.init(context);
+        return Object.values(this.cache.StationaryWeapon);
+    }
 }
 
 module.exports = MapAPI;

datasources/schema.js

@@ -5,32 +5,32 @@ class SchemaAPI extends WorkerKV {
         super('schema_data', dataSource);
     }
 
-    async getCategories(requestId) {
-        await this.init(requestId);
+    async getCategories(context) {
+        await this.init(context);
         if (!this.cache) {
             return Promise.reject(new Error('Schema cache is empty'));
         }
         return this.cache.ItemCategory;
     }
 
-    async getHandbookCategories(requestId) {
-        await this.init(requestId);
+    async getHandbookCategories(context) {
+        await this.init(context);
         if (!this.cache) {
             return Promise.reject(new Error('Schema cache is empty'));
         }
         return this.cache.HandbookCategory;
     }
 
-    async getItemTypes(requestId) {
-        await this.init(requestId);
+    async getItemTypes(context) {
+        await this.init(context);
         if (!this.cache) {
             return Promise.reject(new Error('Schema cache is empty'));
         }
         return this.cache.ItemType;
     }
 
-    async getLanguageCodes(requestId) {
-        await this.init(requestId);
+    async getLanguageCodes(context) {
+        await this.init(context);
         if (!this.cache) {
             return Promise.reject(new Error('Schema cache is empty'));
         }

index.js

@@ -26,7 +26,7 @@ const schemaRefreshInterval = 1000 * 60 * 10;
 const skipCache = false; //ENVIRONMENT !== 'production' || false;
 
 // Example of how router can be used in an application
-async function getSchema(data, requestId) {
+async function getSchema(data, context) {
     if (schema && new Date() - lastSchemaRefresh < schemaRefreshInterval) {
         return schema;
     }
@@ -46,13 +46,13 @@ async function getSchema(data, requestId) {
                     console.log(`Schema loading timed out; forcing load`);
                     clearInterval(loadingInterval);
                     loadingSchema = false;
-                    return resolve(getSchema(data, requestId));
+                    return resolve(getSchema(data, context));
                 }
             }, 100);
         });
     }
     loadingSchema = true;
-    return dynamicTypeDefs(data, requestId).catch(error => {
+    return dynamicTypeDefs(data, context).catch(error => {
         loadingSchema = false;
         console.error('Error loading dynamic type definitions', error);
         return Promise.reject(error);
@@ -162,7 +162,7 @@ async function graphqlHandler(event, graphQLOptions) {
     }
 
     const context = { data: dataAPI, util: graphqlUtil, requestId, lang: {}, warnings: [], errors: [] };
-    let result = await graphql(await getSchema(dataAPI, requestId), query, {}, context, variables);
+    let result = await graphql(await getSchema(dataAPI, context), query, {}, context, variables);
     if (context.errors.length > 0) {
         if (!result.errors) {
             result = Object.assign({errors: []}, result); // this puts the errors at the start of the result