openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/src/adapters/type-ast-bridge/typescript-to-ir.ts

@@ -0,0 +1,294 @@
+import type ts from "typescript";
+import { irRaw } from "../../domain/ir/constructors.js";
+import type {
+  IrComment,
+  IrKeyword,
+  IrMember,
+  IrPropertyName,
+  IrPropertySignature,
+  IrTupleElement,
+  IrType,
+} from "../../domain/ir/nodes.js";
+import type { TypeScriptModule } from "./load-typescript.js";
+import { asRaw, isIrNode, needsPrintedText } from "./typescript-raw-text.js";
+
+/**
+ * Read TypeScript type nodes from user callbacks into IR (ADR-004, decision 3). Synthesized nodes
+ * are mapped by structure. Anything the IR cannot express exactly is printed with the TypeScript
+ * printer, the way the original output it, and kept as a `raw` node: parsed nodes, nodes with
+ * comments, explicit parentheses, single-quoted strings, numbers not in canonical form, and syntax
+ * the IR does not model. Every function takes the user's TypeScript module (ADR-004, decision 4):
+ * `SyntaxKind` numbers differ between versions, so a node is read with the module that made it.
+ */
+
+function keywordOf(ts: TypeScriptModule, kind: ts.SyntaxKind): IrKeyword | undefined {
+  const keywords: ReadonlyMap<ts.SyntaxKind, IrKeyword> = new Map([
+    [ts.SyntaxKind.StringKeyword, "string"],
+    [ts.SyntaxKind.NumberKeyword, "number"],
+    [ts.SyntaxKind.BooleanKeyword, "boolean"],
+    [ts.SyntaxKind.UndefinedKeyword, "undefined"],
+    [ts.SyntaxKind.UnknownKeyword, "unknown"],
+    [ts.SyntaxKind.NeverKeyword, "never"],
+  ]);
+  return keywords.get(kind);
+}
+
+function isCanonicalNumber(text: string): boolean {
+  return String(Number(text)) === text;
+}
+
+function fromNumber(ts: TypeScriptModule, literal: ts.Expression): IrType | null {
+  if (ts.isNumericLiteral(literal)) {
+    return isCanonicalNumber(literal.text)
+      ? { kind: "numberLiteral", value: Number(literal.text) }
+      : null;
+  }
+  const isNegative =
+    ts.isPrefixUnaryExpression(literal) &&
+    literal.operator === ts.SyntaxKind.MinusToken &&
+    ts.isNumericLiteral(literal.operand) &&
+    isCanonicalNumber(literal.operand.text) &&
+    Number(literal.operand.text) !== 0;
+  return isNegative
+    ? { kind: "numberLiteral", value: -Number((literal.operand as ts.NumericLiteral).text) }
+    : null;
+}
+
+function fromLiteral(ts: TypeScriptModule, node: ts.LiteralTypeNode): IrType | null {
+  const { literal } = node;
+  if (ts.isStringLiteral(literal)) {
+    const isSingleQuoted = (literal as { singleQuote?: boolean }).singleQuote === true;
+    return isSingleQuoted
+      ? null
+      : { kind: "stringLiteral", value: literal.text, encoding: "escaped" };
+  }
+  if (literal.kind === ts.SyntaxKind.NullKeyword) {
+    return { kind: "keyword", keyword: "null" };
+  }
+  if (literal.kind === ts.SyntaxKind.TrueKeyword || literal.kind === ts.SyntaxKind.FalseKeyword) {
+    return { kind: "booleanLiteral", value: literal.kind === ts.SyntaxKind.TrueKeyword };
+  }
+  return fromNumber(ts, literal);
+}
+
+/** Converts the children of one node, which becomes their parent. */
+function childrenOf(ts: TypeScriptModule, parent: ts.Node): (child: ts.TypeNode) => IrType {
+  return (child) => fromTypeNode(ts, child, parent);
+}
+
+function fromReference(ts: TypeScriptModule, node: ts.TypeReferenceNode): IrType | null {
+  if (!ts.isIdentifier(node.typeName)) {
+    return null;
+  }
+  const typeArguments = (node.typeArguments ?? []).map(childrenOf(ts, node));
+  return { kind: "reference", name: ts.idText(node.typeName), typeArguments };
+}
+
+function fromTupleElement(
+  ts: TypeScriptModule,
+  element: ts.TypeNode,
+  convert: (node: ts.TypeNode) => IrType,
+): IrTupleElement {
+  if (ts.isRestTypeNode(element)) {
+    return { type: convert(element.type), isRest: true, isOptional: false };
+  }
+  if (ts.isOptionalTypeNode(element)) {
+    // The `?` is the parent of the type: it decides which parentheses the factory put in.
+    return { type: fromTypeNode(ts, element.type, element), isRest: false, isOptional: true };
+  }
+  return { type: convert(element), isRest: false, isOptional: false };
+}
+
+/** A tuple of plain, rest and optional elements; one with named members stays text. */
+function fromTuple(ts: TypeScriptModule, node: ts.TupleTypeNode): IrType | null {
+  if (node.elements.some((element) => ts.isNamedTupleMember(element))) {
+    return null;
+  }
+  const convert = childrenOf(ts, node);
+  return {
+    kind: "tuple",
+    elements: node.elements.map((element) => fromTupleElement(ts, element, convert)),
+  };
+}
+
+/**
+ * Leading comments in order, or null when the IR cannot hold them: trailing comments, or a
+ * comment without a line break after it (the IR always writes one).
+ */
+function fromComments(ts: TypeScriptModule, node: ts.Node): IrComment[] | null {
+  const comments = ts.getSyntheticLeadingComments(node) ?? [];
+  const hasTrailing = (ts.getSyntheticTrailingComments(node)?.length ?? 0) > 0;
+  if (hasTrailing || comments.some((comment) => !comment.hasTrailingNewLine)) {
+    return null;
+  }
+  return comments.map((comment) => ({
+    kind: comment.kind === ts.SyntaxKind.MultiLineCommentTrivia ? "block" : "line",
+    text: comment.text,
+  }));
+}
+
+function fromPropertyName(ts: TypeScriptModule, name: ts.PropertyName): IrPropertyName | null {
+  if (ts.isIdentifier(name)) {
+    return { kind: "identifier", text: ts.idText(name) };
+  }
+  if (ts.isStringLiteral(name) && (name as { singleQuote?: boolean }).singleQuote !== true) {
+    return { kind: "string", value: name.text };
+  }
+  return ts.isNumericLiteral(name) ? { kind: "number", text: name.text } : null;
+}
+
+/** Only `readonly` is modeled; any other modifier makes the member unreadable as IR. */
+function readonlyFlag(ts: TypeScriptModule, node: ts.TypeElement): boolean | null {
+  const modifiers = ts.canHaveModifiers(node) ? (ts.getModifiers(node) ?? []) : [];
+  const isOnlyReadonly = modifiers.every(
+    (modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword,
+  );
+  return isOnlyReadonly ? modifiers.length > 0 : null;
+}
+
+/** A property signature as IR, or null when it uses syntax the IR does not model. */
+export function fromPropertySignature(
+  ts: TypeScriptModule,
+  node: ts.PropertySignature,
+): IrPropertySignature | null {
+  const name = fromPropertyName(ts, node.name);
+  const comments = fromComments(ts, node);
+  const isReadonly = readonlyFlag(ts, node);
+  if (name === null || comments === null || isReadonly === null || node.type === undefined) {
+    return null;
+  }
+  return {
+    kind: "property",
+    name,
+    type: fromTypeNode(ts, node.type, node),
+    isOptional: node.questionToken !== undefined,
+    isReadonly,
+    comments,
+  };
+}
+
+function fromIndexSignature(
+  ts: TypeScriptModule,
+  node: ts.IndexSignatureDeclaration,
+): IrMember | null {
+  const [parameter, ...others] = node.parameters;
+  const comments = fromComments(ts, node);
+  const isReadonly = readonlyFlag(ts, node);
+  const isPlain =
+    parameter?.type !== undefined && ts.isIdentifier(parameter.name) && others.length === 0;
+  if (!isPlain || comments === null || isReadonly === null) {
+    return null;
+  }
+  return {
+    kind: "indexSignature",
+    parameterName: ts.idText(parameter.name as ts.Identifier),
+    parameterType: fromTypeNode(ts, parameter.type as ts.TypeNode, node),
+    type: fromTypeNode(ts, node.type, node),
+    isReadonly,
+    comments,
+  };
+}
+
+function fromMember(ts: TypeScriptModule, member: ts.TypeElement): IrMember | null {
+  if (member.pos >= 0) {
+    return null;
+  }
+  if (ts.isPropertySignature(member)) {
+    return fromPropertySignature(ts, member);
+  }
+  return ts.isIndexSignatureDeclaration(member) ? fromIndexSignature(ts, member) : null;
+}
+
+function fromTypeLiteral(ts: TypeScriptModule, node: ts.TypeLiteralNode): IrType | null {
+  const members = node.members.map((member) => fromMember(ts, member));
+  const isReadable = members.every((member) => member !== null);
+  return isReadable ? { kind: "object", members: members as IrMember[] } : null;
+}
+
+function fromComposite(ts: TypeScriptModule, node: ts.TypeNode): IrType | null {
+  const convert = childrenOf(ts, node);
+  if (ts.isArrayTypeNode(node)) {
+    return { kind: "array", element: convert(node.elementType) };
+  }
+  if (ts.isUnionTypeNode(node)) {
+    return { kind: "union", types: node.types.map(convert) };
+  }
+  if (ts.isIntersectionTypeNode(node)) {
+    return { kind: "intersection", types: node.types.map(convert) };
+  }
+  if (ts.isIndexedAccessTypeNode(node)) {
+    return {
+      kind: "indexedAccess",
+      object: convert(node.objectType),
+      index: convert(node.indexType),
+    };
+  }
+  if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+    return { kind: "readonly", type: convert(node.type) };
+  }
+  return ts.isTypeLiteralNode(node) ? fromTypeLiteral(ts, node) : null;
+}
+
+function fromStructure(ts: TypeScriptModule, node: ts.TypeNode): IrType | null {
+  const keyword = keywordOf(ts, node.kind);
+  if (keyword !== undefined) {
+    return { kind: "keyword", keyword };
+  }
+  if (ts.isIdentifier(node)) {
+    // The original writes JSON string literals and some references as bare identifiers.
+    return irRaw(ts.idText(node));
+  }
+  if (ts.isLiteralTypeNode(node)) {
+    return fromLiteral(ts, node);
+  }
+  if (ts.isTypeReferenceNode(node)) {
+    return fromReference(ts, node);
+  }
+  return ts.isTupleTypeNode(node) ? fromTuple(ts, node) : fromComposite(ts, node);
+}
+
+/**
+ * Whether the factory's parenthesizer put these parentheses in (same rules as the IR printer):
+ * unions, intersections and `readonly` types as array elements, indexed objects, optional tuple
+ * elements and `readonly` operands; unions and intersections as members of other unions or
+ * intersections.
+ */
+function isFactoryParenthesis(
+  ts: TypeScriptModule,
+  inner: ts.TypeNode,
+  parent: ts.Node | undefined,
+): boolean {
+  if (parent === undefined) {
+    return false;
+  }
+  const isComposite = ts.isUnionTypeNode(inner) || ts.isIntersectionTypeNode(inner);
+  const isPostfixOrReadonlyParent =
+    ts.isArrayTypeNode(parent) ||
+    ts.isIndexedAccessTypeNode(parent) ||
+    ts.isOptionalTypeNode(parent) ||
+    ts.isTypeOperatorNode(parent);
+  if (isPostfixOrReadonlyParent) {
+    return isComposite || ts.isTypeOperatorNode(inner);
+  }
+  const isCompositeParent = ts.isUnionTypeNode(parent) || ts.isIntersectionTypeNode(parent);
+  return isCompositeParent && isComposite;
+}
+
+/**
+ * Convert a type node. `parent` is the node that contains it: synthesized nodes have no `parent`
+ * link, and it is needed to tell parentheses the factory inserted from ones the user wrote.
+ */
+export function fromTypeNode(ts: TypeScriptModule, node: ts.TypeNode, parent?: ts.Node): IrType {
+  if (isIrNode(node)) {
+    return node;
+  }
+  if (needsPrintedText(ts, node)) {
+    return asRaw(ts, node);
+  }
+  if (ts.isParenthesizedTypeNode(node)) {
+    return isFactoryParenthesis(ts, node.type, parent)
+      ? fromTypeNode(ts, node.type, parent)
+      : asRaw(ts, node);
+  }
+  return fromStructure(ts, node) ?? asRaw(ts, node);
+}

