@atproto/did 0.5.2 → 0.5.3

package/src/did.ts

@@ -1,265 +0,0 @@
-import { z } from 'zod'
-import { DidError, InvalidDidError } from './did-error.js'
-
-const DID_PREFIX = 'did:'
-const DID_PREFIX_LENGTH = DID_PREFIX.length
-export { DID_PREFIX }
-
-/**
- * Type representation of a Did, with method.
- *
- * ```bnf
- * did                = "did:" method-name ":" method-specific-id
- * method-name        = 1*method-char
- * method-char        = %x61-7A / DIGIT
- * method-specific-id = *( *idchar ":" ) 1*idchar
- * idchar             = ALPHA / DIGIT / "." / "-" / "_" / pct-encoded
- * pct-encoded        = "%" HEXDIG HEXDIG
- * ```
- *
- * @example
- * ```ts
- * type DidWeb = Did<'web'> // `did:web:${string}`
- * type DidCustom = Did<'web' | 'plc'> // `did:${'web' | 'plc'}:${string}`
- * type DidNever = Did<' invalid 🥴 '> // never
- * type DidFoo = Did<'foo' | ' invalid 🥴 '> // `did:foo:${string}`
- * ```
- *
- * @see {@link https://www.w3.org/TR/did-core/#did-syntax}
- */
-export type Did<M extends string = string> = `did:${AsDidMethod<M>}:${string}`
-
-/**
- * DID Method
- */
-export type AsDidMethod<M> = string extends M
-  ? string // can't know...
-  : AsDidMethodInternal<M, ''>
-
-type AlphanumericChar = DigitChar | LowerAlphaChar
-type DigitChar = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
-type LowerAlphaChar =
-  | 'a'
-  | 'b'
-  | 'c'
-  | 'd'
-  | 'e'
-  | 'f'
-  | 'g'
-  | 'h'
-  | 'i'
-  | 'j'
-  | 'k'
-  | 'l'
-  | 'm'
-  | 'n'
-  | 'o'
-  | 'p'
-  | 'q'
-  | 'r'
-  | 's'
-  | 't'
-  | 'u'
-  | 'v'
-  | 'w'
-  | 'x'
-  | 'y'
-  | 'z'
-
-type AsDidMethodInternal<
-  S,
-  Acc extends string,
-> = S extends `${infer H}${infer T}`
-  ? H extends AlphanumericChar
-    ? AsDidMethodInternal<T, `${Acc}${H}`>
-    : never
-  : Acc extends ''
-    ? never
-    : Acc
-
-/**
- * DID Method-name check function.
- *
- * Check if the input is a valid DID method name, at the position between
- * `start` (inclusive) and `end` (exclusive).
- */
-export function assertDidMethod(
-  input: string,
-  start = 0,
-  end = input.length,
-): void {
-  if (
-    !Number.isFinite(end) ||
-    !Number.isFinite(start) ||
-    end < start ||
-    end > input.length
-  ) {
-    throw new TypeError('Invalid start or end position')
-  }
-  if (end === start) {
-    throw new InvalidDidError(input, `Empty method name`)
-  }
-
-  let c: number
-  for (let i = start; i < end; i++) {
-    c = input.charCodeAt(i)
-    if (
-      (c < 0x61 || c > 0x7a) && // a-z
-      (c < 0x30 || c > 0x39) // 0-9
-    ) {
-      throw new InvalidDidError(
-        input,
-        `Invalid character at position ${i} in DID method name`,
-      )
-    }
-  }
-}
-
-/**
- * This method assumes the input is a valid Did
- */
-export function extractDidMethod<D extends Did>(did: D) {
-  const msidSep = did.indexOf(':', DID_PREFIX_LENGTH)
-  const method = did.slice(DID_PREFIX_LENGTH, msidSep)
-  return method as D extends Did<infer M> ? M : string
-}
-
-/**
- * DID Method-specific identifier check function.
- *
- * Check if the input is a valid DID method-specific identifier, at the position
- * between `start` (inclusive) and `end` (exclusive).
- */
-export function assertDidMsid(
-  input: string,
-  start = 0,
-  end = input.length,
-): void {
-  if (
-    !Number.isFinite(end) ||
-    !Number.isFinite(start) ||
-    end < start ||
-    end > input.length
-  ) {
-    throw new TypeError('Invalid start or end position')
-  }
-  if (end === start) {
-    throw new InvalidDidError(input, `DID method-specific id must not be empty`)
-  }
-
-  let c: number
-  for (let i = start; i < end; i++) {
-    c = input.charCodeAt(i)
-
-    // Check for frequent chars first
-    if (
-      (c < 0x61 || c > 0x7a) && // a-z
-      (c < 0x41 || c > 0x5a) && // A-Z
-      (c < 0x30 || c > 0x39) && // 0-9
-      c !== 0x2e && // .
-      c !== 0x2d && // -
-      c !== 0x5f // _
-    ) {
-      // Less frequent chars are checked here
-
-      // ":"
-      if (c === 0x3a) {
-        if (i === end - 1) {
-          throw new InvalidDidError(input, `DID cannot end with ":"`)
-        }
-        continue
-      }
-
-      // pct-encoded
-      if (c === 0x25) {
-        c = input.charCodeAt(++i)
-        if ((c < 0x30 || c > 0x39) && (c < 0x41 || c > 0x46)) {
-          throw new InvalidDidError(
-            input,
-            `Invalid pct-encoded character at position ${i}`,
-          )
-        }
-
-        c = input.charCodeAt(++i)
-        if ((c < 0x30 || c > 0x39) && (c < 0x41 || c > 0x46)) {
-          throw new InvalidDidError(
-            input,
-            `Invalid pct-encoded character at position ${i}`,
-          )
-        }
-
-        // There must always be 2 HEXDIG after a "%"
-        if (i >= end) {
-          throw new InvalidDidError(
-            input,
-            `Incomplete pct-encoded character at position ${i - 2}`,
-          )
-        }
-
-        continue
-      }
-
-      throw new InvalidDidError(
-        input,
-        `Disallowed character in DID at position ${i}`,
-      )
-    }
-  }
-}
-
-export function assertDid(input: unknown): asserts input is Did {
-  if (typeof input !== 'string') {
-    throw new InvalidDidError(typeof input, `DID must be a string`)
-  }
-
-  const { length } = input
-  if (length > 2048) {
-    throw new InvalidDidError(input, `DID is too long (2048 chars max)`)
-  }
-
-  if (!input.startsWith(DID_PREFIX)) {
-    throw new InvalidDidError(input, `DID requires "${DID_PREFIX}" prefix`)
-  }
-
-  const idSep = input.indexOf(':', DID_PREFIX_LENGTH)
-  if (idSep === -1) {
-    throw new InvalidDidError(input, `Missing colon after method name`)
-  }
-
-  assertDidMethod(input, DID_PREFIX_LENGTH, idSep)
-  assertDidMsid(input, idSep + 1, length)
-}
-
-export function isDid(input: unknown): input is Did {
-  try {
-    assertDid(input)
-    return true
-  } catch (err) {
-    if (err instanceof DidError) {
-      return false
-    }
-
-    // Unexpected TypeError (should never happen)
-    throw err
-  }
-}
-
-export function asDid<T>(input: T) {
-  assertDid(input)
-  return input
-}
-
-export const didSchema = z
-  .string()
-  .superRefine((value: string, ctx: z.RefinementCtx): value is Did => {
-    try {
-      assertDid(value)
-      return true
-    } catch (err) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: err instanceof Error ? err.message : 'Unexpected error',
-      })
-      return false
-    }
-  })

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from './atproto.js'
-export * from './did-document.js'
-export * from './did-error.js'
-export * from './did-ref.js'
-export * from './did.js'
-export * from './methods.js'
-export * from './utils.js'

