@atproto/syntax 0.6.3 → 0.6.4

package/tests/datetime.test.ts

@@ -1,280 +0,0 @@
-import * as fs from 'node:fs'
-import { describe, expect, it, test } from 'vitest'
-import {
-  InvalidDatetimeError,
-  ensureValidDatetime,
-  isDatetimeString,
-  isDatetimeStringLenient,
-  normalizeDatetime,
-  normalizeDatetimeAlways,
-} from '../src/index.js'
-
-const interopValid = readLines(
-  `${__dirname}/interop-files/datetime_syntax_valid.txt`,
-)
-const interopInvalidSyntax = readLines(
-  `${__dirname}/interop-files/datetime_syntax_invalid.txt`,
-)
-const interopInvalidParse = readLines(
-  `${__dirname}/interop-files/datetime_parse_invalid.txt`,
-)
-
-// These strings come from the test suite in "@atproto/lexicon", kept around
-// to ensure compatibility with legacy implementation.
-const legacyValid = [
-  '2022-12-12T00:50:36.809Z',
-  '2022-12-12T00:50:36Z',
-  '2022-12-12T00:50:36.8Z',
-  '2022-12-12T00:50:36.80Z',
-  '2022-12-12T00:50:36+00:00',
-  '2022-12-12T00:50:36.8+00:00',
-  '2022-12-11T19:50:36-05:00',
-  '2022-12-11T19:50:36.8-05:00',
-  '2022-12-11T19:50:36.80-05:00',
-  '2022-12-11T19:50:36.809-05:00',
-]
-
-describe(ensureValidDatetime, () => {
-  describe('Interop valid', () => {
-    test.each(interopValid)('%s', (dt) => {
-      expect(() => ensureValidDatetime(dt)).not.toThrow()
-    })
-  })
-
-  describe('Interop invalid syntax', () => {
-    test.each(interopInvalidSyntax)('%s', (dt) => {
-      expect(() => ensureValidDatetime(dt)).toThrow(InvalidDatetimeError)
-    })
-  })
-
-  describe('Interop invalid parse', () => {
-    test.each(interopInvalidParse)('%s', (dt) => {
-      expect(() => ensureValidDatetime(dt)).toThrow(InvalidDatetimeError)
-    })
-  })
-
-  it('rejects datetime that normalizes past year 9999 due to negative offset', () => {
-    // 9999-12-31T23:59:00-00:01 is syntactically valid, but normalizing to
-    // UTC advances it to 10000-01-01T00:00:00Z, which is out of range
-    expect(() => ensureValidDatetime('9999-12-31T23:59:00-00:01')).toThrow(
-      InvalidDatetimeError,
-    )
-  })
-})
-
-describe(isDatetimeString, () => {
-  describe('Interop valid', () => {
-    test.each(interopValid)('%s', (dt) => {
-      expect(isDatetimeString(dt)).toBe(true)
-    })
-  })
-
-  describe('Interop invalid syntax', () => {
-    test.each(interopInvalidSyntax)('%s', (dt) => {
-      expect(isDatetimeString(dt)).toBe(false)
-    })
-  })
-
-  describe('Interop invalid parse', () => {
-    test.each(interopInvalidParse)('%s', (dt) => {
-      expect(isDatetimeString(dt)).toBe(false)
-    })
-  })
-
-  describe('succeeds on legacy valid', () => {
-    test.each(legacyValid)('%s', (dt) => {
-      expect(isDatetimeString(dt)).toBe(true)
-    })
-  })
-
-  it('rejects datetime that normalizes past year 9999 due to negative offset', () => {
-    // 9999-12-31T23:59:00-00:01 is syntactically valid, but normalizing to
-    // UTC advances it to 10000-01-01T00:00:00Z, which is out of range
-    expect(isDatetimeString('9999-12-31T23:59:00-00:01')).toBe(false)
-  })
-})
-
-describe(isDatetimeStringLenient, () => {
-  describe('Interop valid', () => {
-    test.each(interopValid)('%s', (dt) => {
-      expect(isDatetimeStringLenient(dt)).toBe(true)
-    })
-  })
-
-  // Because of it leniency, the "isDatetimeStringLenient" implementation does
-  // not fail on some of the invalid syntax cases, so these tests are skipped.
-  describe.skip('Interop invalid syntax', () => {
-    test.each(interopInvalidSyntax)('%s', (dt) => {
-      expect(isDatetimeStringLenient(dt)).toBe(false)
-    })
-  })
-
-  describe('Interop invalid parse', () => {
-    test.each(interopInvalidParse)('%s', (dt) => {
-      expect(isDatetimeStringLenient(dt)).toBe(false)
-    })
-  })
-
-  describe('Legacy valid', () => {
-    test.each(legacyValid)('%s', (dt) => {
-      expect(isDatetimeStringLenient(dt)).toBe(true)
-    })
-  })
-})
-
-describe(normalizeDatetime, () => {
-  describe('Interop valid', () => {
-    test.each(interopValid)('%s', (dt) => {
-      expect(() => normalizeDatetime(dt)).not.toThrow()
-    })
-  })
-
-  // @NOTE Normalize will actually succeed on some of the invalid syntax cases,
-  // because it is more lenient than the regex validation.
-  describe.skip('Interop invalid syntax', () => {
-    test.each(interopInvalidSyntax)('%s', (dt) => {
-      expect(() => normalizeDatetime(dt)).toThrow(InvalidDatetimeError)
-    })
-  })
-
-  describe('Interop invalid parse', () => {
-    test.each(interopInvalidParse)('%s', (dt) => {
-      expect(() => normalizeDatetime(dt)).toThrow(InvalidDatetimeError)
-    })
-  })
-
-  it('normalizes valid input', () => {
-    expect(normalizeDatetime('1234-04-12T23:20:50Z')).toEqual(
-      '1234-04-12T23:20:50.000Z',
-    )
-    expect(normalizeDatetime('1985-04-12T23:20:50Z')).toEqual(
-      '1985-04-12T23:20:50.000Z',
-    )
-    expect(normalizeDatetime('1985-04-12T23:20:50.123')).toEqual(
-      '1985-04-12T23:20:50.123Z',
-    )
-    expect(normalizeDatetime('1985-04-12 23:20:50.123')).toEqual(
-      '1985-04-12T23:20:50.123Z',
-    )
-    expect(normalizeDatetime('1985-04-12T10:20:50.1+01:00')).toEqual(
-      '1985-04-12T09:20:50.100Z',
-    )
-    expect(normalizeDatetime('Fri, 02 Jan 1999 12:34:56+1212')).toEqual(
-      '1999-01-02T00:22:56.000Z',
-    )
-    expect(normalizeDatetime('Fri, 02 Jan 1999 12:34:56Z')).toEqual(
-      '1999-01-02T12:34:56.000Z',
-    )
-    expect(normalizeDatetime('Fri, 02 Jan 1999 12:34:56 GMT')).toEqual(
-      '1999-01-02T12:34:56.000Z',
-    )
-    expect(normalizeDatetime('Fri, 02 Jan 1999 12:34:56 PST')).toEqual(
-      '1999-01-02T20:34:56.000Z',
-    )
-    expect(normalizeDatetime('Fri, 02 Jan 1999 12:34:56 EST')).toEqual(
-      '1999-01-02T17:34:56.000Z',
-    )
-    // @NOTE "(Central European Standard Time)" is not used by "Date" to infer
-    // the right timezone offset, so these will be parsed as UTC
-    expect(
-      normalizeDatetime(
-        'Fri, 02 Jan 1999 12:34:56 (Central European Standard Time)',
-      ),
-    ).toEqual('1999-01-02T12:34:56.000Z')
-    expect(normalizeDatetime('0001-01-01T00:00:00+01:00')).toEqual(
-      '0000-12-31T23:00:00.000Z',
-    )
-  })
-
-  it('accepts years 1-9', () => {
-    expect(normalizeDatetime('0009-12-31T23:59:59Z')).toEqual(
-      '0009-12-31T23:59:59.000Z',
-    )
-    expect(normalizeDatetime('0005-06-15T12:00:00Z')).toEqual(
-      '0005-06-15T12:00:00.000Z',
-    )
-    expect(normalizeDatetime('0001-01-01T00:00:00Z')).toEqual(
-      '0001-01-01T00:00:00.000Z',
-    )
-    expect(normalizeDatetime('0002-03-04T05:06:07.890Z')).toEqual(
-      '0002-03-04T05:06:07.890Z',
-    )
-  })
-
-  it('accepts single-digit years with leading zeros', () => {
-    expect(normalizeDatetime('0007-01-01T00:00:00Z')).toEqual(
-      '0007-01-01T00:00:00.000Z',
-    )
-  })
-
-  it('accepts year 1 with timezone offsets', () => {
-    // Year 1 with negative offset stays in valid range
-    expect(normalizeDatetime('0001-12-31T23:00:00-01:00')).toEqual(
-      '0002-01-01T00:00:00.000Z',
-    )
-  })
-
-  it('throws on invalid input', () => {
-    expect(() => normalizeDatetime('')).toThrow(InvalidDatetimeError)
-    expect(() => normalizeDatetime('blah')).toThrow(InvalidDatetimeError)
-    expect(() => normalizeDatetime('1999-19-39T23:20:50.123Z')).toThrow(
-      InvalidDatetimeError,
-    )
-    expect(() => normalizeDatetime('Fri, 02 Jan 1999 12:34:56 AFT')).toThrow(
-      InvalidDatetimeError,
-    )
-    expect(() => normalizeDatetime('-000001-12-31T23:00:00.000Z')).toThrow(
-      InvalidDatetimeError,
-    )
-    expect(() => normalizeDatetime('0000-01-01T00:00:00+01:00')).toThrow(
-      InvalidDatetimeError,
-    )
-    // 9999-12-31T23:59:00-00:01 is syntactically valid, but normalizing to
-    // UTC advances it to 10000-01-01T00:00:00Z, which is out of range
-    expect(() => normalizeDatetime('9999-12-31T23:59:00-00:01')).toThrow(
-      InvalidDatetimeError,
-    )
-  })
-})
-
-describe(normalizeDatetimeAlways, () => {
-  it('normalizes valid input', () => {
-    expect(normalizeDatetimeAlways('1985-04-12T23:20:50Z')).toEqual(
-      '1985-04-12T23:20:50.000Z',
-    )
-  })
-
-  it('normalizes invalid input', () => {
-    expect(normalizeDatetimeAlways('blah')).toEqual('1970-01-01T00:00:00.000Z')
-    expect(normalizeDatetimeAlways('0000-01-01T00:00:00+01:00')).toEqual(
-      '1970-01-01T00:00:00.000Z',
-    )
-  })
-
-  describe('Interop valid', () => {
-    test.each(interopValid)('%s', (dt) => {
-      // @NOTE we can't test the returned value as some will normalize while others won't.
-      expect(() => normalizeDatetimeAlways(dt)).not.toThrow()
-    })
-  })
-
-  describe('Interop invalid syntax', () => {
-    test.each(interopInvalidSyntax)('%s', (dt) => {
-      // @NOTE we can't test the returned value as some will normalize while others won't.
-      expect(() => normalizeDatetimeAlways(dt)).not.toThrow()
-    })
-  })
-
-  describe('Interop invalid parse', () => {
-    test.each(interopInvalidParse)('%s', (dt) => {
-      expect(normalizeDatetimeAlways(dt)).toEqual('1970-01-01T00:00:00.000Z')
-    })
-  })
-})
-
-function readLines(filePath: string): string[] {
-  return fs
-    .readFileSync(filePath, 'utf-8')
-    .split(/\r?\n/)
-    .filter((line) => !line.startsWith('#') && line.length > 0)
-}

