@selkirk-systems/fetch 1.4.0 → 1.5.0

package/dist/utils/FetchUtils.js

@@ -37,19 +37,77 @@ export async function fetchPagedURL(url, callback, options) {
   };
   callback = callback ? callback : () => {};
   let ret = [];
-  const proxyUrl = url.toString().split("/p/");
+  let cachedCallbacks = [];
+  let invokedCallbacks = 0;
   const [response] = await Fetch(url, finalOptions);
   const {
     data,
     status
   } = response;
-  const size = new TextEncoder().encode(JSON.stringify(data)).length;
-  const kiloBytes = size / 1024;
-  const megaBytes = kiloBytes / 1024;
   if (status.code > 299 || status.code < 200) {
     return [response, null];
   }
-  const results = {
+  let results = getResults(data);
+  const items = getEmbedded(data);
+  await callback(results, items);
+  ret.push({
+    id: 0,
+    items: items
+  });
+  if (data._links && data.page.totalPages > 1) {
+    const nextUrls = [];
+    for (let i = 1; i < data.page.totalPages; i++) {
+      const nextUrl = new URL(url);
+      nextUrl.searchParams.set("page", i);
+      nextUrls.push(Fetch(nextUrl, finalOptions).then(async ([response]) => {
+        const {
+          data,
+          status
+        } = response;
+        const results = getResults(data);
+        const items = getEmbedded(data);
+        if (i === invokedCallbacks + 1) {
+          invokedCallbacks++;
+          await callback(results, items);
+        } else {
+          cachedCallbacks.push({
+            index: i,
+            results: results,
+            items: items
+          });
+        }
+        ret.push({
+          id: i,
+          items: items
+        });
+        return results;
+      }));
+    }
+    const resultsArray = await Promise.all(nextUrls);
+    results = resultsArray[resultsArray.length - 1];
+    await invokeCallbacks(cachedCallbacks, callback);
+    ret = sortByProp(ret, "id");
+    ret = ret.reduce((acc, value) => acc.concat(value.items), []);
+  }
+  return [null, ret, {
+    ...results,
+    page: data.page.totalPages
+  }];
+}
+async function invokeCallbacks(array, callback) {
+  array = sortByProp(array, "index");
+  await array.map(a => {
+    return callback(a.results, a.items);
+  });
+}
+function getEmbedded(data) {
+  return data._embedded[[Object.keys(data._embedded)[0]]];
+}
+function getResults(data) {
+  const size = new TextEncoder().encode(JSON.stringify(data)).length;
+  const kiloBytes = size / 1024;
+  const megaBytes = kiloBytes / 1024;
+  return {
     page: data.page.number + 1,
     totalPages: data.page.totalPages,
     totalElements: data.page.totalElements,
@@ -57,17 +115,17 @@ export async function fetchPagedURL(url, callback, options) {
     kiloBytes: kiloBytes,
     megaBytes: megaBytes
   };
-  data.items = data._embedded[[Object.keys(data._embedded)[0]]];
-  await callback(results, data.items);
-  ret = ret.concat(data.items || []);
-  if (data._links && data._links.next) {
-    const nextUrl = new URL(`${proxyUrl[0]}/p/${data._links.next.href}`);
-    nextUrl.search = createUrlParams({}, nextUrl.searchParams);
-    const [err, nextPage] = await fetchPagedURL(nextUrl, callback, options);
-    if (err) return [err, nextPage];
-    ret = ret.concat(nextPage);
-  }
-  return [null, ret];
+}
+function sortByProp(array, prop) {
+  return array.sort((a, b) => {
+    if (a[prop] < b[prop]) {
+      return -1;
+    } else if (a[prop] > b[prop]) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
 }
 function timeout(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));

package/lib/utils/FetchUtils.js

@@ -63,20 +63,101 @@ export async function fetchPagedURL( url, callback, options ) {
 
     let ret = [];
 
-    const proxyUrl = url.toString().split( "/p/" );
+    let cachedCallbacks = [];
+    let invokedCallbacks = 0;
 
     const [response] = await Fetch( url, finalOptions );
     const { data, status } = response;
 
-    const size = new TextEncoder().encode( JSON.stringify( data ) ).length;
-    const kiloBytes = size / 1024;
-    const megaBytes = kiloBytes / 1024;
-
     if ( status.code > 299 || status.code < 200 ) {
         return [response, null];
     }
 
-    const results = {
+    let results = getResults( data );
+
+    const items = getEmbedded( data );
+
+    await callback( results, items );
+
+    ret.push( { id: 0, items: items } );
+
+    if ( data._links && data.page.totalPages > 1 ) {
+
+        const nextUrls = [];
+
+        for ( let i = 1; i < data.page.totalPages; i++ ) {
+
+            const nextUrl = new URL( url );
+
+            nextUrl.searchParams.set( "page", i );
+
+            nextUrls.push( Fetch( nextUrl, finalOptions ).then( async ( [response] ) => {
+
+                const { data, status } = response;
+                const results = getResults( data );
+                const items = getEmbedded( data );
+
+                if ( i === ( invokedCallbacks + 1 ) ) {
+                    invokedCallbacks++;
+                    await callback( results, items );
+                }
+                else {
+                    cachedCallbacks.push( { index: i, results: results, items: items } );
+                }
+
+                ret.push( {
+                    id: i,
+                    items: items
+                } );
+
+                return results;
+
+            } ) );
+        }
+
+        const resultsArray = await Promise.all( nextUrls );
+        results = resultsArray[resultsArray.length - 1];
+
+        await invokeCallbacks( cachedCallbacks, callback );
+
+        ret = sortByProp( ret, "id" );
+
+        ret = ret.reduce( ( acc, value ) => acc.concat( value.items ), [] );
+
+    }
+
+
+    return [null, ret, { ...results, page: data.page.totalPages }];
+
+}
+
+async function invokeCallbacks( array, callback ) {
+
+    array = sortByProp( array, "index" );
+
+    await array.map( a => {
+        return callback( a.results, a.items );
+    } )
+
+}
+
+
+function getEmbedded( data ) {
+
+
+    return data._embedded[[Object.keys( data._embedded )[0]]];
+
+
+}
+
+
+function getResults( data ) {
+
+    const size = new TextEncoder().encode( JSON.stringify( data ) ).length;
+    const kiloBytes = size / 1024;
+    const megaBytes = kiloBytes / 1024;
+
+    return {
         page: data.page.number + 1,
         totalPages: data.page.totalPages,
         totalElements: data.page.totalElements,
@@ -84,28 +165,28 @@ export async function fetchPagedURL( url, callback, options ) {
         kiloBytes: kiloBytes,
         megaBytes: megaBytes
     }
+}
 
-    data.items = data._embedded[[Object.keys( data._embedded )[0]]];
+function sortByProp( array, prop ) {
 
-    await callback( results, data.items );
 
-    ret = ret.concat( data.items || [] );
+    return array.sort( ( a, b ) => {
 
-    if ( data._links && data._links.next ) {
+        if ( a[prop] < b[prop] ) {
 
-        const nextUrl = new URL( `${proxyUrl[0]}/p/${data._links.next.href}` );
+            return -1;
 
-        nextUrl.search = createUrlParams( {}, nextUrl.searchParams );
+        } else if ( a[prop] > b[prop] ) {
 
-        const [err, nextPage] = await fetchPagedURL( nextUrl, callback, options );
+            return 1;
 
-        if ( err ) return [err, nextPage];
+        } else {
 
-        ret = ret.concat( nextPage );
+            return 0;
 
-    }
+        }
 
-    return [null, ret];
+    } )
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selkirk-systems/fetch",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Abortable fetch library",
   "keywords": [],
   "author": "Marcos Bernal <mbernal@selkirksystems.com>",
@@ -36,5 +36,5 @@
   "peerDependencies": {
     "@selkirk-systems/state-management": ">=1.0.0"
   },
-  "gitHead": "29c0902c5e98d9679a6e4dd6977459265875ae2e"
+  "gitHead": "3f425f25b96a2239bea972a184391ceb709f64bb"
 }