package/src/lib/uri.ts

@@ -1,78 +0,0 @@
-/**
- * @see {@link https://www.w3.org/TR/did-1.0/#dfn-did-fragments}
- * @see {@link https://datatracker.ietf.org/doc/html/rfc3986#section-3.5}
- */
-export function isFragment(
-  value: string,
-  startIdx = 0,
-  endIdx = value.length,
-): boolean {
-  let charCode: number
-  for (let i = startIdx; i < endIdx; i++) {
-    charCode = value.charCodeAt(i)
-
-    // fragment    = *( pchar / "/" / "?" )
-    // pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
-    // unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
-    // pct-encoded = "%" HEXDIG HEXDIG
-    // sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-    if (
-      (charCode >= 65 /* A */ && charCode <= 90) /* Z */ ||
-      (charCode >= 97 /* a */ && charCode <= 122) /* z */ ||
-      (charCode >= 48 /* 0 */ && charCode <= 57) /* 9 */ ||
-      charCode === 45 /* "-" */ ||
-      charCode === 46 /* "." */ ||
-      charCode === 95 /* "_" */ ||
-      charCode === 126 /* "~" */
-    ) {
-      // unreserved
-    } else if (
-      charCode === 33 /* "!" */ ||
-      charCode === 36 /* "$" */ ||
-      charCode === 38 /* "&" */ ||
-      charCode === 39 /* "'" */ ||
-      charCode === 40 /* "(" */ ||
-      charCode === 41 /* ")" */ ||
-      charCode === 42 /* "*" */ ||
-      charCode === 43 /* "+" */ ||
-      charCode === 44 /* "," */ ||
-      charCode === 59 /* ";" */ ||
-      charCode === 61 /* "=" */
-    ) {
-      // sub-delims
-    } else if (charCode === 58 /* ":" */ || charCode === 64 /* "@" */) {
-      // pchar extra
-    } else if (charCode === 47 /* "/" */ || charCode === 63 /* "?" */) {
-      // fragment extra
-    } else if (charCode === 37 /* "%" */) {
-      // pct-enc
-      if (i + 2 >= endIdx) return false
-      if (!isHexDigit(value.charCodeAt(i + 1))) return false
-      if (!isHexDigit(value.charCodeAt(i + 2))) return false
-      i += 2
-    } else {
-      return false
-    }
-  }
-
-  return true
-}
-
-export function isHexDigit(code: number): boolean {
-  return (
-    (code >= 48 && code <= 57) || // 0-9
-    (code >= 65 && code <= 70) || // A-F
-    (code >= 97 && code <= 102) // a-f
-  )
-}
-
-export const canParse =
-  URL.canParse?.bind(URL) ??
-  ((url, base) => {
-    try {
-      new URL(url, base)
-      return true
-    } catch {
-      return false
-    }
-  })

