startgg-helper 1.0.3 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "startgg-helper",
-  "version": "1.0.3",
+  "version": "2.0.1",
   "description": "A set of functions and classes useful to communicate with the start.gg API, using any client (YOU NEED TO PROVIDE A CLIENT YOURSELF, SEE README)",
   "main": "main.js",
   "scripts": {

package/src/jsUtil.js

@@ -1,12 +1,4 @@
-/**
- * 
- * @param {{}} obj 
- * @param {string} path 
- * @param {*} def 
- * @returns 
- */
-export function deep_get(obj, path, def = null){
-    //https://stackoverflow.com/a/8817473
+function processObjectPath(path){
     path = path=path.split('.');
     for (let i = 0; i < path.length; i++){
         if (/^\d/.test(path[i])){
@@ -16,10 +8,37 @@ export function deep_get(obj, path, def = null){
             }
         }
     }
+    return path;
+}
+
+/**
+ * 
+ * @param {{}} obj 
+ * @param {string} path 
+ * @param {*} def 
+ * @returns 
+ */
+export function deep_get(obj, path, def = null){
+    //https://stackoverflow.com/a/8817473
+    path = processObjectPath(path);
 
     for (var i=0, len=path.length; i<len; i++){
         obj = obj[path[i]];
         if (obj == undefined) return def;
     };
     return obj;
-};
+};
+
+export function deep_set(obj, path, value){
+    path = processObjectPath(path);
+
+    let finalName = path.pop();
+    for (let elt of path){
+        obj = obj[elt];
+        if (!(obj instanceof Object)){
+            return false;
+        }
+    }
+    obj[finalName] = value;
+    return true;
+}

package/src/query.js

@@ -1,12 +1,9 @@
-import { deep_get } from './jsUtil.js';
+import { GraphQLClient } from 'graphql-request';
+import { deep_get, deep_set } from './jsUtil.js';
 import { TimedQuerySemaphore } from './queryLimiter.js'
 
-/**
- * Dummy client class that's only used in the JSDoc. 
- * In a real use case, the user will have their own client class.
- */
-class Client {
-    request(){}
+function isConnection(val){
+    return val instanceof Object && val.nodes instanceof Array
 }
 
 export class Query {
@@ -44,7 +41,7 @@ export class Query {
 
     /**
      * 
-     * @param {Client} client 
+     * @param {GraphQLClient} client 
      * @param {{[varName: string]: value}} params 
      * @param {number} tries How many tries in are we 
      * @param {TimedQuerySemaphore} limiter 
@@ -73,7 +70,7 @@ export class Query {
 
     /**
      * Executes the query with given parameters and client
-     * @param {Client} client 
+     * @param {GraphQLClient} client 
      * @param {{[varName: string]: value}} params 
      * @param {TimedQuerySemaphore} limiter 
      * @param {boolean} silentErrors 
@@ -84,29 +81,124 @@ export class Query {
         return await this.#execute_(client, params, 0, limiter, silentErrors, maxTries);
     }
 
+    static IWQModes = {
+        DONT: 0,
+        INLINE: 1,
+        DUPLICATE: 2,
+        OUT: 3
+    }
+
+    /**
+     * Executes a query containing a paginated collection (of a *Connection type) repeatedly, increasing the page index each time until nothing is returned, returning an aggregation of all the pages.
+     * @param {GraphQLClient} client 
+     * @param {{[varName: string]: value}} params 
+     * @param {string} connectionPathInQuery JSON path to the paginated collection that must aggregated in the query (JSON path : property names separated by dots)
+     * @param {TimedQuerySemaphore} limiter 
+     * @param {{pageParamName?: string, perPageParamName?: string, perPage?: number, delay?: number, maxElements?: number, includeWholeQuery?: number}} config 
+     * @param {boolean} silentErrors 
+     * @param {number} maxTries 
+     * @returns 
+     */
+    async executePaginated(client, params, connectionPathInQuery, limiter = null, config = {}, silentErrors = false, maxTries = null){
+        let result = [];
+        //delay = null, perPage = undefined, pageParamName = "page", perPageParamName = "perPage", silentErrors = false, maxTries = null
+        const pageParamName = config.pageParamName ?? "page";
+        const perPageParamName = config.perPageParamName ?? "perPage";
+        const perPage = config.perPage ?? params[perPageParamName];
+        const delay = config.delay;
+        const maxElements = config.maxElements ?? undefined; //eliminating null
+
+        let currentPage = 1;
+
+        params = Object.assign({}, params);
+        params[pageParamName] = currentPage;
+        params[perPageParamName] = perPage;
+
+        let data;
+        while (true){
+            if (result.length >= maxElements) break;
+
+            console.log("Querying page", params[pageParamName], `(${result.length} elements loaded)`);
+            data = await this.execute(client, params, limiter, silentErrors, maxTries);
+
+            if (!data) throw (this.#getLog("error", params) ?? "Request failed.") + "(in paginated execution, at page " + params[pageParamName] + ")";
+
+            let connection = deep_get(data, connectionPathInQuery);
+
+            if (!connection) {
+                console.warn(`The given path ${connectionPathInQuery} does not point to anything.`);
+                return null;
+            }
+
+            if (!isConnection(connection)) throw "The given path does not point to a connection type"
+            console.log(connection);
+
+            let localResult = connection.nodes;
+            if (connection.pageInfo && connection.pageInfo.totalPages){
+                let totalPages = connection.pageInfo.totalPages;
+                if (currentPage >= totalPages) {
+                    result = result.concat(localResult);
+                    break;
+                }
+            } else {
+                if (localResult.length < 1) break;
+            }
+
+            result = result.concat(localResult);
+            currentPage++;
+            params[pageParamName] = currentPage;
+
+            if (delay)
+                await new Promise(r => setTimeout(r, delay));
+        }
+
+        if (maxElements) result = result.slice(0, maxElements);
+
+        if (config.includeWholeQuery == Query.IWQModes.DUPLICATE || config.includeWholeQuery == Query.IWQModes.INLINE){
+            deep_set(data, connectionPathInQuery + ".nodes", result);
+        } else if (config.includeWholeQuery == Query.IWQModes.OUT){
+            deep_set(data, connectionPathInQuery + ".nodes", null);
+        }
+
+        if (config.includeWholeQuery == Query.IWQModes.DUPLICATE || config.includeWholeQuery == Query.IWQModes.OUT){
+            return [result, data]
+        } else if (config.includeWholeQuery == Query.IWQModes.INLINE){
+            return data;
+        }
+
+        return result;
+    }
+
     /**
      * Executes a query containing a paginated collection, repeatedly, increasing the page index each time until nothing is returned, returning an aggregation of all the pages.
-     * @param {Client} client 
+     * @param {GraphQLClient} client 
      * @param {{[varName: string]: value}} params 
      * @param {string} collectionPathInQuery JSON path to the paginated collection that must aggregated in the query (JSON path : property names separated by dots)
      * @param {TimedQuerySemaphore} limiter 
-     * @param {number} delay Adds a delay between calls (does not interact with the limiter)
-     * @param {string} pageParamName Name of the query parameter that must be updated with a page index for each query
+     * @param {{pageParamName?: string, perPageParamName?: string, perPage?: number, delay?: number, maxElements?: number, includeWholeQuery?: number}} config 
      * @param {boolean} silentErrors 
      * @param {number} maxTries 
      * @returns 
      */
-    async executePaginated(client, params, collectionPathInQuery, limiter = null, delay = null, perPage = undefined, pageParamName = "page", perPageParamName = "perPage", silentErrors = false, maxTries = null){
+    async executePaginatedLegacy(client, params, collectionPathInQuery, limiter = null, config = {}, silentErrors = false, maxTries = null){
         let result = [];
-
+        //delay = null, perPage = undefined, pageParamName = "page", perPageParamName = "perPage", silentErrors = false, maxTries = null
+        const pageParamName = config.pageParamName ?? "page";
+        const perPageParamName = config.perPageParamName ?? "perPage";
+        const perPage = config.perPage ?? params[perPageParamName];
+        const delay = config.delay;
+        const maxElements = config.maxElements ?? undefined; //eliminating null
 
         params = Object.assign({}, params);
         params[pageParamName] = 1;
-        params[perPageParamName] = perPage ?? params[perPageParamName];
+        params[perPageParamName] = perPage;
 
+        let data;
         while (true){
+            if (result.length >= maxElements) break;
+
             console.log("Querying page", params[pageParamName], `(${result.length} elements loaded)`);
-            let data = await this.execute(client, params, limiter, silentErrors, maxTries);
+            data = await this.execute(client, params, limiter, silentErrors, maxTries);
 
             if (!data) throw (this.#getLog("error", params) ?? "Request failed.") + "(in paginated execution, at page " + params[pageParamName] + ")";
 
@@ -128,6 +220,20 @@ export class Query {
                 await new Promise(r => setTimeout(r, delay));
         }
 
+        if (maxElements) result = result.slice(0, maxElements);
+
+        if (config.includeWholeQuery == Query.IWQModes.DUPLICATE || config.includeWholeQuery == Query.IWQModes.INLINE){
+            deep_set(data, collectionPathInQuery, result);
+        } else if (config.includeWholeQuery == Query.IWQModes.OUT){
+            deep_set(data, collectionPathInQuery, null);
+        }
+
+        if (config.includeWholeQuery == Query.IWQModes.DUPLICATE || config.includeWholeQuery == Query.IWQModes.OUT){
+            return [result, data]
+        } else if (config.includeWholeQuery == Query.IWQModes.INLINE){
+            return data;
+        }
+
         return result;
     }
 }