@atproto/lex-data 0.0.7 → 0.0.8

package/src/cid-implementation.test.ts

@@ -0,0 +1,137 @@
+/* eslint-disable import/no-deprecated */
+
+import { base32 } from 'multiformats/bases/base32'
+import { CID } from 'multiformats/cid'
+import { create as createDigest } from 'multiformats/hashes/digest'
+import { assert, describe, expect, it } from 'vitest'
+import { Cid } from './cid.js'
+import { ui8Equals } from './uint8array.js'
+
+export class BytesCid implements Cid {
+  constructor(readonly bytes: Uint8Array) {
+    if (this.bytes.length < 4) {
+      throw new Error('CID bytes are too short')
+    }
+    if (this.bytes[0] > 1) {
+      throw new Error('Unsupported CID version')
+    }
+    if (this.bytes.length !== 4 + this.bytes[3]) {
+      throw new Error('CID bytes length mismatch')
+    }
+  }
+
+  get version() {
+    return this.bytes[0] as 0 | 1
+  }
+
+  get code() {
+    return this.bytes[1]
+  }
+
+  get multihash() {
+    const code = this.bytes[2]
+    const digest = this.bytes.subarray(4)
+    return { code, digest }
+  }
+
+  equals(other: Cid): boolean {
+    return ui8Equals(this.bytes, other.bytes)
+  }
+
+  toString(): string {
+    return base32.encode(this.bytes)
+  }
+}
+
+describe(BytesCid, () => {
+  it('creates a BytesCid from valid bytes', () => {
+    const bytes = new Uint8Array([1, 0x55, 0x12, 3, 1, 2, 3])
+    const cid = new BytesCid(bytes)
+
+    assert(cid.version === 1)
+    assert(cid.code === 0x55)
+    assert(cid.multihash.code === 0x12)
+    assert(ui8Equals(cid.multihash.digest, new Uint8Array([1, 2, 3])))
+    assert(ui8Equals(cid.bytes, bytes))
+    assert(typeof cid.toString === 'function')
+    assert(typeof cid.equals === 'function')
+  })
+
+  it('throws an error for invalid CID bytes', () => {
+    expect(
+      () => new BytesCid(new Uint8Array([2, 0x55, 0x12, 3, 1, 2, 3])),
+    ).toThrowError('Unsupported CID version')
+    expect(() => new BytesCid(new Uint8Array([1, 0x55, 0x12]))).toThrowError(
+      'CID bytes are too short',
+    )
+    expect(
+      () => new BytesCid(new Uint8Array([1, 0x55, 0x12, 4, 1, 2, 3])),
+    ).toThrowError('CID bytes length mismatch')
+  })
+})
+
+/**
+ * A minimal custom implementation of the `Cid` interface for testing purposes.
+ */
+export function createCustomCid<
+  TVersion extends 0 | 1,
+  TCode extends number,
+  TMultihashCode extends number,
+>(
+  version: TVersion,
+  code: TCode,
+  multihashCode: TMultihashCode,
+  digest: Uint8Array,
+): Cid<TVersion, TCode, TMultihashCode> {
+  return {
+    version,
+    code,
+    multihash: { code: multihashCode, digest },
+    bytes: new Uint8Array([
+      version,
+      code,
+      multihashCode,
+      digest.length,
+      ...digest,
+    ]),
+    toString,
+    equals,
+  }
+}
+
+function equals(this: Cid, other: Cid): boolean {
+  return (
+    this.version === other.version &&
+    this.code === other.code &&
+    this.multihash.code === other.multihash.code &&
+    ui8Equals(this.multihash.digest, other.multihash.digest)
+  )
+}
+
+function toString(this: Cid): string {
+  return CID.create(
+    this.version,
+    this.code,
+    createDigest(this.multihash.code, this.multihash.digest),
+  ).toString()
+}
+
+describe(createCustomCid, () => {
+  it('creates a CID with the specified properties', () => {
+    const digest = new Uint8Array([1, 2, 3, 4, 5])
+    const customCid = createCustomCid(1, 0x55, 0x12, digest)
+
+    assert(customCid.version === 1)
+    assert(customCid.code === 0x55)
+    assert(customCid.multihash.code === 0x12)
+    assert(ui8Equals(customCid.multihash.digest, digest))
+    assert(
+      ui8Equals(
+        customCid.bytes,
+        new Uint8Array([1, 0x55, 0x12, 5, 1, 2, 3, 4, 5]),
+      ),
+    )
+    assert(typeof customCid.toString === 'function')
+    assert(typeof customCid.equals === 'function')
+  })
+})

package/src/cid.test.ts

@@ -1,23 +1,50 @@
+/* eslint-disable import/no-deprecated */
+
 import { CID } from 'multiformats/cid'
 import { sha256, sha512 } from 'multiformats/hashes/sha2'
 import { describe, expect, it } from 'vitest'
+import { BytesCid, createCustomCid } from './cid-implementation.test.js'
 import {
+  Cid,
   DAG_CBOR_MULTICODEC,
   RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  asMultiformatsCID,
+  cidForRawHash,
   decodeCid,
   ensureValidCidString,
   isCid,
   parseCid,
-  parseCidString,
+  parseCidSafe,
 } from './cid.js'