package/src/methods/plc.ts

@@ -1,54 +0,0 @@
-import { InvalidDidError } from '../did-error.js'
-import { Did } from '../did.js'
-
-const DID_PLC_PREFIX = `did:plc:`
-const DID_PLC_PREFIX_LENGTH = DID_PLC_PREFIX.length
-const DID_PLC_LENGTH = 32
-
-export { DID_PLC_PREFIX }
-
-export function isDidPlc(input: unknown): input is Did<'plc'> {
-  // Optimization: equivalent to try/catch around "assertDidPlc"
-  if (typeof input !== 'string') return false
-  if (input.length !== DID_PLC_LENGTH) return false
-  if (!input.startsWith(DID_PLC_PREFIX)) return false
-  for (let i = DID_PLC_PREFIX_LENGTH; i < DID_PLC_LENGTH; i++) {
-    if (!isBase32Char(input.charCodeAt(i))) return false
-  }
-  return true
-}
-
-export function asDidPlc<T>(input: T) {
-  assertDidPlc(input)
-  return input
-}
-
-export function assertDidPlc(input: unknown): asserts input is Did<'plc'> {
-  if (typeof input !== 'string') {
-    throw new InvalidDidError(typeof input, `DID must be a string`)
-  }
-
-  if (!input.startsWith(DID_PLC_PREFIX)) {
-    throw new InvalidDidError(input, `Invalid did:plc prefix`)
-  }
-
-  if (input.length !== DID_PLC_LENGTH) {
-    throw new InvalidDidError(
-      input,
-      `did:plc must be ${DID_PLC_LENGTH} characters long`,
-    )
-  }
-
-  // The following check is not necessary, as the check below is more strict:
-
-  // assertDidMsid(input, DID_PLC_PREFIX.length)
-
-  for (let i = DID_PLC_PREFIX_LENGTH; i < DID_PLC_LENGTH; i++) {
-    if (!isBase32Char(input.charCodeAt(i))) {
-      throw new InvalidDidError(input, `Invalid character at position ${i}`)
-    }
-  }
-}
-
-const isBase32Char = (c: number): boolean =>
-  (c >= 0x61 && c <= 0x7a) || (c >= 0x32 && c <= 0x37) // [a-z2-7]

