@atproto/common 0.0.1 → 0.1.0

package/dist/ipld.d.ts

@@ -0,0 +1,10 @@
+import { CID } from 'multiformats/cid';
+import * as Block from 'multiformats/block';
+import * as cborCodec from '@ipld/dag-cbor';
+export declare const dataToCborBlock: (data: unknown) => Promise<Block.Block<unknown>>;
+export declare const verifyCidForBytes: (cid: CID, bytes: Uint8Array) => Promise<void>;
+export declare const sha256RawToCid: (hash: Uint8Array) => CID;
+export declare const cidForCbor: (data: unknown) => Promise<CID>;
+export declare const cborEncode: typeof cborCodec.encode;
+export declare const cborDecode: typeof cborCodec.decode;
+export declare const cborBytesToRecord: (bytes: Uint8Array) => Record<string, unknown>;

package/dist/src/check.d.ts

@@ -0,0 +1,9 @@
+export interface Def<T> {
+    parse: (obj: unknown) => T;
+    safeParse: (obj: unknown) => {
+        success: boolean;
+    };
+}
+export declare const is: <T>(obj: unknown, def: Def<T>) => obj is T;
+export declare const assure: <T>(def: Def<T>, obj: unknown) => T;
+export declare const isObject: (obj: unknown) => obj is Record<string, unknown>;

package/dist/src/cid.d.ts

@@ -0,0 +1,2 @@
+import { CID } from 'multiformats/cid';
+export declare const cidForData: (data: unknown) => Promise<CID>;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * as check from './check';
+export * as util from './util';
+export * from './util';
+export * from './tid';
+export * from './blocks';
+export * from './logger';
+export * from './types';
+export * from './streams';

package/dist/src/ipld.d.ts

@@ -0,0 +1,10 @@
+import { CID } from 'multiformats/cid';
+import * as Block from 'multiformats/block';
+import * as cborCodec from '@ipld/dag-cbor';
+export declare const dataToCborBlock: (data: unknown) => Promise<Block.Block<unknown>>;
+export declare const verifyCidForBytes: (cid: CID, bytes: Uint8Array) => Promise<void>;
+export declare const sha256RawToCid: (hash: Uint8Array) => CID;
+export declare const cidForCbor: (data: unknown) => Promise<CID>;
+export declare const cborEncode: typeof cborCodec.encode;
+export declare const cborDecode: typeof cborCodec.decode;
+export declare const cborBytesToRecord: (bytes: Uint8Array) => Record<string, unknown>;

package/dist/src/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const subsystemLogger: (name: string) => pino.Logger;

package/dist/src/network/names.d.ts

@@ -0,0 +1,6 @@
+export declare class NameResolveError extends Error {
+    responseStatus: number;
+    responseBody: any;
+    constructor(username: string, responseStatus: number, responseBody: any);
+}
+export declare function resolveName(name: string): Promise<string>;

package/dist/src/network/uri.d.ts

@@ -0,0 +1,20 @@
+export declare const ADX_URI_REGEX: RegExp;
+export declare class AdxUri {
+    hash: string;
+    host: string;
+    pathname: string;
+    searchParams: URLSearchParams;
+    constructor(uri: string, base?: string);
+    get protocol(): string;
+    get origin(): string;
+    get hostname(): string;
+    set hostname(v: string);
+    get search(): string;
+    set search(v: string);
+    get collection(): string;
+    set collection(v: string);
+    get recordKey(): string;
+    set recordKey(v: string);
+    get href(): string;
+    toString(): string;
+}

package/dist/src/network/util.d.ts

@@ -0,0 +1,9 @@
+import { AxiosError } from 'axios';
+export declare const assureAxiosError: (err: unknown) => AxiosError;
+export declare const parseAxiosError: (e: unknown) => {
+    code: number;
+    msg: string;
+    err: AxiosError;
+};
+export declare const didNetworkUrl: () => string;
+export declare const cleanHostUrl: (url: string) => string;