package/src/adapters/type-ast-bridge/typescript-types.ts

@@ -0,0 +1,8 @@
+import type ts from "typescript";
+
+/**
+ * The TypeScript compiler's types for code outside the bridge (ADR-004, decision 4). Type-only:
+ * it is erased at build time, so importing it never loads TypeScript. Only the bridge imports
+ * `typescript` itself (enforced by dependency-cruiser).
+ */
+export type { ts };

package/src/api/ast-to-string.ts

@@ -0,0 +1,59 @@
+import { toStatements } from "../adapters/type-ast-bridge/ir-declarations-to-typescript.js";
+import { toTypeElement, toTypeNode } from "../adapters/type-ast-bridge/ir-to-typescript.js";
+import {
+  loadTypeScript,
+  type TypeScriptModule,
+} from "../adapters/type-ast-bridge/load-typescript.js";
+import {
+  type AstToStringOptions,
+  printWithTypeScript,
+} from "../adapters/type-ast-bridge/print-typescript.js";
+import type { ts } from "../adapters/type-ast-bridge/typescript-types.js";
+import { type IrPrintable, printFragments } from "../application/print/print-nodes.js";
+import { withStackOverflowReported } from "../application/stack-overflow.js";
+import type { IrDeclaration } from "../domain/ir/nodes.js";
+
+export type { AstToStringOptions } from "../adapters/type-ast-bridge/print-typescript.js";
+
+/** What `astToString` prints: IR (from `openapiTS` and the transformers) or TypeScript nodes. */
+export type AstToStringInput = IrPrintable | ts.Node | readonly (IrPrintable | ts.Node)[];
+
+function isIrNode(node: IrPrintable | ts.Node): node is IrPrintable {
+  return typeof node.kind === "string";
+}
+
+/** An IR node in TypeScript form, for printing it together with TypeScript nodes. */
+function toTypeScriptNodes(ts: TypeScriptModule, node: IrPrintable): ts.Node[] {
+  if (isIrDeclarationKind(node)) {
+    return toStatements(ts, node);
+  }
+  const isMember = node.kind === "property" || node.kind === "indexSignature";
+  return [isMember ? toTypeElement(ts, node) : toTypeNode(ts, node)];
+}
+
+function isIrDeclarationKind(node: IrPrintable): node is IrDeclaration {
+  return ["interface", "typeAlias", "enum", "constArray", "rawDeclaration"].includes(node.kind);
+}
+
+/**
+ * Print declarations, members or types as a TypeScript file body. IR is printed by our printer;
+ * with TypeScript nodes in the input, or with TypeScript printer options, everything goes
+ * through the TypeScript printer as before (ADR-004, decision 1).
+ */
+export function astToString(ast: AstToStringInput, options?: AstToStringOptions): string {
+  return withStackOverflowReported("print", () => printNodes(ast, options));
+}
+
+function printNodes(ast: AstToStringInput, options: AstToStringOptions | undefined): string {
+  const nodes: readonly (IrPrintable | ts.Node)[] = Array.isArray(ast)
+    ? ast
+    : [ast as IrPrintable | ts.Node];
+  if (nodes.every(isIrNode) && !options) {
+    return printFragments(nodes);
+  }
+  const ts = loadTypeScript();
+  const statements = nodes.flatMap((node) =>
+    isIrNode(node) ? toTypeScriptNodes(ts, node) : [node],
+  );
+  return printWithTypeScript(ts, statements, options);
+}

