@elmohq/sdk 0.0.0-stage → 0.1.1

package/src/internal/feature/auth.ts

@@ -0,0 +1,201 @@
+import { MissingCredentialError, unsendable } from '../core/errors';
+import { isFieldValue } from '../core/metadata';
+import type {
+  AuthRequirement,
+  AuthScheme,
+  AuthToken,
+  Credential,
+  CredentialSpec,
+  CredentialValue,
+  Feature,
+  PlacedCredential,
+  PreparedRequest,
+  ResolvedOptions,
+} from '../core/types';
+
+export interface AuthOptions {
+  readonly schemes?: Readonly<Record<string, CredentialSpec>>;
+}
+
+export function schemesOf(requirement: AuthRequirement): ReadonlyArray<AuthScheme> {
+  return Array.isArray(requirement) ? requirement : [requirement as AuthScheme];
+}
+
+export function candidates(
+  requirements: ReadonlyArray<AuthRequirement>,
+  ..._environment: ReadonlyArray<unknown>
+): ReadonlyArray<ReadonlyArray<AuthScheme>> {
+  return requirements.map(schemesOf);
+}
+
+type Ask = (scheme: AuthScheme) => Promise<AuthToken>;
+
+function formatBearer(token: string): string {
+  return `Bearer ${token}`;
+}
+
+const SCHEME_FORMATS: Partial<
+  Readonly<Record<NonNullable<AuthScheme['scheme']>, (token: string) => string>>
+> = { bearer: formatBearer };
+
+export function formatToken(scheme: AuthScheme, token: AuthToken, prefix?: string): AuthToken {
+  if (!token) return undefined;
+  if (prefix !== undefined) return `${prefix}${token}`;
+  const format = scheme.scheme ? SCHEME_FORMATS[scheme.scheme] : undefined;
+  return format ? format(token) : token;
+}
+
+function labeled(key: string, options: AuthOptions | undefined): string {
+  const variable = options?.schemes?.[key]?.variable;
+  return variable ? `\`${key}\` (\`${variable}\`)` : `\`${key}\``;
+}
+
+export function credentialFor(
+  scheme: AuthScheme,
+  token: AuthToken,
+  options: AuthOptions | undefined,
+): Credential | undefined {
+  const prefix = scheme.key ? options?.schemes?.[scheme.key]?.prefix : undefined;
+  const value = formatToken(scheme, token?.trim(), prefix);
+  if (!value) return undefined;
+  const credential: Credential = {
+    in: scheme.in ?? 'header',
+    name: scheme.name ?? 'Authorization',
+    value,
+  };
+  if (credential.in !== 'query' && !isFieldValue(value)) {
+    const held = scheme.key
+      ? labeled(scheme.key, options)
+      : `The credential \`auth\` returned for \`${credential.name}\``;
+    throw new MissingCredentialError(unsendable(held), scheme.key ? [scheme.key] : []);
+  }
+  return credential;
+}
+
+async function credentialsFor(
+  schemes: ReadonlyArray<AuthScheme>,
+  ask: Ask,
+  options: AuthOptions | undefined,
+): Promise<ReadonlyArray<PlacedCredential> | undefined> {
+  const placed: Array<PlacedCredential> = [];
+  for (const scheme of schemes) {
+    const credential = credentialFor(scheme, await ask(scheme), options);
+    if (!credential) return undefined;
+    placed.push({ credential, scheme });
+  }
+  return placed;
+}
+
+function keysOf(open: ReadonlyArray<ReadonlyArray<string>>): ReadonlyArray<string> {
+  return [...new Set(open.flat())];
+}
+
+function conjoined(keys: ReadonlyArray<string>, options: AuthOptions | undefined): string {
+  return keys.map((key) => labeled(key, options)).join(' and ');
+}
+
+function either(alternatives: ReadonlyArray<string>): string {
+  if (alternatives.length <= 2) return alternatives.join(' or ');
+  return `${alternatives.slice(0, -1).join(', ')}, or ${alternatives.at(-1)}`;
+}
+
+function advice(
+  open: ReadonlyArray<ReadonlyArray<string>>,
+  options: AuthOptions | undefined,
+): string {
+  if (!open.length) return '';
+  const alternatives = open.map((keys) => conjoined(keys, options));
+  if (alternatives.length > 1 && open.some((keys) => keys.length > 1)) {
+    return ` Either ${alternatives.map((one) => `set ${one}`).join(', or ')}.`;
+  }
+  return ` Set ${either(alternatives)}.`;
+}
+
+function missing(
+  open: ReadonlyArray<ReadonlyArray<string>>,
+  options: AuthOptions | undefined,
+): string {
+  return `This call needs a credential that was not set.${advice(open, options)}`;
+}
+
+function offered(
+  alternatives: ReadonlyArray<ReadonlyArray<AuthScheme>>,
+): ReadonlyArray<ReadonlyArray<string>> {
+  return alternatives
+    .map((schemes) =>
+      schemes.map((scheme) => scheme.key).filter((key): key is string => key !== undefined),
+    )
+    .filter((keys) => keys.length > 0);
+}
+
+export function refuseRuledOut(..._ruling: ReadonlyArray<unknown>): void {}
+
+export async function tokenFor(
+  scheme: AuthScheme,
+  held: ResolvedOptions,
+  options: AuthOptions | undefined,
+): Promise<AuthToken> {
+  const own = scheme.key !== undefined && options?.schemes?.[scheme.key]?.option !== false;
+  const stated = own ? (held[scheme.key!] as CredentialValue) : undefined;
+  const value = typeof stated === 'function' ? await stated() : stated;
+  return typeof held.auth === 'function' ? held.auth(scheme, value) : value;
+}
+
+function unauthenticated(
+  open: ReadonlyArray<ReadonlyArray<string>>,
+  options: AuthOptions | undefined,
+): string {
+  return `This call was sent with no credential.${advice(open, options)}`;
+}
+
+function writtenByHand(scheme: AuthScheme, request: PreparedRequest): boolean {
+  return (
+    (scheme.in ?? 'header') === 'header' &&
+    request.meta[(scheme.name ?? 'Authorization').toLowerCase()] !== undefined
+  );
+}
+
+export function authFeature(options?: AuthOptions): Feature {
+  return {
+    name: 'auth',
+    async onPrepare(request, ctx) {
+      const declared = request.callable.auth;
+      if (!declared?.length) return;
+
+      const { auth, environment } = request.options;
+      const alternatives = candidates(declared, environment, options).map((schemes) =>
+        schemes.filter((scheme) => !writtenByHand(scheme, request)),
+      );
+      const asked = new Map<unknown, Promise<AuthToken>>();
+
+      function ask(scheme: AuthScheme): Promise<AuthToken> {
+        const key = scheme.key ?? scheme;
+        let token = asked.get(key);
+        if (!token) {
+          token = tokenFor(scheme, request.options, options);
+          asked.set(key, token);
+        }
+        return token;
+      }
+
+      if (auth !== null) {
+        for (const schemes of alternatives) {
+          const placed = await credentialsFor(schemes, ask, options);
+          if (!placed) continue;
+          for (const { credential } of placed) ctx.binding.applyAuth(credential, request);
+          request.placed = placed;
+          return;
+        }
+        await refuseRuledOut(declared, alternatives, ask, environment, options);
+      }
+
+      const all = offered(declared.map(schemesOf));
+      if (auth === null || request.callable.authOptional) {
+        request.unauthenticated = () => unauthenticated(all, options);
+        return;
+      }
+
+      throw new MissingCredentialError(missing(all, options), keysOf(all));
+    },
+  };
+}

