@certik/skynet 0.20.1 → 0.21.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.21.0
+
+- BREAKING: Remove support for web3.js.
+- Add `debug` log level to `log` library. They will only be printed when `NODE_ENV` is set to `development`.
+- Hide all logs from `log` library when `NODE_ENV` is set to `test`.
+- Add `throttle` and `memoize` to `availability` library.
+- Add `object-hash` library for getting hash of an object. Based on xxhash algorithm.
+
+## 0.20.2
+
+- Make `options` in `withRetry` function optional
+
 ## 0.20.1
 
 - Update dynamodb `scanWholeTable` types

package/availability.ts

@@ -1,3 +1,12 @@
+import pThrottle from "p-throttle";
+import pMemoize, { type CacheStorage } from "p-memoize";
+import type { AsyncReturnType } from "type-fest";
+import QuickLRU from "quick-lru";
+import { getHash } from "./object-hash";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export declare type AnyAsyncFunction = (...arguments_: readonly any[]) => Promise<any>;
+
 export async function wait(time: number) {
   return new Promise((resolve) => {
     setTimeout(resolve, time);
@@ -47,28 +56,49 @@ export async function exponentialRetry<T>(
   return result;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function withRetry<F extends (...args: any[]) => any>(
+export function withRetry<F extends AnyAsyncFunction>(
   func: F,
-  options: { maxRetry: number; initialDuration?: number; growFactor?: number },
-) {
-  let retries = options.maxRetry;
-  let duration = options.initialDuration || 500;
-  const growFactorFinal = options.growFactor || 2;
+  options?: { maxRetry?: number; initialDuration?: number; growFactor?: number },
+): F {
+  let retries = options?.maxRetry || 3;
+  let duration = options?.initialDuration || 500;
+  const growFactorFinal = options?.growFactor || 2;
 
-  return async (...args: Parameters<F>): Promise<ReturnType<F>> => {
+  return (async (...args: Parameters<F>): Promise<AsyncReturnType<F>> => {
     do {
       try {
         return await func(...args);
       } catch (error) {
         retries = retries - 1;
-        if (retries === 0) {
+        if (retries <= 0) {
           throw error;
         }
         await wait(duration);
         duration = duration * growFactorFinal;
       }
-    } while (retries >= 0);
+    } while (retries > 0);
     throw new Error("unreachable");
-  };
+  }) as F;
+}
+
+export function memoize<F extends AnyAsyncFunction>(
+  func: F,
+  options?: {
+    cache?: CacheStorage<string, AsyncReturnType<F>> | false;
+    cacheKey?: (args: Parameters<F>) => string;
+    lruMaxSize?: number;
+  },
+) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.cache) {
+    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 10000 });
+  }
+  if (!options.cacheKey) {
+    options.cacheKey = (args: Parameters<F>) => getHash(args);
+  }
+  return pMemoize<F, string>(func, options);
 }
+
+export { pThrottle as throttle };

package/log.ts

@@ -34,20 +34,38 @@ function timestamp() {
 }
 
 const inline = {
+  debug: function (...args: unknown[]) {
+    if (process.env.NODE_ENV === "development") {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
   log: function (...args: unknown[]) {
-    console.log(`${timestamp()} ${getLine(args)}`);
+    if (process.env.NODE_ENV !== "test") {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
   },
   error: function (...args: unknown[]) {
-    console.error(`${timestamp()} ${getLine(args)}`);
+    if (process.env.NODE_ENV !== "test") {
+      console.error(`${timestamp()} ${getLine(args)}`);
+    }
   },
 };
 
 const logger = {
+  debug: function (...args: unknown[]) {
+    if (process.env.NODE_ENV === "development") {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
   log: function (...args: unknown[]) {
-    console.log(`[${timestamp()}]`, ...args);
+    if (process.env.NODE_ENV !== "test") {
+      console.log(`[${timestamp()}]`, ...args);
+    }
   },
   error: function (...args: unknown[]) {
-    console.error(`[${timestamp()}]`, ...args);
+    if (process.env.NODE_ENV !== "test") {
+      console.error(`[${timestamp()}]`, ...args);
+    }
   },
 };
 

package/object-hash.ts

@@ -0,0 +1,66 @@
+import xh from "@node-rs/xxhash";
+
+export function getHash(obj: unknown) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
+}
+
+function hash(obj: unknown, xxh3: xh.xxh3.Xxh3) {
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
+}
+
+function arrayHash(array: unknown[], xxh3: xh.xxh3.Xxh3) {
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function setHash(_set: Set<unknown>, _xxh3: xh.xxh3.Xxh3) {
+  throw new Error("Set hashing not implemented");
+}
+
+function mapHash(map: Map<unknown, unknown>, xxh3: xh.xxh3.Xxh3) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => (aKey as any).localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function objectHash(obj: any, xxh3: xh.xxh3.Xxh3) {
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@certik/skynet",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "Skynet Shared JS library",
   "type": "module",
   "main": "index.ts",
@@ -21,14 +21,17 @@
     "@aws-sdk/lib-dynamodb": "^3.758.0",
     "@databricks/sql": "^1.9.0",
     "@elastic/elasticsearch": "^8.17.1",
+    "@node-rs/xxhash": "^1.7.6",
     "@slack/web-api": "^6.13.0",
     "chalk": "^5.4.1",
     "execa": "^9.5.2",
     "express": "^4.21.2",
     "md5": "^2.3.0",
     "meow": "^13.2.0",
+    "p-memoize": "^7.1.1",
+    "p-throttle": "^7.0.0",
+    "quick-lru": "^7.0.0",
     "type-fest": "^4.35.0",
-    "web3": "^4.16.0",
     "which": "^5.0.0"
   },
   "devDependencies": {

package/web3.ts

@@ -1,41 +0,0 @@
-import { Web3 } from "web3";
-import type { AbiFunctionFragment } from "web3";
-import { PROTOCOLS } from "./const.ts";
-
-function newWeb3ByProtocol(protocol: string) {
-  if (!Object.keys(PROTOCOLS).includes(protocol)) {
-    return null;
-  }
-
-  return new Web3(PROTOCOLS[protocol].endpoint);
-}
-
-function normalizeCallParams<T>(params?: T) {
-  if (params === undefined) {
-    return [] as T[];
-  }
-
-  if (Array.isArray(params)) {
-    return params as T[];
-  }
-
-  return [params];
-}
-
-async function singleCall<TData, TParams>(protocol: string, abi: AbiFunctionFragment, target: string, params: TParams) {
-  const web3 = newWeb3ByProtocol(protocol);
-
-  if (!web3) {
-    throw new Error(`unsupported protocol`);
-  }
-
-  const contract = new web3.eth.Contract([abi], target);
-  const functionSignature = web3.eth.abi.encodeFunctionSignature(abi);
-  const method = contract.methods[functionSignature];
-
-  const result = await method(...normalizeCallParams(params)).call<TData>();
-
-  return result;
-}
-
-export { singleCall };