package/src/api/comment-header.ts

@@ -0,0 +1,7 @@
+/** The header of every generated file; the CLI writes it before the declarations. */
+export const COMMENT_HEADER = `/**
+ * This file was auto-generated by openapi-typesafe.
+ * Do not make direct changes to the file.
+ */
+
+`;

package/src/api/default-ports.ts

@@ -0,0 +1,44 @@
+import { performance } from "node:perf_hooks";
+import { createConfig, type Config as RedoclyConfig } from "@redocly/openapi-core";
+import supportsColor from "supports-color";
+import { createTerminalLogger } from "../adapters/terminal-logger/terminal-logger.js";
+import type { Logger } from "../application/ports/logger.js";
+
+/**
+ * The default adapters of the Node API (ENGINEERING_PLAN 4.5): this module and the CLI's
+ * composition root are where the process environment is read.
+ */
+
+/** Colors when the terminal supports them, as the original decided. */
+export function terminalSupportsColor(): boolean {
+  const stdout = supportsColor.stdout;
+  return Boolean(stdout) && stdout !== false && stdout.hasBasic !== false;
+}
+
+/** The terminal logger with `DEBUG` from the environment, writing to the console. */
+export function defaultLogger(silent: boolean): Logger {
+  return createTerminalLogger({
+    silent,
+    debugFilter: process.env.DEBUG,
+    useColors: terminalSupportsColor(),
+    sink: console,
+  });
+}
+
+/**
+ * How long one remote `$ref` (or a remote source) may take to load. Large documents (the 27 MB
+ * Cloudflare spec) download in seconds; a minute covers slow hosts, while Node's own fetch would
+ * wait five minutes for a server that never answers (ENGINEERING_PLAN 8.5).
+ */
+export const REMOTE_REF_TIMEOUT_MS = 60_000;
+
+/** A monotonic clock in milliseconds, for debug durations. */
+export function monotonicNow(): number {
+  return performance.now();
+}
+
+/** The default Redocly config: minimal rules, and duplicate operation IDs are an error. */
+export function defaultRedoclyConfig(): Promise<RedoclyConfig> {
+  const rules = { "operation-operationId-unique": { severity: "error" as const } };
+  return createConfig({ rules }, { extends: ["minimal"] });
+}