package/tests/did.test.ts

@@ -1,104 +0,0 @@
-import * as fs from 'node:fs'
-import * as readline from 'node:readline'
-import { describe, expect, it } from 'vitest'
-import {
-  InvalidDidError,
-  ensureValidDid,
-  ensureValidDidRegex,
-} from '../src/index.js'
-
-describe('DID permissive validation', () => {
-  const expectValid = (h: string) => {
-    ensureValidDid(h)
-    ensureValidDidRegex(h)
-  }
-  const expectInvalid = (h: string) => {
-    expect(() => ensureValidDid(h)).toThrow(InvalidDidError)
-    expect(() => ensureValidDidRegex(h)).toThrow(InvalidDidError)
-  }
-
-  it('enforces spec details', () => {
-    expectValid('did:method:val')
-    expectValid('did:method:VAL')
-    expectValid('did:method:val123')
-    expectValid('did:method:123')
-    expectValid('did:method:val-two')
-    expectValid('did:method:val_two')
-    expectValid('did:method:val.two')
-    expectValid('did:method:val:two')
-    expectValid('did:method:val%BB')
-
-    expectInvalid('did')
-    expectInvalid('didmethodval')
-    expectInvalid('method:did:val')
-    expectInvalid('did:method:')
-    expectInvalid('didmethod:val')
-    expectInvalid('did:methodval')
-    expectInvalid(':did:method:val')
-    expectInvalid('did.method.val')
-    expectInvalid('did:method:val:')
-    expectInvalid('did:method:val%')
-    expectInvalid('DID:method:val')
-    expectInvalid('did:METHOD:val')
-    expectInvalid('did:m123:val')
-
-    expectValid('did:method:' + 'v'.repeat(240))
-    expectInvalid('did:method:' + 'v'.repeat(8500))
-
-    expectValid('did:m:v')
-    expectValid('did:method::::val')
-    expectValid('did:method:-')
-    expectValid('did:method:-:_:.:%ab')
-    expectValid('did:method:.')
-    expectValid('did:method:_')
-    expectValid('did:method::.')
-
-    expectInvalid('did:method:val/two')
-    expectInvalid('did:method:val?two')
-    expectInvalid('did:method:val#two')
-    expectInvalid('did:method:val%')
-
-    expectValid(
-      'did:onion:2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid',
-    )
-  })
-
-  it('allows some real DID values', () => {
-    expectValid('did:example:123456789abcdefghi')
-    expectValid('did:plc:7iza6de2dwap2sbkpav7c6c6')
-    expectValid('did:web:example.com')
-    expectValid('did:web:localhost%3A1234')
-    expectValid('did:key:zQ3shZc2QzApp2oymGvQbzP8eKheVshBHbU4ZYjeXqwSKEn6N')
-    expectValid('did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a')
-  })
-
-  it('conforms to interop valid DIDs', () => {
-    const lineReader = readline.createInterface({
-      input: fs.createReadStream(
-        `${__dirname}/interop-files/did_syntax_valid.txt`,
-      ),
-      terminal: false,
-    })
-    lineReader.on('line', (line) => {
-      if (line.startsWith('#') || line.length === 0) {
-        return
-      }
-      expectValid(line)
-    })
-  })
-
-  it('conforms to interop invalid DIDs', () => {
-    const lineReader = readline.createInterface({
-      input: fs.createReadStream(
-        `${__dirname}/interop-files/did_syntax_invalid.txt`,
-      ),
-      terminal: false,
-    })
-    lineReader.on('line', (line) => {
-      if (line.startsWith('#') || line.length === 0) {
-        return
-      }
-      expectInvalid(line)
-    })
-  })
-})

