@atproto/oauth-scopes 0.5.2 → 0.5.3

package/src/scopes/blob-permission.test.ts

@@ -1,126 +0,0 @@
-import { BlobPermission } from './blob-permission.js'
-
-describe('BlobPermission', () => {
-  describe('static', () => {
-    describe('fromString', () => {
-      it('should parse positional scope', () => {
-        const scope = BlobPermission.fromString('blob:image/png')
-        expect(scope).not.toBeNull()
-        expect(scope!.accept).toEqual(['image/png'])
-      })
-
-      it('should parse valid blob scope with multiple accept parameters', () => {
-        const scope = BlobPermission.fromString(
-          'blob?accept=image/png&accept=image/jpeg',
-        )
-        expect(scope).not.toBeNull()
-        expect(scope!.accept).toEqual(['image/png', 'image/jpeg'])
-      })
-
-      it('should reject blob scope without accept', () => {
-        const scope = BlobPermission.fromString('blob')
-        expect(scope).toBeNull()
-      })
-
-      for (const invalid of [
-        'invalid',
-        'scope',
-        'blob:invalid',
-        'blob?accept=invalid-mime',
-        'blob?accept=invalid',
-        'blob:*/**',
-        'blob:*/png',
-      ]) {
-        it(`should return null for invalid rpc scope: ${invalid}`, () => {
-          expect(BlobPermission.fromString(invalid)).toBeNull()
-        })
-      }
-    })
-
-    describe('scopeNeededFor', () => {
-      it('should return correct scope string for specific MIME type', () => {
-        const scope = BlobPermission.scopeNeededFor({ mime: 'image/png' })
-        expect(scope).toBe('blob:image/png')
-      })
-
-      it('should return scope that accepts all MIME types', () => {
-        const scope = BlobPermission.scopeNeededFor({
-          mime: 'application/json',
-        })
-        expect(scope).toBe('blob:application/json')
-      })
-    })
-  })
-
-  describe('instance', () => {
-    describe('matches', () => {
-      it('should match exact MIME type', () => {
-        const scope = BlobPermission.fromString('blob:image/png')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ mime: 'image/png' })).toBe(true)
-      })
-
-      it('should match wildcard MIME type', () => {
-        const scope = BlobPermission.fromString('blob:*/*')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ mime: 'image/jpeg' })).toBe(true)
-        expect(scope!.matches({ mime: 'application/json' })).toBe(true)
-      })
-
-      it('should match subtype wildcard MIME type', () => {
-        const scope = BlobPermission.fromString('blob:image/*')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ mime: 'image/gif' })).toBe(true)
-      })
-
-      it('should not match different MIME type', () => {
-        const scope = BlobPermission.fromString('blob:image/png')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ mime: 'image/jpeg' })).toBe(false)
-      })
-
-      it('should match multiple accept values', () => {
-        const scope = BlobPermission.fromString(
-          'blob?accept=image/png&accept=image/jpeg',
-        )
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ mime: 'image/png' })).toBe(true)
-        expect(scope!.matches({ mime: 'image/jpeg' })).toBe(true)
-        expect(scope!.matches({ mime: 'image/gif' })).toBe(false)
-      })
-    })
-
-    describe('toString', () => {
-      it('should format scope with accept parameter', () => {
-        const scope = new BlobPermission(['image/png', 'image/jpeg'])
-        expect(scope.toString()).toBe('blob?accept=image/jpeg&accept=image/png')
-      })
-
-      it('should strip redundant accept parameters', () => {
-        expect(new BlobPermission(['*/*', 'image/*']).toString()).toBe(
-          'blob:*/*',
-        )
-        expect(new BlobPermission(['*/*', 'image/png']).toString()).toBe(
-          'blob:*/*',
-        )
-        expect(new BlobPermission(['image/*', 'image/png']).toString()).toBe(
-          'blob:image/*',
-        )
-      })
-
-      it('should use positional format for single accept', () => {
-        expect(new BlobPermission(['image/png']).toString()).toBe(
-          'blob:image/png',
-        )
-        expect(new BlobPermission(['image/*']).toString()).toBe('blob:image/*')
-        expect(new BlobPermission(['*/*']).toString()).toBe('blob:*/*')
-      })
-
-      it('should use query format for multiple accepts', () => {
-        expect(new BlobPermission(['image/png', 'image/jpeg']).toString()).toBe(
-          'blob?accept=image/jpeg&accept=image/png',
-        )
-      })
-    })
-  })
-})

