@atproto/oauth-scopes 0.0.2 → 0.1.0

package/src/resources/rpc-scope.test.ts

@@ -1,280 +0,0 @@
-import { RpcScope } from './rpc-scope.js'
-
-describe('RpcScope', () => {
-  describe('static', () => {
-    describe('fromString', () => {
-      it('should parse positional scope', () => {
-        const scope = RpcScope.fromString(
-          'rpc:com.example.service?aud=did:example:123',
-        )
-        expect(scope).not.toBeNull()
-        expect(scope!.aud).toBe('did:example:123')
-        expect(scope!.lxm).toEqual(['com.example.service'])
-      })
-
-      it('should parse strings correctly', () => {
-        expect(
-          RpcScope.fromString('rpc?lxm=com.example.method1&aud=*'),
-        ).toEqual({
-          aud: '*',
-          lxm: ['com.example.method1'],
-        })
-        expect(RpcScope.fromString('rpc:com.example.method1?aud=*')).toEqual({
-          aud: '*',
-          lxm: ['com.example.method1'],
-        })
-      })
-
-      it('should render strings correctly', () => {
-        expect(
-          new RpcScope('did:example:123', ['com.example.service']).toString(),
-        ).toBe('rpc:com.example.service?aud=did:example:123')
-        expect(new RpcScope('*', ['com.example.method1']).toString()).toBe(
-          'rpc:com.example.method1?aud=*',
-        )
-        expect(
-          new RpcScope('did:example:123', [
-            'com.example.method1',
-            'com.example.method2',
-          ]).toString(),
-        ).toBe(
-          'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=did:example:123',
-        )
-      })
-
-      it('should reject scopes without lxm', () => {
-        expect(RpcScope.fromString('rpc?aud=did:example:123')).toBeNull()
-        expect(RpcScope.fromString('rpc:?aud=did:example:123')).toBeNull()
-      })
-
-      it('should reject scopes without aud', () => {
-        expect(RpcScope.fromString('rpc?lxm=com.example.method1')).toBeNull()
-        expect(RpcScope.fromString('rpc:com.example.method1')).toBeNull()
-      })
-
-      it('should reject scopes with lxm in both positional and query form', () => {
-        expect(
-          RpcScope.fromString(
-            'rpc:com.example.method1?aud=did:example:123&lxm=com.example.method2',
-          ),
-        ).toBeNull()
-      })
-
-      it('should parse valid rpc scope with multiple lxm', () => {
-        const scope = RpcScope.fromString(
-          'rpc?aud=*&lxm=com.example.method1&lxm=com.example.method2',
-        )
-        expect(scope).not.toBeNull()
-        expect(scope!.aud).toBe('*')
-        expect(scope!.lxm).toEqual([
-          'com.example.method1',
-          'com.example.method2',
-        ])
-      })
-
-      it('should reject rpc scope without lxm', () => {
-        const scope = RpcScope.fromString('rpc?aud=did:example:123')
-        expect(scope).toBeNull()
-      })
-
-      it('should reject rpc scope without aud', () => {
-        const scope = RpcScope.fromString('rpc?lxm=com.example.method1')
-        expect(scope).toBeNull()
-      })
-
-      it('should reject any aud/any lxm', () => {
-        expect(RpcScope.fromString('rpc?aud=*&lxm=*')).toBeNull()
-        expect(RpcScope.fromString('rpc:*?aud=*')).toBeNull()
-      })
-
-      it('should reject missing aud', () => {
-        expect(RpcScope.fromString('rpc:com.example.service')).toBeNull()
-      })
-
-      it('should reject invalid aud', () => {
-        expect(
-          RpcScope.fromString('rpc:com.example.service?aud=invalid'),
-        ).toBeNull()
-      })
-
-      it('should reject invalid lxm', () => {
-        expect(RpcScope.fromString('rpc:invalid')).toBeNull()
-        expect(RpcScope.fromString('rpc?lxm=invalid')).toBeNull()
-      })
-
-      for (const invalid of [
-        'rpc:*',
-        'invalid',
-        'rpc:invalid',
-        'rpc:invalid?aud=did:foo:bar',
-        'rpc:foo.bar?aud=did:foo:bar&lxm=bar.baz',
-        'rpc:foo.bar?aud=invalid',
-        'rpc:invalid?aud=did:example:123',
-        'rpc:com.example.service?aud=invalid',
-        'notrpc:com.example.service?aud=did:example:123',
-        'rpc?lxm=invalid&aud=invalid',
-      ]) {
-        it(`should return null for invalid rpc scope: ${invalid}`, () => {
-          expect(RpcScope.fromString(invalid)).toBeNull()
-        })
-      }
-    })
-
-    describe('scopeNeededFor', () => {
-      it('should return correct scope string for specific lxm and aud', () => {
-        const scope = RpcScope.scopeNeededFor({
-          lxm: 'com.example.service',
-          aud: 'did:example:123',
-        })
-        expect(scope).toBe('rpc:com.example.service?aud=did:example:123')
-      })
-
-      it('should return scope that accepts all aud with specific lxm', () => {
-        const scope = RpcScope.scopeNeededFor({
-          lxm: 'com.example.method1',
-          aud: '*',
-        })
-        expect(scope).toBe('rpc:com.example.method1?aud=*')
-      })
-    })
-  })
-
-  describe('instance', () => {
-    describe('matches', () => {
-      it('should match exact lxm and aud', () => {
-        const scope = RpcScope.fromString(
-          'rpc:com.example.service?aud=did:example:123',
-        )
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.service',
-            aud: 'did:example:123',
-          }),
-        ).toBe(true)
-      })
-
-      it('should not match different lxm', () => {
-        const scope = RpcScope.fromString(
-          'rpc:com.example.service?aud=did:example:123',
-        )
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.OtherService',
-            aud: 'did:example:123',
-          }),
-        ).toBe(false)
-      })
-
-      it('should not match different aud', () => {
-        const scope = RpcScope.fromString(
-          'rpc:com.example.service?aud=did:example:123',
-        )
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.service',
-            aud: 'did:example:456',
-          }),
-        ).toBe(false)
-      })
-
-      it('should match wildcard aud', () => {
-        const scope = RpcScope.fromString('rpc:com.example.method1?aud=*')
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.method1',
-            aud: 'did:example:123',
-          }),
-        ).toBe(true)
-      })
-
-      it('should match wildcard lxm', () => {
-        const scope = RpcScope.fromString('rpc:*?aud=did:example:123')
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.method1',
-            aud: 'did:example:123',
-          }),
-        ).toBe(true)
-      })
-
-      it('should not match different lxm with wildcard aud', () => {
-        const scope = RpcScope.fromString('rpc:*?aud=did:example:123')
-        expect(scope).not.toBeNull()
-        expect(
-          scope!.matches({
-            lxm: 'com.example.anyMethod',
-            aud: 'did:example:123',
-          }),
-        ).toBe(true)
-      })
-    })
-
-    describe('toString', () => {
-      it('should format scope with lxm and aud', () => {
-        const scope = new RpcScope('did:example:123', ['com.example.service'])
-        expect(scope.toString()).toBe(
-          'rpc:com.example.service?aud=did:example:123',
-        )
-      })
-
-      it('should format scope with wildcard aud', () => {
-        const scope = new RpcScope('*', ['com.example.method1'])
-        expect(scope.toString()).toBe('rpc:com.example.method1?aud=*')
-      })
-
-      it('should format scope with wildcard lxm', () => {
-        const scope = new RpcScope('did:example:123', ['*'])
-        expect(scope.toString()).toBe('rpc:*?aud=did:example:123')
-      })
-
-      it('simplifies lxm if one of them is "*"', () => {
-        const scope = new RpcScope('did:example:123', [
-          '*',
-          'com.example.method1',
-        ])
-        expect(scope.toString()).toBe('rpc:*?aud=did:example:123')
-      })
-    })
-  })
-
-  describe('consistency', () => {
-    const testCases: { input: string; expected: string }[] = [
-      {
-        input: 'rpc:com.example.service?aud=did:example:123',
-        expected: 'rpc:com.example.service?aud=did:example:123',
-      },
-      {
-        input: 'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=*',
-        expected: 'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=*',
-      },
-      {
-        input:
-          'rpc?lxm=com.example.method1&lxm=com.example.method2&lxm=*&aud=did:example:123',
-        expected: 'rpc:*?aud=did:example:123',
-      },
-      {
-        input: 'rpc?aud=did:example:123&lxm=com.example.service',
-        expected: 'rpc:com.example.service?aud=did:example:123',
-      },
-      {
-        input: 'rpc?lxm=com.example.method1&aud=did:example:123',
-        expected: 'rpc:com.example.method1?aud=did:example:123',
-      },
-      {
-        input: 'rpc:com.example.method1?&aud=*',
-        expected: 'rpc:com.example.method1?aud=*',
-      },
-    ]
-
-    for (const { input, expected } of testCases) {
-      it(`should properly re-format ${input}`, () => {
-        expect(RpcScope.fromString(input)?.toString()).toBe(expected)
-      })
-    }
-  })
-})

