@atproto/oauth-provider 0.19.6 → 0.19.8

package/src/lib/hcaptcha.ts

@@ -1,228 +0,0 @@
-import { createHash } from 'node:crypto'
-import { z } from 'zod'
-import {
-  Fetch,
-  FetchBound,
-  bindFetch,
-  fetchJsonProcessor,
-  fetchJsonZodProcessor,
-  fetchOkProcessor,
-} from '@atproto-labs/fetch'
-import { pipe } from '@atproto-labs/pipe'
-
-export const hcaptchaTokenSchema = z.string().min(1)
-export type HcaptchaToken = z.infer<typeof hcaptchaTokenSchema>
-
-export const hcaptchaConfigSchema = z.object({
-  /**
-   * The hCaptcha site key to use for the sign-up form.
-   */
-  siteKey: z.string().min(1),
-  /**
-   * The hCaptcha secret key to use for the sign-up form.
-   */
-  secretKey: z.string().min(1),
-  /**
-   * A salt to use when hashing client tokens.
-   */
-  tokenSalt: z.string().min(1),
-  /**
-   * The risk score above which the user is considered a threat and will be
-   * denied access. This will be ignored if the enterprise features are not
-   * available.
-   *
-   * Note: Score values ranges from 0.0 (no risk) to 1.0 (confirmed threat).
-   */
-  scoreThreshold: z.number().optional(),
-})
-export type HcaptchaConfig = z.infer<typeof hcaptchaConfigSchema>
-
-/**
- * @see {@link https://docs.hcaptcha.com/#verify-the-user-response-server-side hCaptcha API}
- */
-export const hcaptchaVerifyResultSchema = z.object({
-  /**
-   * is the passcode valid, and does it meet security criteria you specified, e.g. sitekey?
-   */
-  success: z.boolean(),
-  /**
-   * timestamp of the challenge (ISO format yyyy-MM-dd'T'HH:mm:ssZZ)
-   */
-  challenge_ts: z.string(),
-  /**
-   * the hostname of the site where the challenge was passed
-   */
-  hostname: z.string().nullable(),
-  /**
-   * optional: any error codes returned by the hCaptcha API.
-   * @see {@link https://docs.hcaptcha.com/#siteverify-error-codes-table}
-   */
-  'error-codes': z.array(z.string()).optional(),
-  /**
-   * ENTERPRISE feature: a score denoting malicious activity. Value ranges from
-   * 0.0 (no risk) to 1.0 (confirmed threat).
-   */
-  score: z.number().optional(),
-  /**
-   * ENTERPRISE feature: reason(s) for score.
-   */
-  score_reason: z.array(z.string()).optional(),
-  /**
-   * sitekey of the request
-   */
-  sitekey: z.string().optional(),
-  /**
-   * obj of form: {'ip_device': 1, .. etc}
-   */
-  behavior_counts: z.record(z.unknown()).optional(),
-  /**
-   * how similar is this? (0.0 - 1.0, -1 on err)
-   */
-  similarity: z.number().optional(),
-  /**
-   * count of similar_tokens not processed
-   */
-  similarity_failures: z.number().optional(),
-  /**
-   * array of strings for any similarity errors
-   */
-  similarity_error_details: z.array(z.string()).optional(),
-  /**
-   * encoded clientID
-   */
-  scoped_uid_0: z.string().optional(),
-  /**
-   * encoded IP
-   */
-  scoped_uid_1: z.string().optional(),
-  /**
-   * encoded IP (APT)
-   */
-  scoped_uid_2: z.string().optional(),
-  /**
-   * Risk Insights (APT + RI)
-   */
-  risk_insights: z.record(z.unknown()).optional(),
-  /**
-   * Advanced Threat Signatures (APT)
-   */
-  sigs: z.record(z.unknown()).optional(),
-  /**
-   * tags added via Rules
-   */
-  tags: z.array(z.string()).optional(),
-})
-
-export type HcaptchaVerifyResult = z.infer<typeof hcaptchaVerifyResultSchema>
-
-export type HcaptchaClientTokens = {
-  hashedIp: string
-  hashedHandle: string
-  hashedUserAgent?: string
-}
-
-const fetchSuccessHandler = pipe(
-  fetchOkProcessor(),
-  fetchJsonProcessor(),
-  fetchJsonZodProcessor(hcaptchaVerifyResultSchema),
-)
-
-export class HCaptchaClient {
-  protected readonly fetch: FetchBound
-  constructor(
-    readonly hostname: string,
-    readonly config: HcaptchaConfig,
-    fetch: Fetch = globalThis.fetch,
-  ) {
-    this.fetch = bindFetch(fetch)
-  }
-
-  public async verify(
-    behaviorType: 'login' | 'signup',
-    response: string,
-    remoteip: string,
-    clientTokens: HcaptchaClientTokens,
-  ) {
-    return this.fetch('https://api.hcaptcha.com/siteverify', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: new URLSearchParams({
-        secret: this.config.secretKey,
-        sitekey: this.config.siteKey,
-        behavior_type: behaviorType,
-        response,
-        remoteip,
-        client_tokens: JSON.stringify(clientTokens),
-      }).toString(),
-    }).then(fetchSuccessHandler)
-  }
-
-  public checkVerifyResult(
-    result: HcaptchaVerifyResult,
-    tokens: HcaptchaClientTokens,
-  ): void {
-    const { success, score } = result
-
-    if (success !== true) {
-      throw new HCaptchaVerifyError(
-        result,
-        tokens,
-        'Expected success to be true',
-      )
-    }
-
-    // https://docs.hcaptcha.com/#verify-the-user-response-server-side
-
-    // Please [...] note that the hostname field is derived from the user's
-    // browser, and should not be used for authentication of any kind; it is
-    // primarily useful as a statistical metric. Additionally, in the event that
-    // your site experiences unusually high challenge traffic, the hostname
-    // field may be returned as "not-provided" rather than the usual value; all
-    // other fields will return their normal values.
-
-    if (
-      // Ignore if enterprise feature is not enabled
-      score != null &&
-      // Ignore if disabled through config
-      this.config.scoreThreshold != null &&
-      score >= this.config.scoreThreshold
-    ) {
-      throw new HCaptchaVerifyError(
-        result,
-        tokens,
-        `Score ${score} is above the threshold ${this.config.scoreThreshold}`,
-      )
-    }
-  }
-
-  public buildClientTokens(
-    remoteip: string,
-    handle: string,
-    userAgent?: string,
-  ): HcaptchaClientTokens {
-    return {
-      hashedIp: this.hashToken(remoteip),
-      hashedHandle: this.hashToken(handle),
-      hashedUserAgent: userAgent ? this.hashToken(userAgent) : undefined,
-    }
-  }
-
-  protected hashToken(value: string) {
-    const hash = createHash('sha256')
-    hash.update(this.config.tokenSalt)
-    hash.update(value)
-    return hash.digest().toString('base64')
-  }
-}
-
-export class HCaptchaVerifyError extends Error {
-  constructor(
-    readonly result: HcaptchaVerifyResult,
-    readonly tokens: HcaptchaClientTokens,
-    message?: string,
-  ) {
-    super(message)
-  }
-}

