@atproto/oauth-provider 0.19.6 → 0.19.8

package/src/lib/http/accept.ts

@@ -1,90 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http'
-// eslint-disable-next-line import/default, import/no-named-as-default-member
-import accept from '@hapi/accept'
-// eslint-disable-next-line import/no-named-as-default-member
-const { mediaType } = accept
-import { SubCtx, subCtx } from './context.js'
-import { Middleware, NextFunction } from './types.js'
-
-type View<
-  T extends object | void,
-  D,
-  Req extends IncomingMessage = IncomingMessage,
-  Res extends ServerResponse = ServerResponse,
-> = (
-  this: SubCtx<T, { data: D }>,
-  req: Req,
-  res: Res,
-  next: NextFunction,
-) => void | PromiseLike<void>
-
-/**
- * @example
- * ```ts
- *  app.use(
- *    acceptMiddleware(
- *      async function (req, res) {
- *        return { hello: 'world' }
- *      },
- *      {
- *        '': 'application/json', // Fallback to JSON
- *        'text/plain': function (req, res) {
- *           res.writeHead(200).end(this.data.hello)
- *         },
- *        'application/json': function (req, res) {
- *          res.writeHead(200).end(JSON.stringify(this.data))
- *        }
- *      }
- *    )
- *  )
- * ```
- */
-export function acceptMiddleware<
-  D,
-  T extends object | void = void,
-  Req extends IncomingMessage = IncomingMessage,
-  Res extends ServerResponse = ServerResponse,
->(
-  controller: (this: T, req: Req, res: Res) => D | PromiseLike<D>,
-  views: Record<string, string | View<T, D, Req, Res>>,
-  fallback: Middleware<T> = (req, res, _next) => void res.writeHead(406).end(),
-): (this: T, req: Req, res: Res, next: NextFunction) => Promise<void> {
-  const viewsMap = new Map(Object.entries(views))
-  const preferences = Array.from(viewsMap.keys()).filter(Boolean)
-
-  // Make sure that every view is either a function or a string that points to a
-  // function.
-  for (const type of viewsMap.keys()) {
-    const view = viewsMap.get(type)
-    if (typeof view === 'string' && typeof viewsMap.get(view) !== 'function') {
-      throw new Error(`Invalid view "${view}" for media type "${type}"`)
-    }
-  }
-
-  return async function (req, res, next) {
-    try {
-      const type = req.headers['accept']
-        ? mediaType(req.headers['accept'], preferences) || undefined
-        : '' // indicate that the client accepts anything
-
-      let view = type != null ? viewsMap.get(type) : undefined
-
-      if (typeof view === 'string') view = viewsMap.get(view)
-      if (typeof view === 'string') throw new Error('Invalid view') // should not happen
-
-      if (view) {
-        const data = await controller.call(this, req, res)
-        const ctx = subCtx(this, { data })
-        if (type) res.setHeader('Content-Type', type)
-
-        await view.call(ctx, req, res, next)
-      } else {
-        // media negotiation failed
-        await fallback.call(this, req, res, next)
-      }
-    } catch (err) {
-      if (!res.headersSent) res.removeHeader('Content-Type')
-      next(err)
-    }
-  }
-}

package/src/lib/http/context.ts

@@ -1,42 +0,0 @@
-export type SubCtx<Parent extends object | void, Child extends object> = Child &
-  Omit<Parent, keyof Child>
-
-export function subCtx<Parent extends object | void, Child extends object>(
-  parent: Parent,
-  child: Child,
-): SubCtx<Parent, Child> {
-  const proto = typeof parent === 'object' ? parent : null
-  const entries = Object.entries(child)
-
-  // Optimization for small objects
-  switch (entries.length) {
-    case 0:
-      return Object.create(proto)
-    case 1: {
-      const e0 = entries[0]
-      return Object.create(proto, {
-        [e0[0]]: valueDescriptor(e0[1]),
-      })
-    }
-    case 2: {
-      const e0 = entries[0]
-      const e1 = entries[1]
-      return Object.create(proto, {
-        [e0[0]]: valueDescriptor(e0[1]),
-        [e1[0]]: valueDescriptor(e1[1]),
-      })
-    }
-  }
-
-  return Object.create(proto, Object.fromEntries(entries.map(entryToEntryDesc)))
-}
-
-function entryToEntryDesc(
-  entry: [string, unknown],
-): [string, PropertyDescriptor] {
-  return [entry[0], valueDescriptor(entry[1])]
-}
-
-function valueDescriptor(value: unknown): PropertyDescriptor {
-  return { value, enumerable: true, writable: false }
-}