package/src/api/discriminator-conflict-warnings.ts

@@ -0,0 +1,43 @@
+import type { Logger } from "../application/ports/logger.js";
+import {
+  type DiscriminatorValueConflict,
+  findDiscriminatorValueConflicts,
+} from "../domain/openapi/discriminator-conflicts.js";
+import { OutputFix } from "../domain/output-fixes.js";
+import { WARNING_CODES, warningText } from "../domain/warnings.js";
+
+const DOCS_BASE_URL = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs";
+const DOCS_URL = `${DOCS_BASE_URL}/advanced.md#discriminator-values`;
+
+function listed(values: readonly unknown[]): string {
+  return values.map((value) => JSON.stringify(value)).join(", ");
+}
+
+function warningOf(conflict: DiscriminatorValueConflict): string {
+  const { member, owner, propertyName, values, allowed, isImplicit } = conflict;
+  const rule = isImplicit
+    ? "A Discriminator Object without a mapping entry for a schema gives it its schema name as " +
+      `the value; add a mapping entry such as ${JSON.stringify(allowed[0])}: "${member}".`
+    : "The Discriminator Object maps these values to the schema; map the values it allows.";
+  return (
+    `${member}: the discriminator "${propertyName}" of ${owner} gives this schema the value ` +
+    `${listed(values)}, which its "${propertyName}" property does not allow ` +
+    `(${listed(allowed)}), so no value of the schema matches the discriminator. ${rule} ` +
+    `See ${DOCS_URL}`
+  );
+}
+
+/**
+ * Warn once per discriminator member whose value its own property does not allow. The members
+ * depend on the run's fixes (`allof-discriminated-union`).
+ */
+export function warnDiscriminatorValueConflicts(
+  document: unknown,
+  fixes: readonly OutputFix[],
+  logger: Logger,
+): void {
+  const isUnionReused = fixes.includes(OutputFix.ALLOF_DISCRIMINATED_UNION);
+  for (const conflict of findDiscriminatorValueConflicts(document, { isUnionReused })) {
+    logger.warn(warningText(warningOf(conflict), WARNING_CODES.DISCRIMINATOR_VALUE_NOT_ALLOWED));
+  }
+}