package/src/resources/rpc-scope.ts

@@ -1,77 +0,0 @@
-import { DIDLike, isDIDLike } from '../lib/did.js'
-import { NSID, isNSID } from '../lib/nsid.js'
-import { Parser } from '../parser.js'
-import { NeRoArray, ResourceSyntax, isScopeForResource } from '../syntax.js'
-
-const validateLxmParam = (value: string) => value === '*' || isNSID(value)
-const validateAudParam = (value: string) => value === '*' || isDIDLike(value)
-
-export const rpcParser = new Parser(
-  'rpc',
-  {
-    lxm: {
-      multiple: true,
-      required: true,
-      validate: validateLxmParam,
-    },
-    aud: {
-      multiple: false,
-      required: true,
-      validate: validateAudParam,
-    },
-  },
-  'lxm',
-)
-
-export type RpcScopeMatch = {
-  lxm: string
-  aud: string
-}
-
-export class RpcScope {
-  constructor(
-    public readonly aud: '*' | DIDLike,
-    public readonly lxm: NeRoArray<'*' | NSID>,
-  ) {}
-
-  matches(options: RpcScopeMatch): boolean {
-    const { aud, lxm } = this
-    return (
-      (aud === '*' || aud === options.aud) &&
-      (lxm.includes('*') || (lxm as readonly string[]).includes(options.lxm))
-    )
-  }
-
-  toString(): string {
-    const { lxm, aud } = this
-    return rpcParser.format({
-      aud,
-      lxm: lxm.includes('*')
-        ? ['*']
-        : ([...new Set(lxm)].sort() as [NSID, ...NSID[]]),
-    })
-  }
-
-  static fromString(scope: string): RpcScope | null {
-    if (!isScopeForResource(scope, 'rpc')) return null
-    const syntax = ResourceSyntax.fromString(scope)
-    return this.fromSyntax(syntax)
-  }
-
-  static fromSyntax(syntax: ResourceSyntax): RpcScope | null {
-    const result = rpcParser.parse(syntax)
-    if (!result) return null
-
-    // rpc:*?aud=* is forbidden
-    if (result.aud === '*' && result.lxm.includes('*')) return null
-
-    return new RpcScope(result.aud, result.lxm)
-  }
-
-  static scopeNeededFor(options: RpcScopeMatch): string {
-    return rpcParser.format({
-      aud: options.aud as DIDLike,
-      lxm: [options.lxm as NSID],
-    })
-  }
-}