package/src/internal/feature/interceptors.ts

@@ -0,0 +1,36 @@
+import type { Feature, PreparedRequest, Result } from '../core/types';
+
+/** Hooks of your own, run in order at three points in every call. */
+export interface Interceptors {
+  /** Runs when a call fails. Return the error to raise, which may be another. */
+  error?: ReadonlyArray<(error: unknown, request: PreparedRequest) => unknown>;
+  /** Runs on the built request, last before it is sent. */
+  request?: ReadonlyArray<(request: PreparedRequest) => Promise<void> | void>;
+  /** Runs on the reply. Return the result to read, which may be another. */
+  response?: ReadonlyArray<(result: Result, request: PreparedRequest) => Promise<Result> | Result>;
+}
+
+function interceptorsOf(request: PreparedRequest): Interceptors | undefined {
+  return request.options['interceptors'] as Interceptors | undefined;
+}
+
+export function interceptorsFeature(): Feature {
+  return {
+    name: 'interceptors',
+    async onError(error, request) {
+      let current = error;
+      for (const fn of interceptorsOf(request)?.error ?? []) current = await fn(current, request);
+      return current;
+    },
+    async onRequest(request) {
+      for (const fn of interceptorsOf(request)?.request ?? []) await fn(request);
+    },
+    async onResult(result, request) {
+      let current = result;
+      for (const fn of interceptorsOf(request)?.response ?? []) {
+        current = await fn(current, request);
+      }
+      return current;
+    },
+  };
+}