+import { ui8Equals } from './uint8array.js'
+
+const invalidCidStr = 'invalidcidstring'
+
+const cborCidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
+const cborCid = parseCid(cborCidStr, { flavor: 'cbor' })
+
+const rawCidStr = 'bafkreifjjcie6lypi6ny7amxnfftagclbuxndqonfipmb64f2km2devei4'
+const rawCid = parseCid(rawCidStr, { flavor: 'raw' })
+
+const rawCidCustom: Cid = createCustomCid(
+  1,
+  RAW_MULTICODEC,
+  SHA256_MULTIHASH,
+  rawCid.multihash.digest,
+)
+const rawCidCustomBytes = new BytesCid(rawCid.bytes)
 
 describe(isCid, () => {
   describe('non-strict mode', () => {
     it('returns true for parsed CIDs', () => {
-      const cid = parseCid(
-        'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
-      )
-      expect(isCid(cid)).toBe(true)
+      expect(isCid(cborCid)).toBe(true)
+      expect(isCid(rawCid)).toBe(true)
+    })
+
+    it('returns true for custom compatible CID implementations', () => {
+      expect(isCid(rawCidCustom)).toBe(true)
+      expect(isCid(rawCidCustomBytes)).toBe(true)
     })
 
     it('returns true for CID v0 and v1', async () => {
@@ -88,56 +115,131 @@ describe(isCid, () => {
       })
     })
   })
+
+  describe('alternative cid implementations', () => {
+    it('accepts compatible CID implementations', () => {
+      expect(isCid(rawCidCustom)).toBe(true)
+    })
+
+    it('rejects non-matching version', () => {
+      expect(isCid({ ...rawCidCustom, version: 0 })).toBe(false)
+    })
+
+    it('rejects non-matching code', () => {
+      expect(isCid({ ...rawCidCustom, code: 0 })).toBe(false)
+    })
+
+    it('rejects non-matching multihash code', () => {
+      expect(
+        isCid({
+          ...rawCidCustom,
+          multihash: { ...rawCidCustom.multihash, code: 0 },
+        }),
+      ).toBe(false)
+    })
+
+    it('rejects non-matching multihash digest', () => {
+      const differentDigest = new Uint8Array(32)
+      differentDigest[0] = 1
+      expect(
+        isCid({
+          ...rawCidCustom,
+          multihash: { ...rawCidCustom.multihash, digest: differentDigest },
+        }),
+      ).toBe(false)
+    })
+
+    it('rejects objects without equals method', () => {
+      expect(isCid({ ...rawCidCustom, equals: undefined })).toBe(false)
+    })
+
+    it('rejects object with throwing equals method', () => {
+      expect(
+        isCid({
+          ...rawCidCustom,
+          equals: () => {
+            throw new Error('fail')
+          },
+        }),
+      ).toBe(false)
+    })
+  })
 })
 
 describe(decodeCid, () => {
   it('decodes CID from bytes', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
+    const cid = parseCid(cborCidStr)
     const bytes = cid.bytes
     const decodedCid = decodeCid(bytes)
-    expect(decodedCid.toString()).toBe(cidStr)
+    expect(decodedCid.toString()).toBe(cborCidStr)
   })
 })
 
 describe(parseCid, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCid(cidStr)
-    expect(cid.toString()).toBe(cidStr)
+    expect(parseCid(cborCidStr).toString()).toBe(cborCidStr)
+    expect(parseCid(rawCidStr).toString()).toBe(rawCidStr)
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     expect(() => parseCid(invalidCidStr)).toThrow()
   })
 })
 
-describe(parseCidString, () => {
+describe(parseCidSafe, () => {
   it('parses valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    const cid = parseCidString(cidStr)
-    expect(cid).toBeDefined()
-    expect(cid!.toString()).toBe(cidStr)
+    expect(parseCidSafe(cborCidStr)?.toString()).toBe(cborCidStr)
+    expect(parseCidSafe(rawCidStr)?.toString()).toBe(rawCidStr)
   })
 
   it('returns undefined for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
-    const cid = parseCidString(invalidCidStr)
-    expect(cid).toBeUndefined()
+    expect(parseCidSafe(invalidCidStr)).toBeNull()
   })
 })
 
 describe(ensureValidCidString, () => {
   it('does not throw for valid CIDs', () => {
-    const cidStr = 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a'
-    expect(() => ensureValidCidString(cidStr)).not.toThrow()
+    expect(() => ensureValidCidString(cborCidStr)).not.toThrow()
   })
 
   it('throws for invalid CIDs', () => {
-    const invalidCidStr = 'invalidcidstring'
     expect(() => ensureValidCidString(invalidCidStr)).toThrow(
       'Invalid CID string',
     )
   })
 })
+
+describe(cidForRawHash, () => {
+  it('creates a RawCid from a SHA-256 hash', () => {
+    const hash = new Uint8Array(32)
+    const cid = cidForRawHash(hash)
+    expect(cid.code).toBe(RAW_MULTICODEC)
+    expect(cid.multihash.code).toBe(SHA256_MULTIHASH)
+    expect(ui8Equals(cid.multihash.digest, hash)).toBe(true)
+  })
+
+  it('rejects hashes on invalid lengths', () => {
+    expect(() => cidForRawHash(new Uint8Array(31))).toThrow(
+      'Invalid SHA-256 hash length',
+    )
+    expect(() => cidForRawHash(new Uint8Array(33))).toThrow(
+      'Invalid SHA-256 hash length',
+    )
+  })
+})
+
+describe(asMultiformatsCID, () => {
+  it('converts compatible CID to multiformats CID', () => {
+    for (const cid of [cborCid, rawCid, rawCidCustom, rawCidCustomBytes]) {
+      expect(asMultiformatsCID(cid)).toBeInstanceOf(CID)
+      expect(asMultiformatsCID(cid)).toMatchObject({
+        version: cid.version,
+        code: cid.code,
+        multihash: {
+          code: cid.multihash.code,
+          digest: cid.multihash.digest,
+        },
+      })
+    }
+  })
+})