package/src/api/discriminator-enum-names.ts

@@ -0,0 +1,26 @@
+import type { SharedEnumNames } from "../application/transform/footer/shared-enum-names.js";
+import type { EnumDeclarationRequest } from "../application/transform/schema/schema-context.js";
+
+/**
+ * `--dedupe-enums` names a shared enum after the first schema that declares it. With
+ * `discriminator-values` and `--enum`, a member's value refers to the owner's enum, which is then
+ * declared when the member is typed, maybe before that first schema; the shared enum would take
+ * the owner's name. A first pass records the names of the declaring schemas only, so the second
+ * pass names each shared enum as the document order does (`OtherKind`, not `PetPetType`).
+ */
+export class FirstSchemaNameRecorder implements SharedEnumNames {
+  private readonly names = new Map<string, string>();
+
+  nameOf(key: string, name: string, request: EnumDeclarationRequest): string {
+    if (!request.isOwnerReference && !this.names.has(key)) {
+      this.names.set(key, name);
+    }
+    return name;
+  }
+
+  /** The recorded name of each shared enum, for the second pass. */
+  chosenNames(): SharedEnumNames {
+    const chosen = new Map(this.names);
+    return { nameOf: (key, name) => chosen.get(key) ?? name };
+  }
+}

package/src/api/discriminator-enum-parent.ts