package/src/methods/web.ts

@@ -1,83 +0,0 @@
-import { InvalidDidError } from '../did-error.js'
-import { Did, assertDidMsid } from '../did.js'
-import { canParse } from '../lib/uri.js'
-
-export const DID_WEB_PREFIX = `did:web:` satisfies Did<'web'>
-
-/**
- * This function checks if the input is a valid Web DID, as per DID spec.
- */
-export function isDidWeb(input: unknown): input is Did<'web'> {
-  // Optimization: make cheap checks first
-  if (typeof input !== 'string') return false
-  if (!input.startsWith(DID_WEB_PREFIX)) return false
-  if (input.charAt(DID_WEB_PREFIX.length) === ':') return false
-
-  try {
-    assertDidMsid(input, DID_WEB_PREFIX.length)
-  } catch {
-    return false
-  }
-
-  return canParse(buildDidWebUrl(input as Did<'web'>))
-}
-
-export function asDidWeb<T>(input: T) {
-  assertDidWeb(input)
-  return input
-}
-
-export function assertDidWeb(input: unknown): asserts input is Did<'web'> {
-  if (typeof input !== 'string') {
-    throw new InvalidDidError(typeof input, `DID must be a string`)
-  }
-
-  if (!input.startsWith(DID_WEB_PREFIX)) {
-    throw new InvalidDidError(input, `Invalid did:web prefix`)
-  }
-
-  if (input.charAt(DID_WEB_PREFIX.length) === ':') {
-    throw new InvalidDidError(input, 'did:web MSID must not start with a colon')
-  }
-
-  // Make sure every char is valid (per DID spec)
-  assertDidMsid(input, DID_WEB_PREFIX.length)
-
-  if (!canParse(buildDidWebUrl(input as Did<'web'>))) {
-    throw new InvalidDidError(input, 'Invalid Web DID')
-  }
-}
-
-export function didWebToUrl(did: Did<'web'>) {
-  try {
-    return new URL(buildDidWebUrl(did)) as URL & {
-      protocol: 'http:' | 'https:'
-    }
-  } catch (cause) {
-    throw new InvalidDidError(did, 'Invalid Web DID', cause)
-  }
-}
-
-export function urlToDidWeb(url: URL): Did<'web'> {
-  const port = url.port ? `%3A${url.port}` : ''
-  const path = url.pathname === '/' ? '' : url.pathname.replaceAll('/', ':')
-
-  return `did:web:${url.hostname}${port}${path}`
-}
-
-export function buildDidWebUrl(did: Did<'web'>): string {
-  const hostIdx = DID_WEB_PREFIX.length
-  const pathIdx = did.indexOf(':', hostIdx)
-
-  const hostEnc =
-    pathIdx === -1 ? did.slice(hostIdx) : did.slice(hostIdx, pathIdx)
-  const host = hostEnc.replaceAll('%3A', ':')
-  const path = pathIdx === -1 ? '' : did.slice(pathIdx).replaceAll(':', '/')
-  const proto =
-    host.startsWith('localhost') &&
-    (host.length === 9 || host.charCodeAt(9) === 58) /* ':' */
-      ? 'http'
-      : 'https'
-
-  return `${proto}://${host}${path}`
-}

