@atproto/oauth-scopes 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atproto/oauth-scopes
 
+## 0.5.3
+
+### Patch Changes
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update TypeScript build to rely on references to composite internal projects
+
+- [#5099](https://github.com/bluesky-social/atproto/pull/5099) [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Bundle only necessary files in the NPM tarball, including the `CHANGELOG.md` and `README.md` files (if present).
+
+- Updated dependencies [[`28a0b58`](https://github.com/bluesky-social/atproto/commit/28a0b588147863eaef948cd2bb8fc0f19d08cda9), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07), [`b43ec31`](https://github.com/bluesky-social/atproto/commit/b43ec31f247f4461725b01226885f88bd430ca07)]:
+  - @atproto/syntax@0.6.4
+  - @atproto/did@0.5.3
+
 ## 0.5.2
 
 ### Patch Changes

package/package.json

@@ -1,9 +1,6 @@
 {
   "name": "@atproto/oauth-scopes",
-  "version": "0.5.2",
-  "engines": {
-    "node": ">=22"
-  },
+  "version": "0.5.3",
   "license": "MIT",
   "description": "A library for manipulating and validating ATproto OAuth scopes in TypeScript.",
   "keywords": [
@@ -18,6 +15,10 @@
     "url": "https://github.com/bluesky-social/atproto",
     "directory": "packages/oauth/auth-scopes"
   },
+  "files": [
+    "./dist",
+    "./CHANGELOG.md"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -25,9 +26,12 @@
       "default": "./dist/index.js"
     }
   },
+  "engines": {
+    "node": ">=22"
+  },
   "dependencies": {
-    "@atproto/syntax": "^0.6.3",
-    "@atproto/did": "^0.5.2"
+    "@atproto/did": "^0.5.3",
+    "@atproto/syntax": "^0.6.4"
   },
   "devDependencies": {
     "jest": "^30.0.0"

package/jest.config.cjs

@@ -1,14 +0,0 @@
-/** @type {import('jest').Config} */
-module.exports = {
-  displayName: 'OAuth Scopes',
-  transform: {
-    '^.+\\.(t|j)s$': [
-      '@swc/jest',
-      { jsc: { transform: {} }, module: { type: 'es6' } },
-    ],
-  },
-  extensionsToTreatAsEsm: ['.ts'],
-  transformIgnorePatterns: [],
-  setupFiles: ['<rootDir>/../../../test.setup.ts'],
-  moduleNameMapper: { '^(\\.\\.?\\/.+)\\.js$': ['$1.ts', '$1.js'] },
-}

package/src/atproto-oauth-scope.ts

@@ -1,79 +0,0 @@
-import { ScopeStringFor, isScopeStringFor } from './lib/syntax.js'
-import { isNonNullable } from './lib/util.js'
-import { AccountPermission } from './scopes/account-permission.js'
-import { BlobPermission } from './scopes/blob-permission.js'
-import { IdentityPermission } from './scopes/identity-permission.js'
-import { IncludeScope } from './scopes/include-scope.js'
-import { RepoPermission } from './scopes/repo-permission.js'
-import { RpcPermission } from './scopes/rpc-permission.js'
-
-export { type ScopeStringFor, isScopeStringFor }
-
-export const STATIC_SCOPE_VALUES = Object.freeze([
-  'atproto',
-  'transition:email',
-  'transition:generic',
-  'transition:chat.bsky',
-] as const)
-
-export type StaticScopeValue = (typeof STATIC_SCOPE_VALUES)[number]
-export function isStaticScopeValue(value: string): value is StaticScopeValue {
-  return (STATIC_SCOPE_VALUES as readonly string[]).includes(value)
-}
-
-export type AtprotoOauthScope =
-  | StaticScopeValue
-  | ScopeStringFor<'account'>
-  | ScopeStringFor<'blob'>
-  | ScopeStringFor<'identity'>
-  | ScopeStringFor<'include'>
-  | ScopeStringFor<'repo'>
-  | ScopeStringFor<'rpc'>
-
-/**
- * @note This function does not only verify the scope string format (with
- * {@link isScopeStringFor}), but also checks if the provided parameters are
- * valid according to the respective scope syntax definition. This allows
- * excluding scopes that cannot be fully interpreted by the current version of
- * the code.
- */
-export function isAtprotoOauthScope(value: string): value is AtprotoOauthScope {
-  return (
-    isStaticScopeValue(value) ||
-    AccountPermission.fromString(value) != null ||
-    BlobPermission.fromString(value) != null ||
-    IdentityPermission.fromString(value) != null ||
-    IncludeScope.fromString(value) != null ||
-    RepoPermission.fromString(value) != null ||
-    RpcPermission.fromString(value) != null
-  )
-}
-
-export function normalizeAtprotoOauthScope(scope: string) {
-  return scope
-    .split(' ')
-    .map(normalizeAtprotoOauthScopeValue)
-    .filter(isNonNullable)
-    .sort()
-    .join(' ')
-}
-
-export function normalizeAtprotoOauthScopeValue(
-  value: string,
-): AtprotoOauthScope | null {
-  if (isStaticScopeValue(value)) return value
-
-  for (const Scope of [
-    AccountPermission,
-    BlobPermission,
-    IdentityPermission,
-    IncludeScope,
-    RepoPermission,
-    RpcPermission,
-  ]) {
-    const parsed = Scope.fromString(value)
-    if (parsed) return parsed.toString()
-  }
-
-  return null
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from './atproto-oauth-scope.js'
-
-export * from './scope-missing-error.js'
-export * from './scope-permissions-transition.js'
-export * from './scope-permissions.js'
-export * from './scopes-set.js'
-
-export * from './scopes/account-permission.js'
-export * from './scopes/blob-permission.js'
-export * from './scopes/identity-permission.js'
-export * from './scopes/include-scope.js'
-export * from './scopes/repo-permission.js'
-export * from './scopes/rpc-permission.js'

package/src/lib/lexicon.ts

@@ -1,21 +0,0 @@
-import { ParamValue } from './syntax.js'
-
-// @NOTE Not types from from '@atproto/lex-document' because we want a readonly
-// version here to prevent accidental mutation.
-
-export type LexiconPermission<P extends string = string> = {
-  readonly type: 'permission'
-  readonly resource: P
-  readonly [x: string]: undefined | ParamValue | readonly ParamValue[]
-}
-
-type LangMap = { readonly [Lang in string]?: string }
-
-export type LexiconPermissionSet = {
-  readonly type: 'permission-set'
-  readonly permissions: readonly LexiconPermission<string>[]
-  readonly title?: string
-  readonly 'title:lang'?: LangMap
-  readonly detail?: string
-  readonly 'detail:lang'?: LangMap
-}

package/src/lib/mime.test.ts

@@ -1,98 +0,0 @@
-import { isAccept, isMime, matchesAccept, matchesAnyAccept } from './mime.js'
-
-describe('isAccept', () => {
-  it('should return true for valid MIME types', () => {
-    expect(isAccept('image/png')).toBe(true)
-    expect(isAccept('application/json')).toBe(true)
-    expect(isAccept('text/html')).toBe(true)
-    expect(isAccept('image/*')).toBe(true)
-    expect(isAccept('*/*')).toBe(true)
-  })
-
-  it('should return false for invalid MIME types', () => {
-    expect(isAccept('image//png')).toBe(false)
-    expect(isAccept('/png')).toBe(false)
-    expect(isAccept('image/')).toBe(false)
-    expect(isAccept('image/**')).toBe(false)
-    expect(isAccept('*/png')).toBe(false)
-    expect(isAccept('*')).toBe(false)
-    expect(isAccept('image/png/extra')).toBe(false)
-  })
-})
-
-describe('isMime', () => {
-  it('should return true for valid MIME types', () => {
-    expect(isMime('image/png')).toBe(true)
-    expect(isMime('application/json')).toBe(true)
-  })
-
-  it('should return false for invalid MIME types', () => {
-    expect(isMime('image/*')).toBe(false)
-    expect(isMime('*/*')).toBe(false)
-    expect(isMime('image/png/extra')).toBe(false)
-    expect(isMime('*/mime')).toBe(false)
-    expect(isMime('/png')).toBe(false)
-    expect(isMime('image/')).toBe(false)
-    expect(isMime('image')).toBe(false)
-    expect(isMime('image/ png')).toBe(false)
-    expect(isMime('image//png')).toBe(false)
-  })
-})
-
-describe('matchesAccept', () => {
-  it('should match exact MIME type', () => {
-    expect(matchesAccept('image/png', 'image/png')).toBe(true)
-  })
-
-  it('should match wildcard MIME type', () => {
-    expect(matchesAccept('image/*', 'image/jpeg')).toBe(true)
-  })
-
-  it('should match subtype wildcard MIME type', () => {
-    expect(matchesAccept('image/*', 'image/gif')).toBe(true)
-  })
-
-  it('should not match different MIME type', () => {
-    expect(matchesAccept('image/png', 'image/jpeg')).toBe(false)
-  })
-
-  it('should not match different wildcard MIME type', () => {
-    expect(matchesAccept('image/*', 'text/html')).toBe(false)
-  })
-
-  it('should match any MIME type with *', () => {
-    expect(matchesAccept('*/*', 'application/json')).toBe(true)
-  })
-
-  it('should not match invalid MIME type', () => {
-    expect(matchesAccept('image/png', '*/mime')).toBe(false)
-    expect(matchesAccept('image/png', 'image')).toBe(false)
-    expect(matchesAccept('image/*', 'image//png')).toBe(false)
-    expect(matchesAccept('image/*', 'image/ png')).toBe(false)
-    expect(matchesAccept('*/*', 'image/')).toBe(false)
-    expect(matchesAccept('*/*', '/mime')).toBe(false)
-  })
-})
-
-describe('matchesAnyAccept', () => {
-  it('should return true if any accept matches', () => {
-    const accepts = ['image/png', 'application/json'] as const
-    expect(matchesAnyAccept(accepts, 'image/png')).toBe(true)
-    expect(matchesAnyAccept(accepts, 'application/json')).toBe(true)
-  })
-
-  it('should return false if no accept matches', () => {
-    const accepts = ['image/png', 'application/json'] as const
-    expect(matchesAnyAccept(accepts, 'text/html')).toBe(false)
-  })
-
-  it('should handle empty accepts array', () => {
-    expect(matchesAnyAccept([], 'image/png')).toBe(false)
-  })
-
-  it('should handle single accept', () => {
-    const accepts = ['image/*'] as const
-    expect(matchesAnyAccept(accepts, 'image/jpeg')).toBe(true)
-    expect(matchesAnyAccept(accepts, 'text/html')).toBe(false)
-  })
-})

package/src/lib/mime.ts

@@ -1,71 +0,0 @@
-// @TODO Refactor in shared location for use with other @atproto packages
-
-function isStringSlashString(value: string): value is `${string}/${string}` {
-  const slashIndex = value.indexOf('/')
-
-  if (slashIndex === -1) return false // Missing slash
-  if (slashIndex === 0) return false // No leading part before the slash
-  if (slashIndex === value.length - 1) return false // No trailing part after the slash
-  if (value.includes('/', slashIndex + 1)) return false // More than one slash
-  if (value.includes(' ')) return false // Spaces are not allowed
-
-  return true
-}
-
-export type Mime = `${string}/${string}`
-
-export function isMime(value: string): value is Mime {
-  return isStringSlashString(value) && !value.includes('*')
-}
-
-export type Accept = '*/*' | `${string}/*` | Mime
-
-export function isAccept(value: unknown): value is Accept {
-  if (typeof value !== 'string') return false
-  if (value === '*/*') return true // Fast path for the most common case
-  if (!isStringSlashString(value)) return false
-  return !value.includes('*') || value.endsWith('/*')
-}
-
-/**
- * @note "unsafe" in that it does not check if either {@link accept} or
- * {@link mime} are actually valid values (and could, therefore, lead to false
- * positives if forged values are used).
- */
-function matchesAcceptUnsafe(accept: Accept, mime: Mime): boolean {
-  if (accept === '*/*') {
-    return true
-  }
-  if (accept.endsWith('/*')) {
-    return mime.startsWith(accept.slice(0, -1))
-  }
-  return accept === mime
-}
-
-export function matchesAccept(accept: Accept, mime: string): boolean {
-  return isMime(mime) && matchesAcceptUnsafe(accept, mime)
-}
-
-/**
- * @note "unsafe" in that it does not check if either {@link accept} or
- * {@link mime} are actually valid values (and could, therefore, lead to false
- * positives if forged values are used).
- */
-function matchesAnyAcceptUnsafe(
-  acceptable: Iterable<Accept>,
-  mime: Mime,
-): boolean {
-  for (const accept of acceptable) {
-    if (matchesAcceptUnsafe(accept, mime)) {
-      return true
-    }
-  }
-  return false
-}
-
-export function matchesAnyAccept(
-  acceptable: Iterable<Accept>,
-  mime: string,
-): boolean {
-  return isMime(mime) && matchesAnyAcceptUnsafe(acceptable, mime)
-}

package/src/lib/nsid.ts

@@ -1,5 +0,0 @@
-import { isValidNsid } from '@atproto/syntax'
-
-export type Nsid = `${string}.${string}.${string}`
-export const isNsid = (v: unknown): v is Nsid =>
-  typeof v === 'string' && isValidNsid(v)

package/src/lib/parser.ts

@@ -1,176 +0,0 @@
-import { ScopeStringSyntax } from './syntax-string.js'
-import { NeRoArray, ParamValue, ScopeSyntax } from './syntax.js'
-
-type InferParamPredicate<T extends (value: ParamValue) => boolean> =
-  T extends ((value: ParamValue) => value is infer U extends ParamValue)
-    ? U
-    : ParamValue
-
-type ParamsSchema = Record<
-  string,
-  | {
-      multiple: false
-      required: boolean
-      default?: ParamValue
-      normalize?: (value: ParamValue) => ParamValue
-      validate: (value: ParamValue) => boolean
-    }
-  | {
-      multiple: true
-      required: boolean
-      default?: NeRoArray<ParamValue>
-      normalize?: (value: NeRoArray<ParamValue>) => NeRoArray<ParamValue>
-      validate: (value: ParamValue) => boolean
-    }
->
-
-type InferParams<S extends ParamsSchema> = {
-  [K in keyof S]:
-    | (S[K]['required'] extends true
-        ? never
-        : 'default' extends keyof S[K]
-          ? S[K]['default']
-          : undefined)
-    | (S[K]['multiple'] extends true
-        ? NeRoArray<InferParamPredicate<S[K]['validate']>>
-        : InferParamPredicate<S[K]['validate']>)
-} & NonNullable<unknown>
-
-export class Parser<P extends string, S extends ParamsSchema> {
-  public readonly schemaKeys: ReadonlySet<keyof S & string>
-
-  constructor(
-    public readonly prefix: P,
-    public readonly schema: S,
-    public readonly positionalName?: keyof S & string,
-  ) {
-    this.schemaKeys = new Set(Object.keys(schema))
-  }
-
-  format(values: InferParams<S>) {
-    const params = new URLSearchParams()
-    let positional: string | undefined = undefined
-
-    for (const key of this.schemaKeys) {
-      const value = values[key]
-      // Ignore undefined values
-      if (value === undefined) continue
-
-      const schema = this.schema[key]
-
-      // Normalize the value if a normalization function is provided
-      const normalized = schema.normalize
-        ? schema.normalize(value as any)
-        : value
-
-      // Ignore values that are equal to the default value
-      if (!schema.required) {
-        if (schema.default === normalized) continue
-        if (
-          schema.multiple &&
-          schema.default &&
-          arrayParamEquals(schema.default, normalized as NeRoArray<string>)
-        ) {
-          continue
-        }
-      }
-
-      if (Array.isArray(normalized)) {
-        if (key === this.positionalName && normalized.length === 1) {
-          positional = String(normalized[0]!)
-        } else {
-          // remove duplicates
-          const unique = new Set(normalized.map(String))
-          for (const v of unique) params.append(key, v)
-        }
-      } else {
-        if (key === this.positionalName) {
-          positional = String(normalized)
-        } else {
-          params.set(key, String(normalized))
-        }
-      }
-    }
-
-    return new ScopeStringSyntax(this.prefix, positional, params).toString()
-  }
-
-  // @NOTE If we needed to ever have more detailed reason as to why parsing
-  // fails, this function could easily be updated to return a
-  // ValidationResult<T> type that explains the reason for failure.
-  parse(syntax: ScopeSyntax<P>) {
-    // @NOTE no need to check prefix, since the typing (P generic) already
-    // ensures it matches
-
-    for (const key of syntax.keys()) {
-      if (!this.schemaKeys.has(key)) return null
-    }
-
-    const result: Record<
-      string,
-      undefined | ParamValue | NeRoArray<ParamValue>
-    > = Object.create(null)
-
-    for (const key of this.schemaKeys) {
-      const definition = this.schema[key]
-
-      const param = definition.multiple
-        ? syntax.getMulti(key)
-        : syntax.getSingle(key)
-
-      if (param === null) {
-        return null // Value is not valid
-      } else if (param !== undefined) {
-        if (key === this.positionalName && syntax.positional !== undefined) {
-          // Positional parameter cannot be used with named parameters
-          return null
-        }
-
-        if (definition.multiple) {
-          // Empty array is not valid
-          if (!(param as ParamValue[]).length) return null
-          if (!(param as ParamValue[]).every(definition.validate)) {
-            return null
-          }
-        } else {
-          if (!definition.validate(param as ParamValue)) {
-            return null
-          }
-        }
-
-        result[key] = param as ParamValue | NeRoArray<ParamValue>
-      } else if (
-        key === this.positionalName &&
-        syntax.positional !== undefined
-      ) {
-        // No named parameters found, but there is a positional parameter
-        const { positional } = syntax
-        if (!definition.validate(positional)) {
-          return null
-        }
-        result[key] = definition.multiple ? [positional] : positional
-      } else if (definition.required) {
-        return null
-      } else {
-        result[key] = definition.default
-      }
-    }
-
-    return result as InferParams<S>
-  }
-}
-
-/**
- * Two param arrays are considered equal if they contain the same values,
- * regardless of the order and duplicates.
- * @param a - The first array to compare.
- * @param b - The second array to compare.
- */
-function arrayParamEquals(
-  a: readonly unknown[],
-  b: readonly unknown[],
-): boolean {
-  for (const item of a) if (!b.includes(item)) return false
-  for (const item of b) if (!a.includes(item)) return false
-  return true
-}

package/src/lib/resource-permission.ts

@@ -1,10 +0,0 @@
-import { ScopeStringFor } from './syntax.js'
-import { Matchable } from './util.js'
-
-/**
- * Interface destined to provide consistency across parsed permission scopes for
- * resources (blob, repo, etc.).
- */
-export interface ResourcePermission<R extends string, T> extends Matchable<T> {
-  toString(): ScopeStringFor<R>
-}

package/src/lib/syntax-lexicon.ts

@@ -1,55 +0,0 @@
-import { LexiconPermission } from './lexicon.js'
-import { ScopeSyntax } from './syntax.js'
-
-const isArray: (value: unknown) => value is readonly unknown[] = Array.isArray
-
-/**
- * Translates a {@link LexiconPermission} into a {@link ScopeSyntax}.
- */
-export class LexPermissionSyntax<P extends string = string>
-  implements ScopeSyntax<P>
-{
-  constructor(readonly lexPermission: LexiconPermission<P>) {}
-
-  get prefix() {
-    return this.lexPermission.resource
-  }
-
-  get positional() {
-    return undefined
-  }
-
-  get(key: string) {
-    // Ignore reserved keywords
-    if (key === 'type') return undefined
-    if (key === 'resource') return undefined
-
-    // Ignore inherited properties (toString(), etc.)
-    if (!Object.hasOwn(this.lexPermission, key)) return undefined
-
-    return this.lexPermission[key]
-  }
-
-  *keys() {
-    for (const key of Object.keys(this.lexPermission)) {
-      if (this.get(key) !== undefined) yield key
-    }
-  }
-
-  getSingle(key: string) {
-    const value = this.get(key)
-    if (isArray(value)) return null
-    return value
-  }
-
-  getMulti(key: string) {
-    const value = this.get(key)
-    if (value === undefined) return undefined
-    if (!isArray(value)) return null
-    return value
-  }
-
-  toJSON() {
-    return this.lexPermission
-  }
-}