package/src/lib/html/README.md

@@ -1,9 +0,0 @@
-# Safe HTML generation and concatenation utility
-
-This library provides a safe way to generate and concatenate HTML strings.
-
-This code _could_ be used as a standalone library, but the Bluesky dev team does
-not want to maintain it as such. As it is currently only used by the
-`@atproto/oauth-provider` package, it is included here. Future development
-should aim to keep this library independent of the rest of the
-`@atproto/oauth-provider` package, so that it can be extracted and published.

package/src/lib/html/build-document.ts

@@ -1,151 +0,0 @@
-import { HtmlValue } from './escapers.js'
-import { Html } from './html.js'
-import { html } from './tags.js'
-
-export type AssetRef = {
-  url: string
-}
-
-export type Attrs = Record<string, boolean | string | undefined>
-
-/**
- * @see {@link https://developer.mozilla.org/fr/docs/Web/HTML/Attributes/rel}
- */
-const ALLOWED_LINK_REL_VALUES = Object.freeze([
-  'alternate',
-  'author',
-  'canonical',
-  'dns-prefetch',
-  'external',
-  'expect',
-  'help',
-  'icon',
-  'license',
-  'manifest',
-  'me',
-  'modulepreload',
-  'next',
-  'pingback',
-  'preconnect',
-  'prefetch',
-  'preload',
-  'prerender',
-  'prev',
-  'privacy-policy',
-  'search',
-  'stylesheet',
-  'terms-of-service',
-] as const)
-export type LinkRel = (typeof ALLOWED_LINK_REL_VALUES)[number]
-export const isLinkRel = (rel: unknown): rel is LinkRel =>
-  (ALLOWED_LINK_REL_VALUES as readonly unknown[]).includes(rel)
-
-export type LinkAttrs = Attrs & {
-  href: string
-  rel: LinkRel
-}
-export type MetaAttrs =
-  | { name: string; content: string }
-  | { 'http-equiv': string; content: string }
-
-const defaultViewport = html`<meta
-  name="viewport"
-  content="width=device-width, initial-scale=1.0"
-/>`
-
-export type BuildDocumentOptions = {
-  htmlAttrs?: Attrs
-  base?: URL
-  meta?: readonly MetaAttrs[]
-  links?: readonly LinkAttrs[]
-  preloads?: readonly AssetRef[]
-  head?: HtmlValue
-  title?: HtmlValue
-  scripts?: readonly (Html | AssetRef | undefined)[]
-  styles?: readonly (Html | AssetRef | undefined)[]
-  body?: HtmlValue
-  bodyAttrs?: Attrs
-}
-
-export const buildDocument = ({
-  htmlAttrs,
-  head,
-  title,
-  body,
-  bodyAttrs,
-  base,
-  meta,
-  links,
-  preloads,
-  scripts,
-  styles,
-}: BuildDocumentOptions) => html`<!doctype html>
-<html${attrsToHtml(htmlAttrs)}>
-  <head>
-    <meta charset="UTF-8" />
-    ${title && html`<title>${title}</title>`}
-    ${base && html`<base href="${base.href}" />`}
-    ${meta?.some(isViewportMeta) ? null : defaultViewport}
-    ${meta?.map(metaToHtml)}
-    ${preloads?.map(linkPreload)}
-    ${links?.map(linkToHtml)}
-    ${head}
-    ${styles?.map(styleToHtml)}
-  </head>
-  <body${attrsToHtml(bodyAttrs)}>${body}${scripts?.map(scriptToHtml)}</body>
-</html>`
-
-function isViewportMeta<T extends MetaAttrs>(
-  attrs: T,
-): attrs is T & { name: 'viewport' } {
-  return 'name' in attrs && attrs.name === 'viewport'
-}
-
-function linkToHtml(attrs: LinkAttrs) {
-  return html`<link${attrsToHtml(attrs)} />`
-}
-
-function metaToHtml(attrs: MetaAttrs) {
-  return html`<meta${attrsToHtml(attrs)} />`
-}
-
-function* attrsToHtml(attrs?: Attrs) {
-  if (attrs) {
-    for (const [name, value] of Object.entries(attrs)) {
-      if (value == null) continue
-      else if (value === false) continue
-      else if (value === true) yield html` ${name}`
-      else yield html` ${name}="${value}"`
-    }
-  }
-}
-
-function linkPreload(asset: AssetRef) {
-  const [path] = asset.url.split('?', 2)
-
-  if (path.endsWith('.js')) {
-    return html`<link rel="modulepreload" href="${asset.url}" />`
-  }
-
-  if (path.endsWith('.css')) {
-    return html`<link rel="preload" href="${asset.url}" as="style" />`
-  }
-
-  return undefined
-}
-
-function scriptToHtml(script?: Html | AssetRef): Html | undefined {
-  if (script == null) return undefined
-  return script instanceof Html
-    ? // prettier-ignore
-      html`<script>${script}</script>` // hash validity requires no space around the content
-    : html`<script type="module" src="${script.url}"></script>`
-}
-
-function styleToHtml(style?: Html | AssetRef): Html | undefined {
-  if (style == null) return undefined
-  return style instanceof Html
-    ? // prettier-ignore
-      html`<style>${style}</style>` // hash validity requires no space around the content
-    : html`<link rel="stylesheet" href="${style.url}" />`
-}

