@atproto/common-web 0.2.3 → 0.2.4

package/dist/ipld.d.ts

@@ -1,8 +1,8 @@
 import { CID } from 'multiformats/cid';
-export declare type JsonValue = boolean | number | string | null | undefined | unknown | Array<JsonValue> | {
+export type JsonValue = boolean | number | string | null | undefined | unknown | Array<JsonValue> | {
     [key: string]: JsonValue;
 };
-export declare type IpldValue = JsonValue | CID | Uint8Array | Array<IpldValue> | {
+export type IpldValue = JsonValue | CID | Uint8Array | Array<IpldValue> | {
     [key: string]: IpldValue;
 };
 export declare const jsonToIpld: (val: JsonValue) => IpldValue;

package/dist/retry.d.ts

@@ -0,0 +1,7 @@
+export type RetryOptions = {
+    maxRetries?: number;
+    getWaitMs?: (n: number) => number | null;
+    retryable?: (err: unknown) => boolean;
+};
+export declare function retry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+export declare function backoffMs(n: number, multiplier?: number, max?: number): number;

package/dist/strings.d.ts

@@ -4,7 +4,7 @@ export declare const utf8ToB64Url: (utf8: string) => string;
 export declare const b64UrlToUtf8: (b64: string) => string;
 export declare const parseLanguage: (langTag: string) => LanguageTag | null;
 export declare const validateLanguage: (langTag: string) => boolean;
-export declare type LanguageTag = {
+export type LanguageTag = {
     grandfathered?: string;
     language?: string;
     extlang?: string;

package/dist/times.d.ts

@@ -3,3 +3,4 @@ export declare const MINUTE: number;
 export declare const HOUR: number;
 export declare const DAY: number;
 export declare const lessThanAgoMs: (time: Date, range: number) => boolean;
+export declare const addHoursToDate: (hours: number, startingDate?: Date) => Date;

package/dist/types.d.ts

@@ -16,5 +16,5 @@ export declare const def: {
     map: Def<Record<string, unknown>>;
     unknown: Def<unknown>;
 };
-export declare type ArrayEl<A> = A extends readonly (infer T)[] ? T : never;
-export declare type NotEmptyArray<T> = [T, ...T[]];
+export type ArrayEl<A> = A extends readonly (infer T)[] ? T : never;
+export type NotEmptyArray<T> = [T, ...T[]];

package/dist/util.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-export declare const noUndefinedVals: <T>(obj: Record<string, T>) => Record<string, T>;
+export declare const noUndefinedVals: <T>(obj: Record<string, T | undefined>) => Record<string, T>;
 export declare const jitter: (maxMs: number) => number;
 export declare const wait: (ms: number) => Promise<unknown>;
-export declare type BailableWait = {
+export type BailableWait = {
     bail: () => void;
     wait: () => Promise<void>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/common-web",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "license": "MIT",
   "description": "Shared web-platform-friendly code for atproto libraries",
   "keywords": [

package/src/arrays.ts

@@ -1,3 +1,10 @@
+export const keyBy = <T>(arr: T[], key: string): Record<string, T> => {
+  return arr.reduce((acc, cur) => {
+    acc[cur[key]] = cur
+    return acc
+  }, {} as Record<string, T>)
+}
+
 export const mapDefined = <T, S>(
   arr: T[],
   fn: (obj: T) => S | undefined,

package/src/async.ts

@@ -72,6 +72,8 @@ export class AsyncBuffer<T> {
   private buffer: T[] = []
   private promise: Promise<void>
   private resolve: () => void
+  private closed = false
+  private toThrow: unknown | undefined
 
   constructor(public maxSize?: number) {
     // Initializing to satisfy types/build, immediately reset by resetPromise()
@@ -88,6 +90,10 @@ export class AsyncBuffer<T> {
     return this.buffer.length
   }
 
+  get isClosed(): boolean {
+    return this.closed
+  }
+
   resetPromise() {
     this.promise = new Promise<void>((r) => (this.resolve = r))
   }
@@ -104,7 +110,17 @@ export class AsyncBuffer<T> {
 
   async *events(): AsyncGenerator<T> {
     while (true) {
+      if (this.closed && this.buffer.length === 0) {
+        if (this.toThrow) {
+          throw this.toThrow
+        } else {
+          return
+        }
+      }
       await this.promise
+      if (this.toThrow) {
+        throw this.toThrow
+      }
       if (this.maxSize && this.size > this.maxSize) {
         throw new AsyncBufferFullError(this.maxSize)
       }
@@ -117,6 +133,17 @@ export class AsyncBuffer<T> {
       }
     }
   }
+
+  throw(err: unknown) {
+    this.toThrow = err
+    this.closed = true
+    this.resolve()
+  }
+
+  close() {
+    this.closed = true
+    this.resolve()
+  }
 }
 
 export class AsyncBufferFullError extends Error {

package/src/did-doc.ts

@@ -27,6 +27,13 @@ export const getHandle = (doc: DidDocument): string | undefined => {
 // @NOTE we parse to type/publicKeyMultibase to avoid the dependency on @atproto/crypto
 export const getSigningKey = (
   doc: DidDocument,
+): { type: string; publicKeyMultibase: string } | undefined => {
+  return getVerificationMaterial(doc, 'atproto')
+}
+
+export const getVerificationMaterial = (
+  doc: DidDocument,
+  keyId: string,
 ): { type: string; publicKeyMultibase: string } | undefined => {
   const did = getDid(doc)
   let keys = doc.verificationMethod
@@ -36,7 +43,7 @@ export const getSigningKey = (
     keys = [keys]
   }
   const found = keys.find(
-    (key) => key.id === '#atproto' || key.id === `${did}#atproto`,
+    (key) => key.id === `#${keyId}` || key.id === `${did}#${keyId}`,
   )
   if (!found?.publicKeyMultibase) return undefined
   return {
@@ -45,6 +52,12 @@ export const getSigningKey = (
   }
 }
 
+export const getSigningDidKey = (doc: DidDocument): string | undefined => {
+  const parsed = getSigningKey(doc)
+  if (!parsed) return
+  return `did:key:${parsed.publicKeyMultibase}`
+}
+
 export const getPdsEndpoint = (doc: DidDocument): string | undefined => {
   return getServiceEndpoint(doc, {
     id: '#atproto_pds',
@@ -68,7 +81,7 @@ export const getNotifEndpoint = (doc: DidDocument): string | undefined => {
 
 export const getServiceEndpoint = (
   doc: DidDocument,
-  opts: { id: string; type: string },
+  opts: { id: string; type?: string },
 ) => {
   const did = getDid(doc)
   let services = doc.service
@@ -81,7 +94,7 @@ export const getServiceEndpoint = (
     (service) => service.id === opts.id || service.id === `${did}${opts.id}`,
   )
   if (!found) return undefined
-  if (found.type !== opts.type) {
+  if (opts.type && found.type !== opts.type) {
     return undefined
   }
   if (typeof found.serviceEndpoint !== 'string') {

package/src/index.ts

@@ -6,6 +6,7 @@ export * from './async'
 export * from './util'
 export * from './tid'
 export * from './ipld'
+export * from './retry'
 export * from './types'
 export * from './times'
 export * from './strings'

package/src/retry.ts

@@ -0,0 +1,52 @@
+import { wait } from './util'
+
+export type RetryOptions = {
+  maxRetries?: number
+  getWaitMs?: (n: number) => number | null
+  retryable?: (err: unknown) => boolean
+}
+
+export async function retry<T>(
+  fn: () => Promise<T>,
+  opts: RetryOptions = {},
+): Promise<T> {
+  const { maxRetries = 3, retryable = () => true, getWaitMs = backoffMs } = opts
+  let retries = 0
+  let doneError: unknown
+  while (!doneError) {
+    try {
+      return await fn()
+    } catch (err) {
+      const waitMs = getWaitMs(retries)
+      const willRetry =
+        retries < maxRetries && waitMs !== null && retryable(err)
+      if (willRetry) {
+        retries += 1
+        if (waitMs !== 0) {
+          await wait(waitMs)
+        }
+      } else {
+        doneError = err
+      }
+    }
+  }
+  throw doneError
+}
+
+// Waits exponential backoff with max and jitter: ~100, ~200, ~400, ~800, ~1000, ~1000, ...
+export function backoffMs(n: number, multiplier = 100, max = 1000) {
+  const exponentialMs = Math.pow(2, n) * multiplier
+  const ms = Math.min(exponentialMs, max)
+  return jitter(ms)
+}
+
+// Adds randomness +/-15% of value
+function jitter(value: number) {
+  const delta = value * 0.15
+  return value + randomRange(-delta, delta)
+}
+
+function randomRange(from: number, to: number) {
+  const rand = Math.random() * (to - from)
+  return rand + from
+}

package/src/times.ts

@@ -6,3 +6,10 @@ export const DAY = HOUR * 24
 export const lessThanAgoMs = (time: Date, range: number) => {
   return Date.now() < time.getTime() + range
 }
+
+export const addHoursToDate = (hours: number, startingDate?: Date): Date => {
+  // When date is passed, clone before calling `setHours()` so that we are not mutating the original date
+  const currentDate = startingDate ? new Date(startingDate) : new Date()
+  currentDate.setHours(currentDate.getHours() + hours)
+  return currentDate
+}

package/src/util.ts

@@ -1,12 +1,12 @@
 export const noUndefinedVals = <T>(
-  obj: Record<string, T>,
+  obj: Record<string, T | undefined>,
 ): Record<string, T> => {
   Object.keys(obj).forEach((k) => {
     if (obj[k] === undefined) {
       delete obj[k]
     }
   })
-  return obj
+  return obj as Record<string, T>
 }
 
 export const jitter = (maxMs: number) => {

package/tests/retry.test.ts

@@ -0,0 +1,93 @@
+import { retry } from '../src/index'
+
+describe('retry', () => {
+  describe('retry()', () => {
+    it('retries until max retries', async () => {
+      let fnCalls = 0
+      let waitMsCalls = 0
+      const fn = async () => {
+        fnCalls++
+        throw new Error(`Oops ${fnCalls}!`)
+      }
+      const getWaitMs = (retries) => {
+        waitMsCalls++
+        expect(retries).toEqual(waitMsCalls - 1)
+        return 0
+      }
+      await expect(retry(fn, { maxRetries: 13, getWaitMs })).rejects.toThrow(
+        'Oops 14!',
+      )
+      expect(fnCalls).toEqual(14)
+      expect(waitMsCalls).toEqual(14)
+    })
+
+    it('retries until max wait', async () => {
+      let fnCalls = 0
+      let waitMsCalls = 0
+      const fn = async () => {
+        fnCalls++
+        throw new Error(`Oops ${fnCalls}!`)
+      }
+      const getWaitMs = (retries) => {
+        waitMsCalls++
+        expect(retries).toEqual(waitMsCalls - 1)
+        if (retries === 13) {
+          return null
+        }
+        return 0
+      }
+      await expect(
+        retry(fn, { maxRetries: Infinity, getWaitMs }),
+      ).rejects.toThrow('Oops 14!')
+      expect(fnCalls).toEqual(14)
+      expect(waitMsCalls).toEqual(14)
+    })
+
+    it('retries until non-retryable error', async () => {
+      let fnCalls = 0
+      let waitMsCalls = 0
+      const fn = async () => {
+        fnCalls++
+        throw new Error(`Oops ${fnCalls}!`)
+      }
+      const getWaitMs = (retries) => {
+        waitMsCalls++
+        expect(retries).toEqual(waitMsCalls - 1)
+        return 0
+      }
+      const retryable = (err: unknown) => err?.['message'] !== 'Oops 14!'
+      await expect(
+        retry(fn, { maxRetries: Infinity, getWaitMs, retryable }),
+      ).rejects.toThrow('Oops 14!')
+      expect(fnCalls).toEqual(14)
+      expect(waitMsCalls).toEqual(14)
+    })
+
+    it('returns latest result after retries', async () => {
+      let fnCalls = 0
+      const fn = async () => {
+        fnCalls++
+        if (fnCalls < 14) {
+          throw new Error(`Oops ${fnCalls}!`)
+        }
+        return 'ok'
+      }
+      const getWaitMs = () => 0
+      const result = await retry(fn, { maxRetries: Infinity, getWaitMs })
+      expect(result).toBe('ok')
+      expect(fnCalls).toBe(14)
+    })
+
+    it('returns result immediately on success', async () => {
+      let fnCalls = 0
+      const fn = async () => {
+        fnCalls++
+        return 'ok'
+      }
+      const getWaitMs = () => 0
+      const result = await retry(fn, { maxRetries: Infinity, getWaitMs })
+      expect(result).toBe('ok')
+      expect(fnCalls).toBe(1)
+    })
+  })
+})