fix(fetch): additional stuff

Author: StephanGerbeth

packages/operators/fixtures/paginatedFetchFixture.js

@@ -0,0 +1,12 @@
+const test = await fetch('https://dummyjson.com/products?limit=10&skip=0&select=title,price');
+console.log(test);
+const a = new Blob([test]);
+console.log(a);
+
+const fr = new FileReader();
+
+fr.onload = function () {
+  console.log(JSON.parse(this.result));
+};
+
+fr.readAsText(a);

packages/operators/src/fetch/concurrentDownload.test.js

@@ -0,0 +1,35 @@
+import { concatMap, map } from 'rxjs';
+
+import { replaceTypes } from './json/replacer.js';
+import { reviveTypes } from './json/reviver.js';
+import { defaultDeserializeReworker, defaultSerializeReworker } from './json/reworker/default.js';
+import { signJSON, verifyJSON } from './sign.js';
+
+export const serialize = (reworker, signer) => source =>
+  source.pipe(
+    rework(reworker || defaultSerializeReworker),
+    map(data => JSON.stringify(data, replaceTypes)),
+    signJSON(signer)
+  );
+
+export const deserialize = (reworker, signAddress) => source =>
+  source.pipe(
+    verifyJSON(signAddress),
+    map(data => JSON.parse(data, reviveTypes)),
+    rework(reworker || defaultDeserializeReworker)
+  );
+
+const rework = reworker => source =>
+  source.pipe(
+    concatMap(data => reworkEntry('data', data, reworker)),
+    map(data => Object.fromEntries(data).data)
+  );
+
+const reworkEntry = async (key, value, reworker) => {
+  const { transform } = reworker.find(({ type }) => type === value?.constructor) || {};
+  if (transform) {
+    return await transform(key, value, reworkEntry, reworker);
+  } else {
+    return [[key, value]];
+  }
+};

packages/operators/src/json.js

@@ -0,0 +1,10 @@
+export const replaceTypes = (key, value) => {
+  if (value?.constructor && value.constructor === Date) {
+    return value.toISOString();
+  }
+
+  if (value?.constructor && value.constructor === BigInt) {
+    return value.toString();
+  }
+  return value;
+};

packages/operators/src/json/replacer.js

@@ -0,0 +1,26 @@
+export const reviveTypes = (key, value) => {
+  if (isValidUrl(value)) {
+    return new URL(value);
+  }
+  if (isValidISODateString(value)) {
+    return new Date(value);
+  }
+  if (isBigInt(value)) {
+    return BigInt(value);
+  }
+  return value;
+};
+
+const isValidUrl = value => {
+  return URL.canParse(value) && /^[\w]+:\/\/\S+$/gm.test(value);
+};
+
+function isValidISODateString(value) {
+  if (!/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(value)) return false;
+  const d = new Date(value);
+  return d instanceof Date && !isNaN(d.getTime()) && d.toISOString() === value; // valid date
+}
+
+function isBigInt(value) {
+  return value?.constructor === String && /^\d+$/.test(value);
+}

packages/operators/src/json/reviver.js

@@ -0,0 +1,30 @@
+export const defaultReworker = [
+  {
+    type: Array,
+    transform: async (key, value, rework, reworker) => [
+      [
+        key,
+        Array.from(
+          await Promise.all(value.map((entry, key) => rework(key, entry, reworker))),
+          ([[, value]]) => value
+        )
+      ]
+    ]
+  },
+  {
+    type: Object,
+    transform: async (key, value, rework, reworker) => [
+      [
+        key,
+        Object.fromEntries(
+          await Object.entries(value).reduce(async (accumulator, [key, value]) => {
+            return [...(await accumulator), ...(await rework(key, await value, reworker))];
+          }, Promise.resolve([]))
+        )
+      ]
+    ]
+  }
+];
+
+export const defaultSerializeReworker = defaultReworker;
+export const defaultDeserializeReworker = defaultReworker;

packages/operators/src/json/reworker/default.js

@@ -0,0 +1,43 @@
+import { defaultDeserializeReworker, defaultSerializeReworker } from './default.js';
+
+const serializeMapping = {
+  tokenData: { name: 'tokenURI', preserve: false },
+  contractData: { name: 'contractURI', preserve: false }
+};
+export const serializeReworker = resolve =>
+  defaultSerializeReworker.concat([
+    {
+      type: Blob,
+      transform: async (key, value) => transform(key, value, serializeMapping[String(key)], resolve)
+    }
+  ]);
+
+const deserializeMapping = {
+  tokenURI: { name: 'tokenData', preserve: true },
+  contractURI: { name: 'contractData', preserve: true }
+};
+export const deserializeReworker = resolve =>
+  defaultDeserializeReworker.concat([
+    {
+      type: URL,
+      transform: async (key, value) =>
+        transform(key, value, deserializeMapping[String(key)], resolve)
+    }
+  ]);
+
+const transform = async (key, value, config, resolve) => {
+  const result = await resolve(normalizeUrl(value), key);
+  if (config?.preserve) {
+    result.tokenURI = value.toString();
+  }
+  return [
+    !config || config.preserve ? [key, value] : undefined,
+    [config?.name || key, result]
+  ].filter(Boolean);
+};
+
+const normalizeUrl = url => {
+  const regex = /^(?<protocol>\w+:)\/\/(?<cid>\w+)\/*(?<filename>[\w.]+)*$/gm;
+  const { groups } = regex.exec(url);
+  return url + (groups.filename ? '' : '0');
+};

packages/operators/src/json/reworker/token.js

@@ -0,0 +1,12 @@
+import { ReplaySubject, share, timer } from 'rxjs';
+
+export const cache = ttl => {
+  return source =>
+    source.pipe(
+      share({
+        // TODO: check if a buffer size is neccessary
+        connector: () => new ReplaySubject(),
+        resetOnComplete: () => timer(ttl)
+      })
+    );
+};