package/src/internal/feature/logger.ts

@@ -0,0 +1,222 @@
+import { safeAddress } from '../core/errors';
+import type {
+  AuthScheme,
+  CallableDescriptor,
+  CallLog,
+  Feature,
+  PreparedRequest,
+  Result,
+  Send,
+} from '../core/types';
+
+/** One method of a {@link Logger}: a message, then the values logged with it. */
+export type LogFn = (message: string, ...rest: ReadonlyArray<unknown>) => void;
+
+/** Where log lines go, such as `console`. */
+export interface Logger {
+  debug: LogFn;
+  error: LogFn;
+  info: LogFn;
+  warn: LogFn;
+}
+
+/**
+ * How much a client logs. `'error'` writes failed calls. `'warn'` adds a retry
+ * or a redirect. `'info'` adds a line per attempt, with its status and time.
+ * `'debug'` adds headers, with credentials hidden.
+ */
+export type LogLevel = 'debug' | 'error' | 'info' | 'off' | 'warn';
+
+const LEVELS: Readonly<Record<LogLevel, number>> = {
+  debug: 40,
+  error: 10,
+  info: 30,
+  off: 0,
+  warn: 20,
+};
+
+export interface LoggerOptions {
+  level?: LogLevel;
+  logger?: Logger;
+}
+
+function describeCall(request: PreparedRequest): string {
+  const method = request.callable.method?.toUpperCase();
+  const address = typeof request.address === 'string' ? safeAddress(request.address) : '';
+  return method ? `${method} ${address}` : address;
+}
+
+const ADDRESS_RE = /\b[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/gi;
+
+export function failureText(error: unknown): string {
+  const messages: Array<string> = [];
+  const seen = new Set<unknown>();
+  let current = error;
+  while (current !== undefined && current !== null && !seen.has(current)) {
+    seen.add(current);
+    const failed = current instanceof Error;
+    messages.push(failed ? (current as Error).message : String(current));
+    current = failed ? (current as Error).cause : undefined;
+  }
+  return messages.join(' Caused by: ').replace(ADDRESS_RE, safeAddress);
+}
+
+function declaredHeaders(callable: CallableDescriptor): Set<string> {
+  const names = new Set<string>();
+  for (const requirement of callable.auth ?? []) {
+    for (const scheme of Array.isArray(requirement) ? requirement : [requirement as AuthScheme]) {
+      if (scheme.in === 'header' && scheme.name) names.add(scheme.name.toLowerCase());
+    }
+  }
+  return names;
+}
+
+const SECRET_HEADERS: ReadonlyArray<string> = [
+  'authorization',
+  'cookie',
+  'proxy-authorization',
+  'set-cookie',
+];
+
+function isSecret(name: string, declared: ReadonlySet<string>): boolean {
+  const lower = name.toLowerCase();
+  return (
+    SECRET_HEADERS.includes(lower) ||
+    declared.has(lower) ||
+    lower.endsWith('-key') ||
+    lower.endsWith('-token') ||
+    lower.endsWith('-secret')
+  );
+}
+
+export function safeHeaders(
+  meta: Readonly<Record<string, unknown>>,
+  callable: CallableDescriptor,
+): Record<string, unknown> {
+  const declared = declaredHeaders(callable);
+  const safe: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(meta)) {
+    safe[name] = isSecret(name, declared) ? '***' : value;
+  }
+  return safe;
+}
+
+function callLog(id: string, request: PreparedRequest, at: number, sink: Logger): CallLog {
+  const label = describeCall(request);
+  let started = Date.now();
+  function line(text: string): string {
+    return `[${id}] ${label} ${text}`;
+  }
+
+  return {
+    ended(error) {
+      const ms = Date.now() - started;
+      if (error !== undefined) {
+        if (at >= LEVELS.error) {
+          sink.error(line(`stream failed after ${ms} ms: ${failureText(error)}`));
+        }
+      } else if (at >= LEVELS.info) {
+        sink.info(line(`stream ended after ${ms} ms`));
+      }
+    },
+    failed(error) {
+      if (at >= LEVELS.error) sink.error(line(`failed: ${failureText(error)}`));
+    },
+    replied(response) {
+      const ms = Date.now() - started;
+      if (response?.redirected && at >= LEVELS.warn) {
+        sink.warn(line(`was redirected to ${safeAddress(response.url)}`));
+      }
+      if (at >= LEVELS.info) sink.info(line(`-> ${response?.status ?? '?'} in ${ms} ms`));
+      if (at >= LEVELS.debug) {
+        sink.debug(`[${id}] received`, {
+          headers: safeHeaders(Object.fromEntries(response?.headers ?? []), request.callable),
+          ms,
+          status: response?.status,
+        });
+      }
+    },
+    retrying(wait, retry, retries, after) {
+      if (at < LEVELS.warn) return;
+      const again = `retrying in ${Math.round(wait)} ms (${retry} of ${retries})`;
+      if (after?.status !== undefined) {
+        sink.warn(line(`-> ${after.status}, ${again}`));
+      } else if (after?.error !== undefined) {
+        sink.warn(line(`failed: ${failureText(after.error)}, ${again}`));
+      } else {
+        sink.warn(line(again));
+      }
+    },
+    sending() {
+      started = Date.now();
+      if (at >= LEVELS.info) sink.info(`[${id}] ${label}`);
+      if (at >= LEVELS.debug)
+        sink.debug(`[${id}] sending`, { headers: safeHeaders(request.meta, request.callable) });
+    },
+  };
+}
+
+export function readLevel(named: string): LogLevel | undefined {
+  const spelled = named.toLowerCase();
+  if (spelled === 'warning') return 'warn';
+  return Object.prototype.hasOwnProperty.call(LEVELS, spelled) ? (spelled as LogLevel) : undefined;
+}
+
+function resolveLogging(
+  base: LoggerOptions,
+  request: PreparedRequest,
+  unknown: Set<string>,
+): { at: number; sink: Logger } | undefined {
+  const named = String(request.options['logLevel'] || base.level || 'off');
+  const level = readLevel(named);
+  const sink =
+    (request.options['logger'] as Logger | undefined) ??
+    base.logger ??
+    (globalThis as { console?: Logger }).console;
+  if (level === undefined && sink && !unknown.has(named)) {
+    unknown.add(named);
+    sink.warn(
+      `Unknown log level "${named}": nothing is logged. Use "debug", "info", "warn", "error" or "off".`,
+    );
+  }
+  if (level === undefined || level === 'off' || !sink) return undefined;
+  return { at: LEVELS[level], sink };
+}
+
+async function written(request: PreparedRequest, next: Send): Promise<Result> {
+  const { log } = request;
+  if (!log) return next(request);
+
+  const result = await next(request);
+  log.replied(result.response);
+  return result;
+}
+
+export function loggerFeature(options: LoggerOptions = {}): Feature {
+  let counter = 0;
+  const unknown = new Set<string>();
+  const warned = new Set<CallableDescriptor>();
+
+  return {
+    name: 'logger',
+    async onError(error, request) {
+      request.log?.failed(error);
+      return error;
+    },
+    onOpen: written,
+    onPrepare(request) {
+      const on = resolveLogging(options, request, unknown);
+      if (!on) return;
+      const id = `req_${++counter}`;
+      request.log = callLog(id, request, on.at, on.sink);
+      const { callable } = request;
+      if (callable.deprecated && on.at >= LEVELS.warn && !warned.has(callable)) {
+        warned.add(callable);
+        const method = callable.method?.toUpperCase();
+        const operation = method ? `${method} ${callable.address}` : callable.address;
+        on.sink.warn(`[${id}] ${operation} is deprecated`);
+      }
+    },
+    onSend: written,
+  };
+}