@@ -0,0 +1,129 @@
+import { createRef, parseRefPointer } from "../domain/openapi/json-pointer.js";
+import type { SchemaObject } from "../types.js";
+import type { EnumPatch } from "./discriminator-enum.js";
+
+/**
+ * The `discriminator-values` fix (#1700). With `--enum`, the enum the scan adds to a member
+ * (`petType: "Cat"`) is declared as an enum of its own (`CatPetType`), which is not assignable to
+ * the parent's enum (`PetType`). The parent's enum is found here, so the member's property can be
+ * typed with its members (`PetType.Cat`).
+ */
+
+/** The parent's enum schema and the location it is typed at, which gives the enum its name. */
+export interface EnumParent {
+  readonly schema: SchemaObject;
+  readonly path: string;
+}
+
+type ResolveSchemaRef = (ref: string) => unknown;
+
+/** A declared property schema and the location the transformer types it at. */
+interface DeclaredProperty {
+  readonly property: unknown;
+  readonly path: string;
+}
+
+const PROPERTIES_KEYWORD = "properties";
+/** `components`, `schemas` and the schema name: the segments before the schema's own keywords. */
+const ROOT_SEGMENTS = 3;
+
+/** The location a `$ref` is typed at: object properties are nested without `properties`. */
+function typedAt(ref: string): string {
+  const segments = parseRefPointer(ref);
+  const nested = segments.slice(ROOT_SEGMENTS).filter((segment) => segment !== PROPERTIES_KEYWORD);
+  return createRef([...segments.slice(0, ROOT_SEGMENTS), ...nested]);
+}
+
+function isSchemaObject(value: unknown): value is SchemaObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** The property `name` of a schema object typed at `ref`. */
+function ownProperty(item: SchemaObject, ref: string, name: string): DeclaredProperty | undefined {
+  const property = ("properties" in item ? item.properties : undefined)?.[name];
+  return property === undefined ? undefined : { property, path: createRef([ref, name]) };
+}
+
+/** The property `name` of the schema at `ref`, its own or from an `allOf` item, depth first. */
+function declaredProperty(
+  ref: string,
+  name: string,
+  resolve: ResolveSchemaRef,
+  visited: Set<string>,
+): DeclaredProperty | undefined {
+  const schema = resolve(ref);
+  if (visited.has(ref) || !isSchemaObject(schema)) {
+    return undefined;
+  }
+  visited.add(ref);
+  // An inline `allOf` item is typed at its parent's location, so both share the path.
+  for (const item of [schema, ...(schema.allOf ?? [])]) {
+    if (!isSchemaObject(item)) {
+      continue;
+    }
+    const found =
+      "$ref" in item
+        ? declaredProperty(item.$ref as string, name, resolve, visited)
+        : ownProperty(item, ref, name);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * A discriminator and the `$ref` of the schema that declares its property; `ref` is the member
+ * whose value the discriminator gives, where there is one.
+ */
+export type DiscriminatorOwner = Pick<EnumPatch, "discriminator" | "discriminatorRef"> &
+  Partial<Pick<EnumPatch, "ref">>;
+
+/**
+ * The property `name` that the member at `ref` inherits through its `allOf` `$ref`s. Its own
+ * keywords and inline items are left out: the scan writes the added value there.
+ */
+function inheritedProperty(
+  ref: string,
+  name: string,
+  resolve: ResolveSchemaRef,
+): DeclaredProperty | undefined {
+  const schema = resolve(ref);
+  const visited = new Set([ref]);
+  for (const item of isSchemaObject(schema) ? (schema.allOf ?? []) : []) {
+    const found =
+      isSchemaObject(item) && "$ref" in item
+        ? declaredProperty(item.$ref as string, name, resolve, visited)
+        : undefined;
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The enum of the property that the discriminator owner declares, if it is one. An owner that
+ * declares no such property (a `oneOf` with a mapping) leaves the member's type to the property
+ * the member inherits, so that property's enum is the one.
+ */
+export function enumParentOf(
+  patch: DiscriminatorOwner,
+  resolve: ResolveSchemaRef,
+): EnumParent | undefined {
+  const name = patch.discriminator.propertyName;
+  const declared =
+    declaredProperty(patch.discriminatorRef, name, resolve, new Set()) ??
+    (patch.ref === undefined ? undefined : inheritedProperty(patch.ref, name, resolve));
+  if (declared === undefined || !isSchemaObject(declared.property)) {
+    return undefined;
+  }
+  const ref = (declared.property as { readonly $ref?: unknown }).$ref;
+  const parent =
+    typeof ref === "string"
+      ? { schema: resolve(ref), path: typedAt(ref) }
+      : { schema: declared.property, path: declared.path };
+  return isSchemaObject(parent.schema) && Array.isArray(parent.schema.enum)
+    ? { schema: parent.schema, path: parent.path }
+    : undefined;
+}