package/src/scopes/blob-permission.ts

@@ -1,105 +0,0 @@
-import { Accept, isAccept, matchesAnyAccept } from '../lib/mime.js'
-import { Parser } from '../lib/parser.js'
-import { ResourcePermission } from '../lib/resource-permission.js'
-import { ScopeStringSyntax } from '../lib/syntax-string.js'
-import {
-  NeArray,
-  NeRoArray,
-  ParamValue,
-  ScopeSyntax,
-  isScopeStringFor,
-} from '../lib/syntax.js'
-
-export { type Accept }
-
-export const DEFAULT_ACCEPT = Object.freeze(['*/*'] as const)
-
-export type BlobPermissionMatch = {
-  mime: string
-}
-
-export class BlobPermission
-  implements ResourcePermission<'blob', BlobPermissionMatch>
-{
-  constructor(public readonly accept: NeRoArray<Accept>) {}
-
-  matches(options: BlobPermissionMatch) {
-    return matchesAnyAccept(this.accept, options.mime)
-  }
-
-  toString() {
-    return BlobPermission.parser.format(this)
-  }
-
-  protected static readonly parser = new Parser(
-    'blob',
-    {
-      accept: {
-        multiple: true,
-        required: true,
-        validate: isAccept,
-        normalize: (value) => {
-          // Returns a more concise representation of the accept values.
-          if (value.includes('*/*')) return DEFAULT_ACCEPT
-
-          return value
-            .map(toLowerCase)
-            .filter(isNonRedundant)
-            .sort() as NeArray<Accept>
-        },
-      },
-    },
-    'accept',
-  )
-
-  static fromString(scope: string) {
-    if (!isScopeStringFor(scope, 'blob')) return null
-    const syntax = ScopeStringSyntax.fromString(scope)
-    return BlobPermission.fromSyntax(syntax)
-  }
-
-  static fromSyntax(syntax: ScopeSyntax<'blob'>) {
-    const result = BlobPermission.parser.parse(syntax)
-    if (!result) return null
-
-    return new BlobPermission(result.accept)
-  }
-
-  static scopeNeededFor(options: BlobPermissionMatch) {
-    return BlobPermission.parser.format({
-      accept: [options.mime as Accept],
-    })
-  }
-}
-
-function toLowerCase<T extends ParamValue>(
-  value: T,
-): T extends string ? string : T {
-  return (
-    typeof value === 'string' ? value.toLowerCase() : value
-  ) as T extends string ? string : T
-}
-
-function isNonRedundant(
-  value: ParamValue,
-  index: number,
-  arr: readonly ParamValue[],
-): boolean {
-  if (typeof value !== 'string') {
-    return true
-  }
-  if (value.endsWith('/*')) {
-    // assuming the array contains unique element, wildcards cannot be redundant
-    // with one another ('image/*' is not redundant with 'text/*')
-    return true
-  }
-  const base = value.split('/', 1)[0]
-  if (arr.includes(`${base}/*`)) {
-    // If another value in the array is a wildcard for the same base, we can
-    // skip this one as it is redundant. e.g. if the array contains 'image/png'
-    // and 'image/*', we can skip 'image/png' because 'image/*' already covers
-    // it.
-    return false
-  }
-  return true
-}

package/src/scopes/identity-permission.test.ts