package/src/lib/http/headers.ts

@@ -1,15 +0,0 @@
-import type { ServerResponse } from 'node:http'
-
-export function appendHeader(
-  res: ServerResponse,
-  header: string,
-  value: string | readonly string[],
-): void {
-  const existing = res.getHeader(header)
-  if (existing == null) {
-    res.setHeader(header, value)
-  } else {
-    const arr = Array.isArray(existing) ? existing : [String(existing)]
-    res.setHeader(header, arr.concat(value))
-  }
-}

package/src/lib/http/index.ts

@@ -1,10 +0,0 @@
-export * from './accept.js'
-export * from './context.js'
-export * from './headers.js'
-export * from './middleware.js'
-export * from './parser.js'
-export * from './request.js'
-export * from './response.js'
-export * from './router.js'
-export * from './stream.js'
-export * from './types.js'

package/src/lib/http/method.ts

@@ -1,18 +0,0 @@
-import type { IncomingMessage } from 'node:http'
-
-export type MethodMatcherInput = string | Iterable<string> | MethodMatcher
-export type MethodMatcher = (req: IncomingMessage) => boolean
-
-export function createMethodMatcher(method: MethodMatcherInput): MethodMatcher {
-  if (method === '*') return () => true
-  if (typeof method === 'function') return method
-
-  if (typeof method === 'string') {
-    method = method.toUpperCase()
-    return (req) => req.method === method
-  }
-
-  const set = new Set(Array.from(method, (m) => m.toUpperCase()))
-  if (set.size === 0) return () => false
-  return (req) => req.method != null && set.has(req.method)
-}

package/src/lib/http/middleware.ts