package/src/methods.ts

@@ -1,2 +0,0 @@
-export * from './methods/plc.js'
-export * from './methods/web.js'

package/src/utils.ts

@@ -1,18 +0,0 @@
-export type Identifier<D extends string, I extends string> =
-  | `#${I}`
-  | `${D}#${I}`
-export function matchesIdentifier<D extends string, I extends string>(
-  did: D,
-  id: I,
-  candidate: string,
-): candidate is Identifier<D, I> {
-  // optimized implementation of:
-  // return candidate === `#${id}` || candidate === `${did}#${id}`
-
-  return candidate.charCodeAt(0) === 35 // '#'
-    ? candidate.length === id.length + 1 && candidate.endsWith(id)
-    : candidate.length === id.length + 1 + did.length &&
-        candidate.charCodeAt(did.length) === 35 && // '#'
-        candidate.startsWith(did) &&
-        candidate.endsWith(id)
-}

package/tests/did-ref.test.ts

@@ -1,69 +0,0 @@
-import { isAtprotoDidRefAbsolute } from '../src/atproto.js'
-import { isDidRefRelative } from '../src/did-ref.js'
-
-describe('isAtprotoDidRefAbsolute', () => {
-  it('accepts well-formed absolute references', () => {
-    expect(
-      isAtprotoDidRefAbsolute('did:plc:l3rouwludahu3ui3bt66mfvj#atproto'),
-    ).toBe(true)
-    expect(isAtprotoDidRefAbsolute('did:web:example.com#service_id')).toBe(true)
-    expect(isAtprotoDidRefAbsolute('did:web:example.com#atproto_label')).toBe(
-      true,
-    )
-  })
-
-  it('rejects bare DIDs', () => {
-    expect(isAtprotoDidRefAbsolute('did:plc:l3rouwludahu3ui3bt66mfvj')).toBe(
-      false,
-    )
-    expect(isAtprotoDidRefAbsolute('did:web:example.com')).toBe(false)
-  })
-
-  it('rejects relative references', () => {
-    expect(isAtprotoDidRefAbsolute('#atproto')).toBe(false)
-  })
-
-  it('rejects malformed input', () => {
-    expect(isAtprotoDidRefAbsolute('')).toBe(false)
-    expect(isAtprotoDidRefAbsolute('did:plc:l3rouwludahu3ui3bt66mfvj#')).toBe(
-      false,
-    )
-    expect(
-      isAtprotoDidRefAbsolute('did:plc:l3rouwludahu3ui3bt66mfvj##foo'),
-    ).toBe(false)
-    expect(
-      isAtprotoDidRefAbsolute('did:plc:l3rouwludahu3ui3bt66mfvj#a#b'),
-    ).toBe(false)
-    expect(isAtprotoDidRefAbsolute('did:foo:bar#baz')).toBe(false)
-    expect(isAtprotoDidRefAbsolute(null)).toBe(false)
-    expect(isAtprotoDidRefAbsolute(123)).toBe(false)
-  })
-})
-
-describe('isDidRefRelative', () => {
-  it('accepts well-formed relative references', () => {
-    expect(isDidRefRelative('#atproto')).toBe(true)
-    expect(isDidRefRelative('#atproto_label')).toBe(true)
-    expect(isDidRefRelative('#a')).toBe(true)
-  })
-
-  it('narrows on a specific id when supplied', () => {
-    expect(isDidRefRelative('#atproto', 'atproto')).toBe(true)
-    expect(isDidRefRelative('#atproto_label', 'atproto')).toBe(false)
-  })
-
-  it('rejects absolute references and bare strings', () => {
-    expect(isDidRefRelative('did:plc:l3rouwludahu3ui3bt66mfvj#atproto')).toBe(
-      false,
-    )
-    expect(isDidRefRelative('atproto')).toBe(false)
-  })
-
-  it('rejects malformed input', () => {
-    expect(isDidRefRelative('')).toBe(false)
-    expect(isDidRefRelative('#')).toBe(false)
-    expect(isDidRefRelative('#a#b')).toBe(false)
-    expect(isDidRefRelative(null)).toBe(false)
-    expect(isDidRefRelative(123)).toBe(false)
-  })
-})