package/dist/src/streams.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream, Readable, Transform, TransformCallback } from 'stream';
+export declare const forwardStreamErrors: (...streams: Stream[]) => void;
+export declare const cloneStream: (stream: Readable) => Readable;
+export declare const streamSize: (stream: Readable) => Promise<number>;
+export declare const bytesToStream: (bytes: Uint8Array) => Readable;
+export declare class MaxSizeChecker extends Transform {
+    maxSize: number;
+    createError: () => Error;
+    totalSize: number;
+    constructor(maxSize: number, createError: () => Error);
+    _transform(chunk: Uint8Array, _enc: BufferEncoding, cb: TransformCallback): void | this;
+}

package/dist/src/tid.d.ts

@@ -0,0 +1,20 @@
+export declare class TID {
+    str: string;
+    constructor(str: string);
+    static next(): TID;
+    static nextStr(): string;
+    static fromTime(timestamp: number, clockid: number): TID;
+    static fromStr(str: string): TID;
+    static newestFirst(a: TID, b: TID): number;
+    static oldestFirst(a: TID, b: TID): number;
+    static is(str: string): boolean;
+    timestamp(): number;
+    clockid(): number;
+    formatted(): string;
+    toString(): string;
+    compareTo(other: TID): number;
+    equals(other: TID): boolean;
+    newerThan(other: TID): boolean;
+    olderThan(other: TID): boolean;
+}
+export default TID;

package/dist/src/types.d.ts

@@ -0,0 +1,14 @@
+import * as mf from 'multiformats/cid';
+import { z } from 'zod';
+export declare const isCid: (str: string) => boolean;
+declare const bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+export declare type Bytes = z.infer<typeof bytes>;
+export declare const def: {
+    string: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, mf.CID, any>;
+    strToCid: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mf.CID, string>;
+    bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    strToInt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;
+    strToBool: z.ZodEffects<z.ZodString, boolean, string>;
+};
+export {};

package/dist/src/util.d.ts

@@ -0,0 +1,9 @@
+export declare const noUndefinedVals: <T>(obj: Record<string, T>) => Record<string, T>;
+export declare const wait: (ms: number) => Promise<unknown>;
+export declare const flattenUint8Arrays: (arrs: Uint8Array[]) => Uint8Array;
+export declare const streamToArray: (stream: AsyncIterable<Uint8Array>) => Promise<Uint8Array>;
+export declare const s32encode: (i: number) => string;
+export declare const s32decode: (s: string) => number;
+export declare const asyncFilter: <T>(arr: T[], fn: (t: T) => Promise<boolean>) => Promise<T[]>;
+export declare const isErrnoException: (err: unknown) => err is NodeJS.ErrnoException;
+export declare const errHasMsg: (err: unknown, msg: string) => boolean;

package/dist/times.d.ts

@@ -0,0 +1,4 @@
+export declare const SECOND = 1000;
+export declare const MINUTE: number;
+export declare const HOUR: number;
+export declare const DAY: number;

package/dist/types.d.ts

@@ -1,14 +1,18 @@
 import * as mf from 'multiformats/cid';
 import { z } from 'zod';