package/src/syntax.test.ts

@@ -1,203 +0,0 @@
-import { ResourceSyntax, isScopeForResource } from './syntax.js'
-
-describe('isScopeForResource', () => {
-  describe('exact match', () => {
-    it('should return true for exact match', () => {
-      expect(isScopeForResource('resource', 'resource')).toBe(true)
-    })
-
-    it('should return false for different resource', () => {
-      expect(isScopeForResource('resource', 'differentResource')).toBe(false)
-    })
-  })
-
-  describe('with positional parameter', () => {
-    it('should return true for exact match with positional parameter', () => {
-      expect(isScopeForResource('resource:positional', 'resource')).toBe(true)
-    })
-
-    it('should return false for different resource with positional parameter', () => {
-      expect(
-        isScopeForResource('differentResource:positional', 'resource'),
-      ).toBe(false)
-    })
-  })
-
-  describe('with named parameters', () => {
-    it('should return true for exact match with named parameters', () => {
-      expect(isScopeForResource('resource?param=value', 'resource')).toBe(true)
-    })
-
-    it('should return false for different resource with named parameters', () => {
-      expect(
-        isScopeForResource('differentResource?param=value', 'resource'),
-      ).toBe(false)
-    })
-  })
-})
-
-for (const { scope, normalized = scope, content } of [
-  {
-    scope: 'my-res',
-    content: { resource: 'my-res' },
-  },
-  {
-    scope: 'my-res:my-pos',
-    content: { resource: 'my-res', positional: 'my-pos' },
-  },
-  {
-    scope: 'my-res:',
-    content: { resource: 'my-res', positional: '' },
-  },
-  {
-    scope: 'my-res:foo?x=value&y=value-y',
-    content: {
-      resource: 'my-res',
-      positional: 'foo',
-      params: { x: ['value'], y: ['value-y'] },
-    },
-  },
-  {
-    scope: 'my-res?x=value&y=value-y',
-    content: { resource: 'my-res', params: { x: ['value'], y: ['value-y'] } },
-  },
-  {
-    scope: 'my-res?x=foo&x=bar&x=baz',
-    content: { resource: 'my-res', params: { x: ['foo', 'bar', 'baz'] } },
-  },
-  {
-    scope: 'rpc:foo.bar?aud=did:foo:bar?lxm=bar.baz',
-    normalized: 'rpc:foo.bar?aud=did:foo:bar%3Flxm%3Dbar.baz',
-    content: {
-      resource: 'rpc',
-      positional: 'foo.bar',
-      params: { aud: ['did:foo:bar?lxm=bar.baz'] },
-    },
-  },
-] as Array<{
-  scope: string
-  normalized?: string
-  content: {
-    resource: string
-    positional?: string
-    params?: Record<string, string[]>
-  }
-}>) {
-  describe(`Valid "${scope}"`, () => {
-    const syntax = ResourceSyntax.fromString(scope)
-
-    it('should match the expected syntax', () => {
-      expect(syntax).toEqual({
-        resource: content.resource,
-        positional: content.positional,
-        params: content.params
-          ? new URLSearchParams(
-              Object.entries(content.params).flatMap(([k, v]) =>
-                v.map((val) => [k, val]),
-              ),
-            )
-          : undefined,
-      })
-    })
-
-    it(`should stringify ${scope} correctly`, () => {
-      expect(syntax.toString()).toBe(normalized)
-    })
-
-    it(`should parse ${scope} correctly`, () => {
-      expect(syntax.toJSON()).toMatchObject(content)
-    })
-
-    it(`should match ${scope} resource`, () => {
-      expect(syntax.is(content.resource)).toBe(true)
-    })
-
-    it(`should return undefined for nonexistent single-value param`, () => {
-      expect(syntax.getSingle('nonexistent')).toBeUndefined()
-    })
-
-    it(`should return undefined for nonexistent multi-value param`, () => {
-      expect(syntax.getMulti('nonexistent')).toBeUndefined()
-    })
-
-    const { params } = content
-    if (params) {
-      it(`should allow detecting unknown params`, () => {
-        const allowedParams = Object.keys(params) as [string, ...string[]]
-        expect(syntax.containsParamsOtherThan(allowedParams)).toBe(false)
-
-        if (allowedParams.length > 1) {
-          const woFirst = allowedParams.slice(1) as [string, ...string[]]
-          expect(syntax.containsParamsOtherThan(woFirst)).toBe(true)
-
-          const woLast = allowedParams.slice(0, -1) as [string, ...string[]]
-          expect(syntax.containsParamsOtherThan(woLast)).toBe(true)
-        }
-      })
-
-      for (const [key, values] of Object.entries(params)) {
-        it(`should get an array when reading "${key}"`, () => {
-          expect(syntax.getMulti(key)).toEqual(values)
-        })
-
-        if (values.length === 1) {
-          it(`should allow retrieving single-value params`, () => {
-            expect(syntax.getSingle(key)).toEqual(values[0])
-          })
-        } else {
-          it(`should return null for multi-value params`, () => {
-            expect(syntax.getSingle(key)).toBeNull()
-            expect(syntax.getSingle(key, true)).toBeNull()
-          })
-        }
-      }
-    }
-
-    const { positional } = content
-    if (positional !== undefined) {
-      it(`should return positional parameter`, () => {
-        expect(syntax.positional).toBe(positional)
-      })
-
-      it(`should return positional parameter when reading as single-value`, () => {
-        expect(syntax.getSingle('nonexistent', true)).toBe(positional)
-      })
-
-      it(`should return positional parameter when reading as multi-value`, () => {
-        expect(syntax.getMulti('nonexistent', true)).toEqual([positional])
-      })
-    }
-  })
-}
-
-describe('invalid positional parameters', () => {
-  it('should return null for positional parameters used together with named parameters', () => {
-    const syntax = ResourceSyntax.fromString('my-res:pos?x=value')
-    expect(syntax.getSingle('x', true)).toBeNull()
-    expect(syntax.getMulti('x', true)).toBeNull()
-  })
-})
-
-describe('containsParamsOtherThan', () => {
-  it('should return true if there are additional params', () => {
-    const syntax = ResourceSyntax.fromString('my-res?x=value&y=value-y')
-    expect(syntax.containsParamsOtherThan(['x'])).toBe(true)
-  })
-})
-
-describe('url encoding', () => {
-  it('should handle URL encoding in positional parameters', () => {
-    const syntax = ResourceSyntax.fromString('my-res:my%20pos')
-    expect(syntax.positional).toBe('my pos')
-  })
-
-  it('should handle URL encoding in named parameters', () => {
-    const syntax = ResourceSyntax.fromString('my-res?x=my%20value')
-    expect(syntax.getSingle('x')).toBe('my value')
-  })
-
-  it(`should allow colon (:) in positional parameters`, () => {
-    const syntax = ResourceSyntax.fromString('my-res:my:pos')
-    expect(syntax.positional).toBe('my:pos')
-  })
-})