@@ -1,80 +0,0 @@
-import { IdentityPermission } from './identity-permission.js'
-
-describe('IdentityPermission', () => {
-  describe('static', () => {
-    describe('fromString', () => {
-      it('should parse positional scope', () => {
-        const scope = IdentityPermission.fromString('identity:handle')
-        expect(scope).not.toBeNull()
-        expect(scope!.attr).toBe('handle')
-      })
-
-      it('should parse valid identity scope with wildcard attribute', () => {
-        const scope = IdentityPermission.fromString('identity:*')
-        expect(scope).not.toBeNull()
-        expect(scope!.attr).toBe('*')
-      })
-
-      it('should return null for invalid identity scope', () => {
-        expect(IdentityPermission.fromString('invalid')).toBeNull()
-        expect(IdentityPermission.fromString('identity:invalid')).toBeNull()
-      })
-
-      for (const invalid of [
-        'identity:*?action=*',
-        'identity:*?action=manage',
-        'identity:*?action=submit',
-        'invalid',
-        'identity:invalid',
-        'identity:handle?action=invalid',
-        'identity?attribute=invalid&action=invalid',
-      ]) {
-        it(`should return null for invalid rpc scope: ${invalid}`, () => {
-          expect(IdentityPermission.fromString(invalid)).toBeNull()
-        })
-      }
-    })
-
-    describe('scopeNeededFor', () => {
-      it('should return correct scope string for specific attribute and action', () => {
-        const scope = IdentityPermission.scopeNeededFor({ attr: 'handle' })
-        expect(scope).toBe('identity:handle')
-      })
-
-      it('should return scope that accepts all attributes with specific action', () => {
-        const scope = IdentityPermission.scopeNeededFor({ attr: '*' })
-        expect(scope).toBe('identity:*')
-      })
-    })
-  })
-
-  describe('instance', () => {
-    describe('matches', () => {
-      it('should match default attribute and action', () => {
-        const scope = IdentityPermission.fromString('identity:handle')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ attr: 'handle' })).toBe(true)
-        expect(scope!.matches({ attr: '*' })).toBe(false)
-      })
-
-      it('should match wildcard attribute with specific action', () => {
-        const scope = IdentityPermission.fromString('identity:*')
-        expect(scope).not.toBeNull()
-        expect(scope!.matches({ attr: '*' })).toBe(true)
-        expect(scope!.matches({ attr: 'handle' })).toBe(true)
-      })
-    })
-
-    describe('toString', () => {
-      it('should format scope with default action', () => {
-        const scope = new IdentityPermission('handle')
-        expect(scope.toString()).toBe('identity:handle')
-      })
-
-      it('should format wildcard attribute with default action', () => {
-        const scope = new IdentityPermission('*')
-        expect(scope.toString()).toBe('identity:*')
-      })
-    })
-  })
-})

package/src/scopes/identity-permission.ts

@@ -1,54 +0,0 @@
-import { Parser } from '../lib/parser.js'
-import { ResourcePermission } from '../lib/resource-permission.js'
-import { ScopeStringSyntax } from '../lib/syntax-string.js'
-import { ScopeSyntax, isScopeStringFor } from '../lib/syntax.js'
-import { knownValuesValidator } from '../lib/util.js'
-
-export const IDENTITY_ATTRIBUTES = Object.freeze(['handle', '*'] as const)
-export type IdentityAttribute = (typeof IDENTITY_ATTRIBUTES)[number]
-
-export type IdentityPermissionMatch = {
-  attr: IdentityAttribute
-}
-
-export class IdentityPermission
-  implements ResourcePermission<'identity', IdentityPermissionMatch>
-{
-  constructor(public readonly attr: IdentityAttribute) {}
-
-  matches(options: IdentityPermissionMatch) {
-    return this.attr === '*' || this.attr === options.attr
-  }
-
-  toString() {
-    return IdentityPermission.parser.format(this)
-  }
-
-  protected static readonly parser = new Parser(
-    'identity',
-    {
-      attr: {
-        multiple: false,
-        required: true,
-        validate: knownValuesValidator(IDENTITY_ATTRIBUTES),
-      },
-    },
-    'attr',
-  )
-
-  static fromString(scope: string) {
-    if (!isScopeStringFor(scope, 'identity')) return null
-    const syntax = ScopeStringSyntax.fromString(scope)
-    return IdentityPermission.fromSyntax(syntax)
-  }
-
-  static fromSyntax(syntax: ScopeSyntax<'identity'>) {
-    const result = IdentityPermission.parser.parse(syntax)
-    if (!result) return null
-    return new IdentityPermission(result.attr)
-  }
-
-  static scopeNeededFor(options: IdentityPermissionMatch): string {
-    return IdentityPermission.parser.format(options)
-  }
-}