-export declare const isCid: (str: string) => boolean;
-declare const bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
-export declare type Bytes = z.infer<typeof bytes>;
-export declare const def: {
-    string: z.ZodString;
+import { Def } from './check';
+export declare const schema: {
     cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, mf.CID, any>;
-    strToCid: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, mf.CID, string>;
     bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
-    strToInt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;
-    strToBool: z.ZodEffects<z.ZodString, boolean, string>;
+    string: z.ZodString;
+    record: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    unknown: z.ZodUnknown;
+};
+export declare const def: {
+    cid: Def<mf.CID>;
+    bytes: Def<Uint8Array>;
+    string: Def<string>;
+    record: Def<Record<string, unknown>>;
+    unknown: Def<unknown>;
 };
-export {};
+export declare type ArrayEl<A> = A extends readonly (infer T)[] ? T : never;

package/dist/util.d.ts

@@ -1,6 +1,9 @@
-/// <reference types="node" />
 export declare const noUndefinedVals: <T>(obj: Record<string, T>) => Record<string, T>;
 export declare const wait: (ms: number) => Promise<unknown>;
+export declare const bailableWait: (ms: number) => {
+    bail: () => void;
+    wait: () => Promise<void>;
+};
 export declare const flattenUint8Arrays: (arrs: Uint8Array[]) => Uint8Array;
 export declare const streamToArray: (stream: AsyncIterable<Uint8Array>) => Promise<Uint8Array>;
 export declare const s32encode: (i: number) => string;
@@ -8,3 +11,5 @@ export declare const s32decode: (s: string) => number;
 export declare const asyncFilter: <T>(arr: T[], fn: (t: T) => Promise<boolean>) => Promise<T[]>;
 export declare const isErrnoException: (err: unknown) => err is NodeJS.ErrnoException;
 export declare const errHasMsg: (err: unknown, msg: string) => boolean;
+export declare const chunkArray: <T>(arr: T[], chunkSize: number) => T[][];
+export declare const range: (num: number) => number[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atproto/common",
-  "version": "0.0.1",
-  "main": "dist/index.js",
+  "version": "0.1.0",
+  "main": "src/index.ts",
   "license": "MIT",
   "scripts": {
     "test": "jest",

package/src/async.ts

@@ -0,0 +1,100 @@
+import { bailableWait } from './util'
+
+// reads values from a generator into a list
+// NOTE: does not signal generator to close. it *will* continue to produce values
+export const readFromGenerator = async <T>(
+  gen: AsyncGenerator<T>,
+  maxLength = Number.MAX_SAFE_INTEGER,
+  timeout = 2000,
+): Promise<T[]> => {
+  const evts: T[] = []
+  while (evts.length < maxLength) {
+    const { bail, wait } = bailableWait(timeout)
+    const maybeEvt = await Promise.race([gen.next(), wait()])
+    bail()
+    if (!maybeEvt) break
+    const evt = maybeEvt as IteratorResult<T>
+    if (evt.done) break
+    evts.push(evt.value)
+  }
+  return evts
+}
+
+export type Deferrable = {
+  resolve: () => void
+  complete: Promise<void>
+}
+
+export const createDeferrable = (): Deferrable => {
+  let resolve
+  const promise: Promise<void> = new Promise((res) => {
+    resolve = () => res()
+  })
+  return { resolve, complete: promise }
+}
+
+export const createDeferrables = (count: number): Deferrable[] => {
+  const list: Deferrable[] = []
+  for (let i = 0; i < count; i++) {
+    list.push(createDeferrable())
+  }
+  return list
+}
+
+export const allComplete = async (deferrables: Deferrable[]): Promise<void> => {
+  await Promise.all(deferrables.map((d) => d.complete))
+}
+
+export class AsyncBuffer<T> {
+  private buffer: T[] = []
+  private promise: Promise<void>
+  private resolve: () => void
+
+  constructor(public maxSize?: number) {
+    this.resetPromise()
+  }
+
+  get curr(): T[] {
+    return this.buffer
+  }
+
+  get size(): number {
+    return this.buffer.length
+  }
+
+  resetPromise() {
+    this.promise = new Promise<void>((r) => (this.resolve = r))
+  }
+
+  push(item: T) {
+    this.buffer.push(item)
+    this.resolve()
+  }
+
+  pushMany(items: T[]) {
+    items.forEach((i) => this.buffer.push(i))
+    this.resolve()
+  }
+
+  async *events(): AsyncGenerator<T> {
+    while (true) {
+      await this.promise
+      if (this.maxSize && this.size > this.maxSize) {
+        throw new AsyncBufferFullError(this.maxSize)
+      }
+      const [first, ...rest] = this.buffer
+      if (first) {
+        this.buffer = rest
+        yield first
+      } else {
+        this.resetPromise()
+      }
+    }
+  }
+}
+
+export class AsyncBufferFullError extends Error {
+  constructor(maxSize: number) {
+    super(`ReachedMaxBufferSize: ${maxSize}`)
+  }
+}

package/src/check.ts

@@ -1,13 +1,22 @@
-export interface Def<T> {
+import { ZodError } from 'zod'
+
+export interface Checkable<T> {
   parse: (obj: unknown) => T
-  safeParse: (obj: unknown) => { success: boolean }
+  safeParse: (
+    obj: unknown,
+  ) => { success: true; data: T } | { success: false; error: ZodError }
+}
+
+export interface Def<T> {
+  name: string
+  schema: Checkable<T>
 }
 
-export const is = <T>(obj: unknown, def: Def<T>): obj is T => {
+export const is = <T>(obj: unknown, def: Checkable<T>): obj is T => {
   return def.safeParse(obj).success
 }
 
-export const assure = <T>(def: Def<T>, obj: unknown): T => {
+export const assure = <T>(def: Checkable<T>, obj: unknown): T => {
   return def.parse(obj)
 }
 

package/src/index.ts

@@ -1,9 +1,11 @@
 export * as check from './check'
 export * as util from './util'
 
+export * from './async'
 export * from './util'
 export * from './tid'
-export * from './blocks'
+export * from './ipld'
 export * from './logger'
 export * from './types'
 export * from './streams'
+export * from './times'

package/src/ipld.ts

@@ -0,0 +1,48 @@
+import { CID } from 'multiformats/cid'
+import * as Block from 'multiformats/block'
+import * as rawCodec from 'multiformats/codecs/raw'
+import { sha256 } from 'multiformats/hashes/sha2'
+import * as mf from 'multiformats'
+import * as cborCodec from '@ipld/dag-cbor'
+import { check, schema } from '.'
+
+export const dataToCborBlock = async (data: unknown) => {
+  return Block.encode({
+    value: data,
+    codec: cborCodec,
+    hasher: sha256,
+  })
+}
+
+export const verifyCidForBytes = async (cid: CID, bytes: Uint8Array) => {
+  const digest = await sha256.digest(bytes)
+  const expected = CID.createV1(cid.code, digest)
+  if (!cid.equals(expected)) {
+    throw new Error(
+      `Not a valid CID for bytes. Expected: ${expected.toString()} Got: ${cid.toString()}`,
+    )
+  }
+}
+
+export const sha256RawToCid = (hash: Uint8Array): CID => {
+  const digest = mf.digest.create(sha256.code, hash)
+  return CID.createV1(rawCodec.code, digest)
+}
+
+export const cidForCbor = async (data: unknown): Promise<CID> => {
+  const block = await dataToCborBlock(data)
+  return block.cid
+}
+
+export const cborEncode = cborCodec.encode
+export const cborDecode = cborCodec.decode
+
+export const cborBytesToRecord = (
+  bytes: Uint8Array,
+): Record<string, unknown> => {
+  const val = cborDecode(bytes)
+  if (!check.is(val, schema.record)) {
+    throw new Error(`Expected object, got: ${val}`)
+  }
+  return val
+}

package/src/times.ts

@@ -0,0 +1,4 @@
+export const SECOND = 1000
+export const MINUTE = SECOND * 60
+export const HOUR = MINUTE * 60
+export const DAY = HOUR * 24

package/src/types.ts

@@ -1,44 +1,43 @@
 import * as mf from 'multiformats/cid'
 import { z } from 'zod'
+import { Def } from './check'
 
-const cid = z
+const cidSchema = z
   .any()
   .refine((obj: unknown) => mf.CID.asCID(obj) !== null, {
     message: 'Not a CID',
   })
   .transform((obj: unknown) => mf.CID.asCID(obj) as mf.CID)
 
-export const isCid = (str: string): boolean => {
-  try {
-    mf.CID.parse(str)
-    return true
-  } catch (err) {
-    return false
-  }
+export const schema = {
+  cid: cidSchema,
+  bytes: z.instanceof(Uint8Array),
+  string: z.string(),
+  record: z.record(z.string(), z.unknown()),
+  unknown: z.unknown(),
 }
 
-const strToCid = z
-  .string()
-  .refine(isCid, { message: 'Not a valid CID' })
-  .transform((str: string) => mf.CID.parse(str))
-
-const bytes = z.instanceof(Uint8Array)
-export type Bytes = z.infer<typeof bytes>
-
-const strToInt = z
-  .string()
-  .refine((str) => !isNaN(parseInt(str)), {
-    message: 'Cannot parse string to integer',
-  })
-  .transform((str) => parseInt(str))
-
-const strToBool = z.string().transform((str) => str === 'true' || str === 't')
-
 export const def = {
-  string: z.string(),
-  cid,
-  strToCid,
-  bytes,
-  strToInt,
-  strToBool,
+  cid: {
+    name: 'cid',
+    schema: schema.cid,
+  } as Def<mf.CID>,
+  bytes: {
+    name: 'bytes',
+    schema: schema.bytes,
+  } as Def<Uint8Array>,
+  string: {
+    name: 'string',
+    schema: schema.string,
+  } as Def<string>,
+  record: {
+    name: 'record',
+    schema: schema.record,
+  } as Def<Record<string, unknown>>,
+  unknown: {
+    name: 'unknown',
+    schema: schema.unknown,
+  } as Def<unknown>,
 }
+
+export type ArrayEl<A> = A extends readonly (infer T)[] ? T : never

package/src/util.ts

@@ -13,6 +13,20 @@ export const wait = (ms: number) => {
   return new Promise((res) => setTimeout(res, ms))
 }
 
+export const bailableWait = (
+  ms: number,
+): { bail: () => void; wait: () => Promise<void> } => {
+  let bail
+  const waitPromise = new Promise<void>((res) => {
+    const timeout = setTimeout(res, ms)
+    bail = () => {
+      clearTimeout(timeout)
+      res()
+    }
+  })
+  return { bail, wait: () => waitPromise }
+}
+
 export const flattenUint8Arrays = (arrs: Uint8Array[]): Uint8Array => {
   const length = arrs.reduce((acc, cur) => {
     return acc + cur.length
@@ -67,9 +81,28 @@ export const asyncFilter = async <T>(
 export const isErrnoException = (
   err: unknown,
 ): err is NodeJS.ErrnoException => {
-  return !!err && 'code' in err
+  return !!err && err['code']
 }
 
 export const errHasMsg = (err: unknown, msg: string): boolean => {
   return !!err && typeof err === 'object' && err['message'] === msg
 }
+
+export const chunkArray = <T>(arr: T[], chunkSize: number): T[][] => {
+  return arr.reduce((acc, cur, i) => {
+    const chunkI = Math.floor(i / chunkSize)
+    if (!acc[chunkI]) {
+      acc[chunkI] = []
+    }
+    acc[chunkI].push(cur)
+    return acc
+  }, [] as T[][])
+}
+
+export const range = (num: number): number[] => {
+  const nums: number[] = []
+  for (let i = 0; i < num; i++) {
+    nums.push(i)
+  }
+  return nums
+}

package/tests/async.test.ts

@@ -0,0 +1,22 @@
+import { readFromGenerator, wait } from '../src'
+
+describe('async', () => {
+  describe('readFromGenerator', () => {
+    async function* waitToYield(time: number) {
+      for (let i = 0; i < 5; i++) {
+        await wait(time)
+        yield true
+      }
+    }
+
+    it('reads from generator with timeout', async () => {
+      const read = await readFromGenerator(waitToYield(100), undefined, 105)
+      expect(read).toEqual([true, true, true, true, true])
+    })
+
+    it('stops reading at timeout', async () => {
+      const read = await readFromGenerator(waitToYield(100), undefined, 95)
+      expect(read).toEqual([])
+    })
+  })
+})

package/src/blocks.ts

@@ -1,40 +0,0 @@
-import { CID } from 'multiformats/cid'
-import * as Block from 'multiformats/block'
-import * as rawCodec from 'multiformats/codecs/raw'
-import { sha256 as blockHasher } from 'multiformats/hashes/sha2'
-import * as mf from 'multiformats'
-import * as blockCodec from '@ipld/dag-cbor'
-
-export const valueToIpldBlock = async (data: unknown) => {
-  return Block.encode({
-    value: data,
-    codec: blockCodec,
-    hasher: blockHasher,
-  })
-}
-
-export const sha256RawToCid = (hash: Uint8Array): CID => {
-  const digest = mf.digest.create(blockHasher.code, hash)
-  return CID.createV1(rawCodec.code, digest)
-}
-
-export const cidForData = async (data: unknown): Promise<CID> => {
-  const block = await valueToIpldBlock(data)
-  return block.cid
-}
-
-export const valueToIpldBytes = (value: unknown): Uint8Array => {
-  return blockCodec.encode(value)
-}
-
-export const ipldBytesToValue = (bytes: Uint8Array) => {
-  return blockCodec.decode(bytes)
-}
-
-export const ipldBytesToRecord = (bytes: Uint8Array): object => {
-  const val = ipldBytesToValue(bytes)
-  if (typeof val !== 'object' || val === null) {
-    throw new Error(`Expected object, got: ${val}`)
-  }
-  return val
-}