package/tests/methods/plc.test.ts

@@ -1,72 +0,0 @@
-import { InvalidDidError } from '../../src/did-error.js'
-import { Did } from '../../src/did.js'
-import { asDidPlc, assertDidPlc, isDidPlc } from '../../src/methods/plc.js'
-
-const VALID: Did<'plc'>[] = [
-  'did:plc:l3rouwludahu3ui3bt66mfvj',
-  'did:plc:aaaaaaaaaaaaaaaaaaaaaaaa',
-  'did:plc:zzzzzzzzzzzzzzzzzzzzzzzz',
-]
-
-const INVALID: [value: unknown, message: string][] = [
-  ['did:plc:l3rouwludahu3ui3bt66mfv0', 'Invalid character at position 31'],
-  ['did:plc:l3rouwludahu3ui3bt66mfv1', 'Invalid character at position 31'],
-  ['did:plc:l3rouwludahu3ui3bt66mfv9', 'Invalid character at position 31'],
-  ['did:plc:l3rouwludahu3ui3bt66mfv', 'did:plc must be 32 characters long'],
-  ['did:plc:l3rouwludahu3ui3bt66mfvja', 'did:plc must be 32 characters long'],
-  ['did:plc:example.com:', 'did:plc must be 32 characters long'],
-  ['did:plc:exam%3Aple.com%3A8080', 'did:plc must be 32 characters long'],
-  [3, 'DID must be a string'],
-  [{ toString: () => 'did:plc:foo.com' }, 'DID must be a string'],
-  [[''], 'DID must be a string'],
-  ['random-string', 'Invalid did:plc prefix'],
-  ['did plc', 'Invalid did:plc prefix'],
-  ['lorem ipsum dolor sit', 'Invalid did:plc prefix'],
-]
-
-describe('isDidPlc', () => {
-  it('returns true for various valid dids', () => {
-    for (const did of VALID) {
-      expect(isDidPlc(did)).toBe(true)
-    }
-  })
-
-  it('returns false for invalid dids', () => {
-    for (const [did] of INVALID) {
-      expect(isDidPlc(did)).toBe(false)
-    }
-  })
-})
-
-describe('assertDidPlc', () => {
-  it('does not throw on valid dids', () => {
-    for (const did of VALID) {
-      expect(() => assertDidPlc(did)).not.toThrow()
-    }
-  })
-
-  it('throws if called with non string argument', () => {
-    for (const [val, message] of INVALID) {
-      expect(() => assertDidPlc(val)).toThrow(
-        new InvalidDidError(
-          typeof val === 'string' ? val : typeof val,
-          message,
-        ),
-      )
-    }
-  })
-})
-
-describe('asDidPlc', () => {
-  it('returns the input for valid dids', () => {
-    for (const did of VALID) {
-      expect(asDidPlc(did)).toBe(did)
-    }
-  })
-
-  it('throws if called with invalid dids', () => {
-    for (const [val] of INVALID) {
-      expect(() => asDidPlc(val)).toThrow(InvalidDidError)
-    }
-  })
-})