@@ -1,169 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { invokeOnce } from '../util/function.js'
-import { writeJson } from './response.js'
-import { Handler, Middleware, NextFunction } from './types.js'
-
-const isNonNullable = <X>(x: X): x is NonNullable<X> => x != null
-
-export function combineMiddlewares<M extends Middleware<any, any, any>>(
-  middlewares: Iterable<null | undefined | M>,
-  options?: { skipKeyword?: string },
-): M
-
-/**
- * Combine express/connect like middlewares (that can be async) into a single
- * middleware.
- */
-export function combineMiddlewares(
-  middlewares: Iterable<null | undefined | Middleware<unknown>>,
-  { skipKeyword }: { skipKeyword?: string } = {},
-): Middleware<unknown> {
-  const middlewaresArray = Array.from(middlewares).filter(isNonNullable)
-
-  // Optimization: if there are no middlewares, return a noop middleware.
-  if (middlewaresArray.length === 0) return (req, res, next) => void next()
-  if (middlewaresArray.length === 1) return middlewaresArray[0]
-
-  return function (req, res, next) {
-    let i = 0
-    const nextMiddleware = (err?: unknown) => {
-      if (err) {
-        if (skipKeyword && err === skipKeyword) next()
-        else next(err)
-      } else if (i >= middlewaresArray.length) {
-        next()
-      } else {
-        const currentMiddleware = middlewaresArray[i++]!
-        const currentNext = invokeOnce(nextMiddleware)
-        currentMiddleware.call(this, req, res, currentNext)
-      }
-    }
-    nextMiddleware()
-  }
-}
-
-export type AsHandler<M extends Middleware<any, any, any>> =
-  M extends Middleware<infer T, infer Req, infer Res>
-    ? Handler<T, Req, Res>
-    : never
-
-/**
- * Convert a middleware in a function that can be used as both a middleware and
- * and handler.
- */
-export function asHandler<M extends Middleware<any, any, any>>(
-  middleware: M,
-  options?: FinalHandlerOptions,
-) {
-  return function (
-    this,
-    req,
-    res,
-    next = invokeOnce(createFinalHandler(req, res, options)),
-  ) {
-    return middleware.call(this, req, res, next)
-  } as AsHandler<M>
-}
-
-export const DEV_MODE = process.env['NODE_ENV'] === 'development'
-
-export type FinalHandlerOptions = {
-  debug?: boolean
-}
-
-export function createFinalHandler(
-  req: IncomingMessage,
-  res: ServerResponse,
-  options?: FinalHandlerOptions,
-): NextFunction {
-  return (err) => {
-    if (err != null && (options?.debug ?? DEV_MODE)) {
-      console.error(err)
-    }
-
-    if (res.headersSent) {
-      // If an error occurred, and headers were sent, we can't know that the
-      // whole response body was sent. So we can't safely reuse the socket.
-      if (err) req.socket.destroy()
-
-      return
-    }
-
-    const { status, ...payload } = buildFallbackPayload(req, err)
-
-    res.setHeader('Content-Security-Policy', "default-src 'none'")
-    res.setHeader('X-Content-Type-Options', 'nosniff')
-
-    writeJson(res, payload, { status })
-  }
-}
-
-function buildFallbackPayload(
-  req: IncomingMessage,
-  err: unknown,
-): {
-  status: number
-  error: string
-  error_description: string
-  stack?: undefined | string
-} {
-  const status = err ? getErrorStatusCode(err) : 404
-  const expose = getProp(err, 'expose', 'boolean') ?? status < 500
-
-  return {
-    status,
-    error: err
-      ? expose
-        ? getProp(err, 'code', 'string') ??
-          getProp(err, 'error', 'string') ??
-          'unknown_error'
-        : 'system_error'
-      : 'not_found',
-    error_description:
-      err instanceof Error
-        ? expose
-          ? getProp(err, 'error_description', 'string') ||
-            String(err.message) ||
-            'Unknown error'
-          : 'System error'
-        : `Cannot ${req.method} ${req.url}`,
-    stack: DEV_MODE && err instanceof Error ? err.stack : undefined,
-  }
-}
-
-function getErrorStatusCode(err: NonNullable<unknown>): number {
-  const status =
-    getProp(err, 'status', 'number') ?? getProp(err, 'statusCode', 'number')
-  return status != null && status >= 400 && status < 600 ? status : 500
-}
-
-// eslint-disable-next-line
-function getProp(obj: unknown, key: string, t: 'function'): Function | undefined
-function getProp(obj: unknown, key: string, t: 'string'): string | undefined
-function getProp(obj: unknown, key: string, t: 'number'): number | undefined
-function getProp(obj: unknown, key: string, t: 'boolean'): boolean | undefined
-function getProp(obj: unknown, key: string, t: 'object'): object | undefined
-function getProp(obj: unknown, key: string, t: 'symbol'): symbol | undefined
-function getProp(obj: unknown, key: string, t: 'bigint'): bigint | undefined
-function getProp(obj: unknown, key: string, t: 'undefined'): undefined
-function getProp(
-  obj: unknown,
-  key: string,
-  type:
-    | 'string'
-    | 'number'
-    | 'boolean'
-    | 'object'
-    | 'function'
-    | 'symbol'
-    | 'bigint'
-    | 'undefined',
-): unknown
-
-function getProp(obj: unknown, key: string, type: string): unknown {
-  if (obj != null && typeof obj === 'object' && key in obj) {
-    const value = (obj as Record<string, unknown>)[key]
-    if (typeof value === type) return value
-  }
-  return undefined
-}

package/src/lib/http/parser.ts