package/src/lib/html/escapers.ts

@@ -1,66 +0,0 @@
-import { Html } from './html.js'
-import { NestedIterable, stringReplacer } from './util.js'
-
-export function* javascriptEscaper(code: string) {
-  // "</script>" can only appear in javascript strings, so we can safely escape
-  // the "<" without breaking the javascript.
-  yield* stringReplacer(code, '</script>', '\\u003c/script>')
-}
-
-export function* jsonEscaper(value: unknown) {
-  // https://redux.js.org/usage/server-rendering#security-considerations
-  const json = JSON.stringify(value)
-  if (json === undefined) throw new TypeError('Cannot serialize to JSON')
-  // "<" can only appear in JSON strings, so we can safely escape it without
-  // breaking the JSON.
-  yield* stringReplacer(json, '<', '\\u003c')
-}
-
-export function* cssEscaper(css: string) {
-  yield* stringReplacer(css, '</style>', '\\u003c/style>')
-}
-
-export type HtmlVariable = Html | string | number | null | undefined
-export type HtmlValue = NestedIterable<HtmlVariable>
-
-export function* htmlEscaper(
-  htmlFragments: TemplateStringsArray,
-  values: readonly HtmlValue[],
-): Generator<string | Html, void, undefined> {
-  for (let i = 0; i < htmlFragments.length; i++) {
-    yield htmlFragments[i]!
-
-    const value = values[i]
-    if (value != null) yield* htmlVariableToFragments(value)
-  }
-}
-
-function* htmlVariableToFragments(
-  value: HtmlValue,
-): Generator<string | Html, void, undefined> {
-  if (value == null) {
-    return
-  } else if (typeof value === 'number') {
-    yield String(value)
-  } else if (typeof value === 'string') {
-    yield encode(value)
-  } else if (value instanceof Html) {
-    yield value
-  } else {
-    // Will throw if the value is not an iterable
-    for (const v of value) yield* htmlVariableToFragments(v)
-  }
-}
-
-const specialCharRegExp = /[<>"'&]/g
-const specialCharMap = new Map([
-  ['<', '&lt;'],
-  ['>', '&gt;'],
-  ['"', '&quot;'],
-  ["'", '&apos;'],
-  ['&', '&amp;'],
-])
-const specialCharMapGet = (c: string) => specialCharMap.get(c)!
-function encode(value: string): string {
-  return value.replace(specialCharRegExp, specialCharMapGet)
-}

package/src/lib/html/html.ts

@@ -1,56 +0,0 @@
-const symbol = Symbol('Html.dangerouslyCreate')
-
-/**
- * This class represents trusted HTML that can be safely embedded in a web page,
- * or used as fragments to build a larger HTML document.
- */
-export class Html implements Iterable<string> {
-  readonly #fragments: readonly (Html | string)[]
-
-  private constructor(fragments: Iterable<Html | string>, guard: symbol) {
-    if (guard !== symbol) {
-      // Forces developers to use `Html.dangerouslyCreate` to create an Html
-      // instance, to make it clear that the content needs to be trusted.
-      throw new TypeError(
-        'Use Html.dangerouslyCreate() to create an Html instance',
-      )
-    }
-
-    // Transform into an array in case iterable can be consumed only once
-    // (e.g. a generator function).
-    this.#fragments = Array.from(fragments)
-  }
-
-  toString(): string {
-    // More efficient than `return this.#fragments.join('')` because it avoids
-    // creating intermediate strings when items of this.#fragments are Html
-    // instances (as all their toString() would end-up being called, creating
-    // lots of intermediary strings). The approach here allows to do a full scan
-    // of all the child nodes and concatenate them in a single pass.
-    return Array.from(this).join('')
-  }
-
-  [Symbol.toPrimitive](hint): string {
-    switch (hint) {
-      case 'string':
-      case 'default':
-        return this.toString()
-      default:
-        throw new TypeError(`Cannot convert Html to a ${hint}`)
-    }
-  }
-
-  *[Symbol.iterator](): IterableIterator<string> {
-    for (const fragment of this.#fragments) {
-      if (typeof fragment === 'string') {
-        yield fragment
-      } else {
-        yield* fragment
-      }
-    }
-  }
-
-  static dangerouslyCreate(fragments: Iterable<Html | string>): Html {
-    return new Html(fragments, symbol)
-  }
-}

package/src/lib/html/hydration-data.ts

@@ -1,19 +0,0 @@
-import { Html, js } from './index.js'
-
-export function declareHydrationData<T extends Record<string, unknown>>(
-  values: T,
-): Html {
-  return Html.dangerouslyCreate(hydrationDataGenerator(values))
-}
-
-export function* hydrationDataGenerator(
-  values: Record<string, unknown>,
-): Generator<Html> {
-  for (const [key, val] of Object.entries(values)) {
-    yield js`window[${key}]=JSON.parse(${JSON.stringify(val)});`
-  }
-  // The script tag is removed after the data is assigned to the global
-  // variables to prevent other scripts from reading the values. The "app"
-  // script will read the global variable and then unset it.
-  yield js`document.currentScript.remove();`
-}

package/src/lib/html/index.ts

@@ -1,5 +0,0 @@
-export * from './html.js'
-export * from './tags.js'
-
-// Extra util
-export * from './build-document.js'

package/src/lib/html/tags.ts

@@ -1,67 +0,0 @@
-import {
-  HtmlValue,
-  cssEscaper,
-  htmlEscaper,
-  javascriptEscaper,
-  jsonEscaper,
-} from './escapers.js'
-import { Html } from './html.js'
-
-export { type HtmlValue }
-export const html = (
-  tpl: TemplateStringsArray,
-  ...val: readonly HtmlValue[]
-) =>
-  tpl.length === 1 && val.length === 0
-    ? // Optimization for static HTML, avoid creating an iterable
-      Html.dangerouslyCreate(tpl)
-    : Html.dangerouslyCreate(htmlEscaper(tpl, val))
-
-/**
- * Escapes code to use as a JavaScript string inside a `<script>` tag.
- */
-export const javascriptCode = (code: string) =>
-  Html.dangerouslyCreate(javascriptEscaper(code))
-
-/**
- * Creates an HTML safe JavaScript code block, with JSON serialization of the
- * injected variables.
- *
- * @example
- * ```js
- * const dataOnTheServer = { foo: 'bar' };
- * const clientScript = js`
- *   const data = ${dataOnTheServer};
- *   console.log(data);
- * `
- * console.log(clientScript.toString()); // Output: 'const data = {"foo":"bar"};console.log(data);'
- * ```
- */
-export const js = (tpl: TemplateStringsArray, ...val: readonly unknown[]) =>
-  tpl.length === 1 && val.length === 0
-    ? // Optimization for static JavaScript, avoid un-necessary serialization
-      javascriptCode(tpl[0])
-    : javascriptCode(String.raw({ raw: tpl }, ...val.map(jsonCode)))
-
-/**
- * Escapes a value to be used as a JSON string inside a `<script>` tag.
- *
- * @see {@link https://redux.js.org/usage/server-rendering#security-considerations}
- */
-export const jsonCode = (value: unknown) =>
-  Html.dangerouslyCreate(jsonEscaper(value))
-
-/**
- * Creates an HTML safe CSS code block.
- */
-export const css = (tpl: TemplateStringsArray, ...val: readonly number[]) =>
-  tpl.length === 1 && val.length === 0
-    ? // Optimization for static CSS, avoid creating an iterable
-      cssCode(tpl[0])
-    : cssCode(String.raw({ raw: tpl }, ...val.map(jsonEscaper)))
-
-/**
- * Escapes a value to be uses as CSS styles inside a `<style>` tag.
- */
-export const cssCode = (code?: string) =>
-  code ? Html.dangerouslyCreate(cssEscaper(code)) : undefined

package/src/lib/html/util.ts

@@ -1,17 +0,0 @@
-export type NestedIterable<V> = V | Iterable<NestedIterable<V>>
-
-export function* stringReplacer(
-  source: string,
-  searchValue: string,
-  replaceValue: string,
-): Generator<string, void, undefined> {
-  let previousIndex = 0
-  let index = source.indexOf(searchValue)
-  while (index !== -1) {
-    yield source.slice(previousIndex, index)
-    yield replaceValue
-    previousIndex = index + searchValue.length
-    index = source.indexOf(searchValue, previousIndex)
-  }
-  yield source.slice(previousIndex)
-}

package/src/lib/http/README.md

@@ -1,11 +0,0 @@
-# utilities for generating middlewares to work with Node's http module or Express / Connect frameworks
-
-This library uses a functional programming style to generate middleware
-functions that can be used with Node's http module or Express / Connect
-frameworks.
-
-This code _could_ be used as a standalone library, but the Bluesky dev team does
-not want to maintain it as such. As it is currently only used by the
-`@atproto/oauth-provider` package, it is included here. Future development
-should aim to keep this library independent of the rest of the
-`@atproto/oauth-provider` package, so that it can be extracted and published.