package/src/internal/feature/retry.ts

@@ -0,0 +1,168 @@
+import { backoffDelay, exceedsMaxRetryAfter, retryAfterDelay, sleep } from '../core/backoff';
+import { discardBody, isStreamed } from '../core/body';
+import { calledOffWith, classifyError, ElmoError, failureOf, TransportError } from '../core/errors';
+import type { Feature, PreparedRequest, Result, RetryRules, Send } from '../core/types';
+
+/** Which failed calls are sent again, how many times, and how long each waits first. */
+export interface RetryOptions extends RetryRules {
+  /**
+   * How long to wait before the next attempt, in milliseconds, in place of the
+   * API's retry headers and the backoff. `undefined` keeps the usual wait.
+   * After a failure that got no reply, `result` holds only the `error`.
+   * {@link maxRetryAfter} does not limit what this returns.
+   */
+  retryDelay?(result: Result, request: PreparedRequest, attempt: number): number | undefined;
+  /**
+   * Whether to retry, in place of `statuses`, `x-should-retry` and
+   * `retryOnTimeout`. After a reply, the body is unread: read it from
+   * `response.clone()`. After a failure that got no reply, `result` holds only
+   * the `error`. A call the API may have acted on is never asked about: a
+   * method outside `methods` is sent again only after 408, 425 or 429, after
+   * a failure that answers `x-should-retry: true`, or when the request never
+   * reached the API.
+   */
+  retryOn?(result: Result, request: PreparedRequest): boolean;
+}
+
+export const DEFAULT_MAX_RETRIES = 2;
+
+function askedFor(config: RetryOptions, result: Result): number | undefined {
+  const headers = config.retryAfter;
+  if (headers === false || !result.response) return undefined;
+  return retryAfterDelay(result.response, headers === true ? undefined : headers);
+}
+
+const IDEMPOTENT_METHODS: ReadonlyArray<string> = [
+  'DELETE',
+  'GET',
+  'HEAD',
+  'OPTIONS',
+  'PUT',
+  'TRACE',
+];
+
+function isRepeatable(config: RetryOptions, request: PreparedRequest): boolean {
+  const method = request.callable.method?.toUpperCase();
+  if (!method) return false;
+  if ((config.methods ?? IDEMPOTENT_METHODS).includes(method)) return true;
+  const { idempotency } = request.callable;
+  return idempotency !== undefined && request.meta[idempotency] !== undefined;
+}
+
+function retriesFor(
+  base: RetryOptions,
+  override: RetryOptions | true | undefined,
+  request: PreparedRequest,
+): number {
+  if (override && override !== true && override.maxRetries !== undefined) {
+    return Math.max(0, override.maxRetries);
+  }
+  const retries = request.options['maxRetries'];
+  if (typeof retries === 'number' && Number.isFinite(retries)) return Math.max(0, retries);
+  return base.maxRetries ?? DEFAULT_MAX_RETRIES;
+}
+
+function resolveRetry(base: RetryOptions, request: PreparedRequest): RetryOptions | undefined {
+  const override = request.options['retry'] as RetryOptions | boolean | undefined;
+  if (override === false) return undefined;
+
+  const declared = request.callable.retry;
+  if (declared === false && override === undefined) return undefined;
+
+  const stated = declared ? { ...base, ...declared } : base;
+  const config = override && override !== true ? { ...stated, ...override } : stated;
+  const maxRetries = retriesFor(stated, override, request);
+  return maxRetries < 1 ? undefined : { ...config, maxRetries };
+}
+
+const REFUSED_STATUSES: ReadonlyArray<number> = [408, 425, 429];
+
+const RETRY_HEADER = 'x-should-retry';
+
+const PERMANENT_STATUSES: ReadonlyArray<number> = [501, 505, 506, 508, 510, 511];
+
+function worthAnotherAttempt(status: number): boolean {
+  if (status >= 500) return !PERMANENT_STATUSES.includes(status);
+  return REFUSED_STATUSES.includes(status);
+}
+
+function shouldRetry(
+  config: RetryOptions,
+  result: Result,
+  request: PreparedRequest,
+  repeatable: boolean,
+): boolean {
+  const { response } = result;
+  if (!response) return false;
+  const asked = response.headers.get(RETRY_HEADER);
+  const invited = asked === 'true' && response.status >= 400;
+  if (!repeatable && !invited && !REFUSED_STATUSES.includes(response.status)) return false;
+  if (config.retryOn) return config.retryOn(result, request);
+  if (asked === 'false') return false;
+  if (invited) return true;
+  const { statuses } = config;
+  return statuses ? statuses.includes(response.status) : worthAnotherAttempt(response.status);
+}
+
+function shouldRetryError(
+  config: RetryOptions,
+  error: unknown,
+  request: PreparedRequest,
+  repeatable: boolean,
+): boolean {
+  if (error instanceof ElmoError && !(error instanceof TransportError)) return false;
+  const kind = classifyError(error);
+  if (kind === 'abort') return false;
+  if (failureOf(error).reachedServer !== 'no' && !repeatable) return false;
+  if (config.retryOn) return config.retryOn({ error }, request);
+  return kind !== 'timeout' || config.retryOnTimeout === true;
+}
+
+export function retryFeature(options: RetryOptions = {}): Feature {
+  async function repeated(request: PreparedRequest, next: Send): Promise<Result> {
+    const config = isStreamed(request.body) ? undefined : resolveRetry(options, request);
+    if (!config) return next(request);
+
+    const attempts = (config.maxRetries ?? DEFAULT_MAX_RETRIES) + 1;
+    const repeatable = isRepeatable(config, request);
+    const started = Date.now();
+
+    for (let attempt = 0; ; attempt++) {
+      const last = attempt >= attempts - 1;
+      let result: Result | undefined;
+      let threw = false;
+      let wait: number | undefined;
+
+      if (attempt) request.attempt = attempt;
+      try {
+        result = await next(request);
+        if (last || !shouldRetry(config, result, request, repeatable)) return result;
+
+        wait = config.retryDelay?.(result, request, attempt);
+        if (wait === undefined) {
+          wait = askedFor(config, result);
+          if (exceedsMaxRetryAfter(wait, config.maxRetryAfter)) return result;
+        }
+      } catch (error) {
+        if (last || !shouldRetryError(config, error, request, repeatable)) throw error;
+        threw = true;
+        result = { error };
+        wait = config.retryDelay?.(result, request, attempt);
+      }
+
+      wait ??= backoffDelay(attempt, config);
+      if (config.budget !== undefined && Date.now() - started + wait >= config.budget) {
+        if (threw) throw result.error;
+        return result;
+      }
+
+      discardBody(result);
+      request.log?.retrying(wait, attempt + 1, attempts - 1, result);
+      await sleep(wait, request.signal).catch((reason: unknown) => {
+        throw calledOffWith(reason);
+      });
+    }
+  }
+
+  return { name: 'retry', onOpen: repeated, onSend: repeated };
+}