@@ -1,101 +0,0 @@
-import { parse as parseJson } from '@hapi/bourne'
-import { type as hapiContentType } from '@hapi/content'
-import createHttpError from 'http-errors'
-
-export type JsonScalar = string | number | boolean | null
-export type Json = JsonScalar | Json[] | { [_ in string]?: Json }
-
-/**
- * Parse a content-type string into its components.
- *
- * @throws {TypeError} If the content-type is invalid.
- */
-export function parseContentType(type: unknown): ContentType {
-  if (typeof type !== 'string') {
-    throw createHttpError(
-      415,
-      `Invalid content-type: ${type == null ? String(type) : typeof type}`,
-    )
-  }
-
-  try {
-    return hapiContentType(type)
-  } catch (err) {
-    // De-boomify the error
-    throw createHttpError(
-      415,
-      err instanceof Error ? err.message : 'Invalid content-type',
-    )
-  }
-}
-
-export type ContentType = {
-  mime: string
-  charset?: string
-  boundary?: string
-}
-
-export type Parser<T extends string = string, R = unknown> = {
-  readonly name: string
-  readonly test: (mime: string) => mime is T
-  readonly parse: (buffer: Buffer, type: ContentType) => R
-}
-
-export type ParserName<P extends Parser> = P extends { readonly name: infer N }
-  ? N
-  : never
-export type ParserType<P extends Parser> = P extends Parser<infer T> ? T : never
-export type ParserResult<P extends Parser> = ReturnType<P['parse']>
-
-export type ParserForType<P extends Parser, T> =
-  P extends Parser<infer U> ? (U extends T ? P : never) : never
-
-export const parsers = [
-  {
-    name: 'json',
-    test: (mime): mime is `application/json` | `application/${string}+json` => {
-      return /^application\/(?:.+\+)?json$/.test(mime)
-    },
-    parse: (buffer, { charset }): Json => {
-      if (charset != null && !/^utf-?8$/i.test(charset)) {
-        throw createHttpError(415, 'Unsupported charset')
-      }
-      try {
-        return parseJson(buffer.toString())
-      } catch (err) {
-        throw createHttpError(400, 'Invalid JSON', { cause: err })
-      }
-    },
-  },
-  {
-    name: 'urlencoded',
-    test: (mime): mime is 'application/x-www-form-urlencoded' => {
-      return mime === 'application/x-www-form-urlencoded'
-    },
-    parse: (buffer, { charset }): { [_ in string]?: string } => {
-      if (charset != null && !/^utf-?8$/i.test(charset)) {
-        throw createHttpError(415, 'Unsupported charset')
-      }
-      try {
-        if (!buffer.length) return {}
-        const params = new URLSearchParams(buffer.toString())
-        if (params.has('__proto__')) throw new TypeError('Invalid key')
-        return Object.fromEntries(params)
-      } catch (err) {
-        throw createHttpError(400, 'Invalid URL-encoded data', { cause: err })
-      }
-    },
-  },
-  {
-    name: 'bytes',
-    test: (mime): mime is 'application/octet-stream' => {
-      return mime === 'application/octet-stream'
-    },
-    parse: (buffer): Buffer => buffer,
-  },
-] as const satisfies Parser[]
-
-export type KnownParser = (typeof parsers)[number]
-
-export type KnownNames = KnownParser['name']
-export type KnownTypes = ParserType<KnownParser>

package/src/lib/http/path.ts

@@ -1,82 +0,0 @@
-export type PathMatcher<P extends Params> = (pathname: string) => P | undefined
-
-type StringPath<P extends Params> = string extends keyof P
-  ? `/${string}`
-  : keyof P extends never
-    ? `/${string}` | ``
-    : {
-        [K in keyof P]: K extends string
-          ?
-              | `${`/:${K}` | `/${string}/:${K}`}${StringPath<Omit<P, K>>}`
-              | `${StringPath<Omit<P, K>>}${`/:${K}` | `/:${K}/${string}`}`
-          : never
-      }[keyof P]
-
-export type Path<P extends Params> =
-  | string
-  | StringPath<P>
-  | RegExp
-  | PathMatcher<P>
-export type Params = Record<string, undefined | string>
-
-export function createPathMatcher<P extends Params = Params>(
-  refPath: Path<P>,
-): PathMatcher<P> {
-  if (typeof refPath === 'string') {
-    // Create a path matcher for a path with parameters (like /foo/:fooId/bar/:barId).
-    if (refPath.includes('/:')) {
-      const refParts = refPath
-        .slice(1)
-        .split('/')
-        .map((part, i) => [part, i] as const)
-      const refPartsLength = refParts.length
-
-      const staticParts = refParts.filter(([p]) => !p.startsWith(':'))
-      const paramParts = refParts
-        // Extract parameters, ignoring those with no name (like /foo/:/bar).
-        .filter(([p]) => p.startsWith(':') && p.length > 1)
-        .map(([p, i]) => [p.slice(1), i] as const)
-
-      return (reqPath: string) => {
-        const reqParts = reqPath.slice(1).split('/')
-
-        if (reqParts.length !== refPartsLength) return undefined
-
-        // Make sure all static parts match.
-        for (let i = 0; i < staticParts.length; i++) {
-          const value = staticParts[i]![0]
-          const idx = staticParts[i]![1]
-
-          if (value !== reqParts[idx]) return undefined
-        }
-
-        // Then extract the parameters.
-        const params: Record<string, string> = {}
-        for (let i = 0; i < paramParts.length; i++) {
-          const name = paramParts[i]![0]
-          const idx = paramParts[i]![1]
-
-          const value = reqParts[idx]
-
-          // Empty parameter values are not allowed.
-          if (!value) return undefined
-
-          params[name] = value
-        }
-
-        return params as P
-      }
-    }
-
-    return (reqPath: string) => (reqPath === refPath ? ({} as P) : undefined)
-  }
-
-  if (refPath instanceof RegExp) {
-    return (reqPath: string) => {
-      const match = reqPath.match(refPath)
-      return match ? ((match.groups || {}) as P) : undefined
-    }
-  }
-
-  return refPath
-}