package/tests/handle.test.ts

@@ -1,239 +0,0 @@
-import * as fs from 'node:fs'
-import * as readline from 'node:readline'
-import { describe, expect, it } from 'vitest'
-import {
-  InvalidHandleError,
-  ensureValidHandle,
-  ensureValidHandleRegex,
-  normalizeAndEnsureValidHandle,
-} from '../src/index.js'
-
-describe('handle validation', () => {
-  const expectValid = (h: string) => {
-    ensureValidHandle(h)
-    ensureValidHandleRegex(h)
-  }
-  const expectInvalid = (h: string) => {
-    expect(() => ensureValidHandle(h)).toThrow(InvalidHandleError)
-    expect(() => ensureValidHandleRegex(h)).toThrow(InvalidHandleError)
-  }
-
-  it('allows valid handles', () => {
-    expectValid('A.ISI.EDU')
-    expectValid('XX.LCS.MIT.EDU')
-    expectValid('SRI-NIC.ARPA')
-    expectValid('john.test')
-    expectValid('jan.test')
-    expectValid('a234567890123456789.test')
-    expectValid('john2.test')
-    expectValid('john-john.test')
-    expectValid('john.bsky.app')
-    expectValid('jo.hn')
-    expectValid('a.co')
-    expectValid('a.org')
-    expectValid('joh.n')
-    expectValid('j0.h0')
-    const longHandle =
-      'shoooort' + '.loooooooooooooooooooooooooong'.repeat(8) + '.test'
-    expect(longHandle.length).toEqual(253)
-    expectValid(longHandle)
-    expectValid('short.' + 'o'.repeat(63) + '.test')
-    expectValid('jaymome-johnber123456.test')
-    expectValid('jay.mome-johnber123456.test')
-    expectValid('john.test.bsky.app')
-
-    // NOTE: this probably isn't ever going to be a real domain, but my read of
-    // the RFC is that it would be possible
-    expectValid('john.t')
-  })
-
-  // NOTE: we may change this at the proto level; currently only disallowed at
-  // the registration level
-  it('allows .local and .arpa handles (proto-level)', () => {
-    expectValid('laptop.local')
-    expectValid('laptop.arpa')
-  })
-
-  it('allows punycode handles', () => {
-    expectValid('xn--ls8h.test') // 💩.test
-    expectValid('xn--bcher-kva.tld') // bücher.tld
-    expectValid('xn--3jk.com')
-    expectValid('xn--w3d.com')
-    expectValid('xn--vqb.com')
-    expectValid('xn--ppd.com')
-    expectValid('xn--cs9a.com')
-    expectValid('xn--8r9a.com')
-    expectValid('xn--cfd.com')
-    expectValid('xn--5jk.com')
-    expectValid('xn--2lb.com')
-  })
-
-  it('allows onion (Tor) handles', () => {
-    expectValid('expyuzz4wqqyqhjn.onion')
-    expectValid('friend.expyuzz4wqqyqhjn.onion')
-    expectValid(
-      'g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion',
-    )
-    expectValid(
-      'friend.g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion',
-    )
-    expectValid(
-      'friend.g2zyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion',
-    )
-    expectValid(
-      '2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion',
-    )
-    expectValid(
-      'friend.2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion',
-    )
-  })
-
-  it('throws on invalid handles', () => {
-    expectInvalid('did:thing.test')
-    expectInvalid('did:thing')
-    expectInvalid('john-.test')
-    expectInvalid('john.0')
-    expectInvalid('john.-')
-    expectInvalid('short.' + 'o'.repeat(64) + '.test')
-    expectInvalid('short' + '.loooooooooooooooooooooooong'.repeat(10) + '.test')
-    const longHandle =
-      'shooooort' + '.loooooooooooooooooooooooooong'.repeat(8) + '.test'
-    expect(longHandle.length).toEqual(254)
-    expectInvalid(longHandle)
-    expectInvalid('xn--bcher-.tld')
-    expectInvalid('john..test')
-    expectInvalid('jo_hn.test')
-    expectInvalid('-john.test')
-    expectInvalid('.john.test')
-    expectInvalid('jo!hn.test')
-    expectInvalid('jo%hn.test')
-    expectInvalid('jo&hn.test')
-    expectInvalid('jo@hn.test')
-    expectInvalid('jo*hn.test')
-    expectInvalid('jo|hn.test')
-    expectInvalid('jo:hn.test')
-    expectInvalid('jo/hn.test')
-    expectInvalid('john💩.test')
-    expectInvalid('bücher.test')
-    expectInvalid('john .test')
-    expectInvalid('john.test.')
-    expectInvalid('john')
-    expectInvalid('john.')
-    expectInvalid('.john')
-    expectInvalid('john.test.')
-    expectInvalid('.john.test')
-    expectInvalid(' john.test')
-    expectInvalid('john.test ')
-    expectInvalid('joh-.test')
-    expectInvalid('john.-est')
-    expectInvalid('john.tes-')
-  })
-
-  it('throws on "dotless" TLD handles', () => {
-    expectInvalid('org')
-    expectInvalid('ai')
-    expectInvalid('gg')
-    expectInvalid('io')
-  })
-
-  it('correctly validates corner cases (modern vs. old RFCs)', () => {
-    expectValid('12345.test')
-    expectValid('8.cn')
-    expectValid('4chan.org')
-    expectValid('4chan.o-g')
-    expectValid('blah.4chan.org')
-    expectValid('thing.a01')
-    expectValid('120.0.0.1.com')
-    expectValid('0john.test')
-    expectValid('9sta--ck.com')
-    expectValid('99stack.com')
-    expectValid('0ohn.test')
-    expectValid('john.t--t')
-    expectValid('thing.0aa.thing')
-
-    expectInvalid('cn.8')
-    expectInvalid('thing.0aa')
-    expectInvalid('thing.0aa')
-  })
-
-  it('does not allow IP addresses as handles', () => {
-    expectInvalid('127.0.0.1')
-    expectInvalid('192.168.0.142')
-    expectInvalid('fe80::7325:8a97:c100:94b')
-    expectInvalid('2600:3c03::f03c:9100:feb0:af1f')
-  })
-
-  it('is consistent with examples from stackoverflow', () => {
-    const okStackoverflow = [
-      'stack.com',
-      'sta-ck.com',
-      'sta---ck.com',
-      'sta--ck9.com',
-      'stack99.com',
-      'sta99ck.com',
-      'google.com.uk',
-      'google.co.in',
-      'google.com',
-      'maselkowski.pl',
-      'm.maselkowski.pl',
-      'xn--masekowski-d0b.pl',
-      'xn--fiqa61au8b7zsevnm8ak20mc4a87e.xn--fiqs8s',
-      'xn--stackoverflow.com',
-      'stackoverflow.xn--com',
-      'stackoverflow.co.uk',
-      'xn--masekowski-d0b.pl',
-      'xn--fiqa61au8b7zsevnm8ak20mc4a87e.xn--fiqs8s',
-    ]
-    okStackoverflow.forEach(expectValid)
-
-    const badStackoverflow = [
-      '-notvalid.at-all',
-      '-thing.com',
-      'www.masełkowski.pl.com',
-    ]
-    badStackoverflow.forEach(expectInvalid)
-  })
-
-  it('conforms to interop valid handles', () => {
-    const lineReader = readline.createInterface({
-      input: fs.createReadStream(
-        `${__dirname}/interop-files/handle_syntax_valid.txt`,
-      ),
-      terminal: false,
-    })
-    lineReader.on('line', (line) => {
-      if (line.startsWith('#') || line.length === 0) {
-        return
-      }
-      expectValid(line)
-    })
-  })
-
-  it('conforms to interop invalid handles', () => {
-    const lineReader = readline.createInterface({
-      input: fs.createReadStream(
-        `${__dirname}/interop-files/handle_syntax_invalid.txt`,
-      ),
-      terminal: false,
-    })
-    lineReader.on('line', (line) => {
-      if (line.startsWith('#') || line.length === 0) {
-        return
-      }
-      expectInvalid(line)
-    })
-  })
-})
-
-describe('normalization', () => {
-  it('normalizes handles', () => {
-    const normalized = normalizeAndEnsureValidHandle('JoHn.TeST')
-    expect(normalized).toBe('john.test')
-  })
-
-  it('throws on invalid normalized handles', () => {
-    expect(() => normalizeAndEnsureValidHandle('JoH!n.TeST')).toThrow(
-      InvalidHandleError,
-    )
-  })
-})