package/src/internal/feature/rules.ts

@@ -0,0 +1,54 @@
+import { refusedInput } from '../core/errors';
+import type { Feature, InputRule, ResolvedOptions } from '../core/types';
+
+const COUNTED = { characters: 'character', entries: 'entry', items: 'item' } as const;
+
+function brokenBound(rule: InputRule, size: bigint | number): [string, number] | undefined {
+  if (rule.min !== undefined && size < rule.min) return ['at least', rule.min];
+  if (rule.max !== undefined && size > rule.max) return ['at most', rule.max];
+  if (rule.above !== undefined && size <= rule.above) return ['more than', rule.above];
+  if (rule.below !== undefined && size >= rule.below) return ['less than', rule.below];
+  return undefined;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null) return false;
+  const prototype = Object.getPrototypeOf(value) as unknown;
+  return prototype === Object.prototype || prototype === null;
+}
+
+function inputOf(options: ResolvedOptions, name: string | undefined): unknown {
+  if (name === undefined) return options.body;
+  return isPlainObject(options.body) ? options.body[name] : undefined;
+}
+
+function sizeOf(value: unknown, of: InputRule['of']): bigint | number | undefined {
+  if (of === undefined) {
+    return typeof value === 'number' || typeof value === 'bigint' ? value : undefined;
+  }
+  if (of === 'characters') return typeof value === 'string' ? Array.from(value).length : undefined;
+  if (of === 'items') return Array.isArray(value) ? value.length : undefined;
+  if (!isPlainObject(value)) return undefined;
+  return Object.values(value).filter((entry) => entry !== undefined).length;
+}
+
+export function rulesFeature(): Feature {
+  return {
+    name: 'rules',
+    onOptions(options, callable) {
+      for (const rule of callable.rules ?? []) {
+        const size = sizeOf(inputOf(options, rule.name), rule.of);
+        if (size === undefined) continue;
+        const broken = brokenBound(rule, size);
+        if (!broken) continue;
+        const [bound, limit] = broken;
+        const held = rule.name === undefined ? 'The request body' : `\`${rule.name}\``;
+        const stated =
+          rule.of === undefined
+            ? `is ${bound} ${limit}`
+            : `takes ${bound} ${limit} ${limit === 1 ? COUNTED[rule.of] : rule.of}`;
+        throw refusedInput(held, stated, size);
+      }
+    },
+  };
+}