openapi-typesafe 1.0.0-rc.0 → 1.0.0-rc.1

package/src/application/transform/ref-pointer/typed-walk.ts

@@ -0,0 +1,192 @@
+import { irIndexedAccess, irKeyword, irReference } from "../../../domain/ir/constructors.js";
+import type { IrKeyword, IrType } from "../../../domain/ir/nodes.js";
+import { indexBy, indexKeyword, rootType } from "../ref-type.js";
+import type { RefResolver, SchemaOptions } from "../schema/schema-context.js";
+import {
+  followRefs,
+  isArrayShape,
+  isJsonObject,
+  isObjectShape,
+  type Presence,
+  propertyPresence,
+  schemaPresence,
+} from "./generated-shape.js";
+import {
+  isOptionalHeader,
+  isOptionalRequestBody,
+  isParameterList,
+  isTypedAsSchema,
+  leadingNode,
+  leadingSegmentsOf,
+  type RefPointer,
+  startsInSchema,
+} from "./pointer-walk.js";
+
+/**
+ * The type of a `$ref` pointer as the generated types have it: the `schema` of a media type,
+ * header or component parameter is its type, `items` is indexed by `number`,
+ * `additionalProperties` by `string`, and a value that may be `undefined` or `null` is wrapped in
+ * `NonNullable` before it is indexed. The walk stops at a segment with no type of its own
+ * (`allOf/0`, `definitions/A`, operation `parameters/0`): the caller types the target itself.
+ */
+
+const DEFS_KEYWORD = "$defs";
+
+export interface TypedWalk {
+  readonly type: IrType;
+  /** The document node the type stands for (not followed through a `$ref`). */
+  readonly node: unknown;
+  readonly isSchema: boolean;
+  /** The segment is a property or `$defs` name, not a keyword. */
+  readonly isName: boolean;
+  readonly presence: Presence;
+}
+
+export interface TypedWalkInput {
+  readonly pointer: RefPointer;
+  readonly options: SchemaOptions;
+  readonly refs: RefResolver;
+}
+
+/** The walk result: a type, or the index of the first segment that has no type. */
+export type TypedWalkResult =
+  | { readonly kind: "typed"; readonly walk: TypedWalk }
+  | { readonly kind: "untyped"; readonly index: number };
+
+function present(walk: TypedWalk): IrType {
+  return walk.presence === "present" ? walk.type : irReference("NonNullable", [walk.type]);
+}
+
+function indexEntries(walk: TypedWalk, key: IrKeyword, keyword: string, refs: RefResolver) {
+  const owner = followRefs(walk.node, refs);
+  const child = isJsonObject(owner) ? owner[keyword] : undefined;
+  return {
+    ...walk,
+    type: irIndexedAccess(present(walk), irKeyword(key)),
+    node: child,
+    presence: schemaPresence(child, refs),
+  };
+}
+
+function nameStep(walk: TypedWalk, name: string, isLast: boolean, input: TypedWalkInput) {
+  const owner = followRefs(walk.node, input.refs);
+  const properties = isJsonObject(owner) && isJsonObject(owner.properties) ? owner.properties : {};
+  const type =
+    walk.presence === "present"
+      ? indexKeyword(walk.type, name, isLast)
+      : indexBy(present(walk), name);
+  return {
+    ...walk,
+    type,
+    node: properties[name],
+    isName: false,
+    presence: propertyPresence(walk.node, name, input.options, input.refs),
+  };
+}
+
+/** `$defs` is optional (`NonNullable` when more follows); its members are present. */
+function defsStep(walk: TypedWalk, owner: unknown, isLast: boolean): TypedWalk {
+  const defs = isJsonObject(owner) && isJsonObject(owner[DEFS_KEYWORD]) ? owner[DEFS_KEYWORD] : {};
+  return {
+    ...walk,
+    type: indexKeyword(present(walk), DEFS_KEYWORD, isLast),
+    node: { properties: defs, required: Object.keys(defs) },
+    isName: true,
+    presence: "present",
+  };
+}
+
+const SHAPED_KEYWORDS: ReadonlySet<string> = new Set([
+  "properties",
+  "items",
+  "additionalProperties",
+]);
+
+/**
+ * Whether the keyword gives the owner's generated type a member: `items` only an array,
+ * `properties` and `additionalProperties` only an object (`type: string` ignores them). A node
+ * that is not in the document is indexed as the keyword says.
+ */
+function hasKeywordMember(owner: unknown, segment: string): boolean {
+  if (!SHAPED_KEYWORDS.has(segment) || !isJsonObject(owner)) {
+    return true;
+  }
+  return segment === "items" ? isArrayShape(owner) : isObjectShape(owner);
+}
+
+function keywordStep(walk: TypedWalk, segment: string, isLast: boolean, input: TypedWalkInput) {
+  const owner = followRefs(walk.node, input.refs);
+  if (!hasKeywordMember(owner, segment)) {
+    return null;
+  }
+  switch (segment) {
+    case "properties":
+      return { ...walk, isName: true };
+    case "items":
+      return indexEntries(walk, "number", "items", input.refs);
+    case "additionalProperties":
+      return indexEntries(walk, "string", "additionalProperties", input.refs);
+    case DEFS_KEYWORD:
+      return defsStep(walk, owner, isLast);
+    default:
+      return null;
+  }
+}
+
+function containerStep(walk: TypedWalk, index: number, input: TypedWalkInput): TypedWalk {
+  const segment = input.pointer.segments[index] as string;
+  const owner = followRefs(walk.node, input.refs);
+  const isOptional =
+    (segment === "requestBody" && isOptionalRequestBody(owner, input.refs)) ||
+    isOptionalHeader(input.pointer, index, owner);
+  return {
+    ...walk,
+    type: indexBy(present(walk), segment),
+    node: isJsonObject(owner) ? owner[segment] : undefined,
+    presence: isOptional ? "absent" : "present",
+  };
+}
+
+function step(walk: TypedWalk, index: number, input: TypedWalkInput): TypedWalk | null {
+  const { segments } = input.pointer;
+  const segment = segments[index] as string;
+  const isLast = index === segments.length - 1;
+  if (walk.isSchema) {
+    return walk.isName
+      ? nameStep(walk, segment, isLast, input)
+      : keywordStep(walk, segment, isLast, input);
+  }
+  if (segment === "schema" && isTypedAsSchema(input.pointer, index)) {
+    const owner = followRefs(walk.node, input.refs);
+    const schema = isJsonObject(owner) ? owner.schema : undefined;
+    // The container's type is its schema's type: an optional header stays optional.
+    const presence = walk.presence === "absent" ? "absent" : schemaPresence(schema, input.refs);
+    return { ...walk, node: schema, isSchema: true, presence };
+  }
+  return isParameterList(input.pointer, index) ? null : containerStep(walk, index, input);
+}
+
+/** Walk the whole pointer; see the module comment. */
+export function typedWalk(input: TypedWalkInput): TypedWalkResult {
+  const { pointer } = input;
+  const node = leadingNode(pointer, input.refs);
+  const isSchema = startsInSchema(pointer);
+  let walk: TypedWalk = {
+    type: indexBy(
+      rootType(pointer.rootSegment, false),
+      ...pointer.segments.slice(0, leadingSegmentsOf(pointer)),
+    ),
+    node,
+    isSchema,
+    isName: false,
+    presence: isSchema ? schemaPresence(node, input.refs) : "present",
+  };
+  for (let index = leadingSegmentsOf(pointer); index < pointer.segments.length; index++) {
+    const next = step(walk, index, input);
+    if (next === null) {
+      return { kind: "untyped", index };
+    }
+    walk = next;
+  }
+  return { kind: "typed", walk };
+}

package/src/application/transform/ref-type.ts

@@ -8,6 +8,7 @@ import {
   irString,
 } from "../../domain/ir/constructors.js";
 import type { IrType } from "../../domain/ir/nodes.js";
+import { toPropertyName } from "../../domain/ir/property-name.js";
 import { parseRefPointer } from "../../domain/openapi/json-pointer.js";
 
 /** Where a referenced parameter lives in the generated `parameters` type. */
@@ -37,16 +38,20 @@ export class InvalidRefError extends OpenAPITypesafeError {
 }
 
 /** Segments that index into the root type, always as escaped string literal types. */
-function indexBy(type: IrType, ...segments: readonly string[]): IrType {
+export function indexBy(type: IrType, ...segments: readonly string[]): IrType {
   return segments.reduce<IrType>(
     (object, segment) => irIndexedAccess(object, irString(segment, "escaped")),
     type,
   );
 }
 
-/** `Extract<T, { name: unknown }>`; the name is written as an identifier, as in the original. */
-function extractVariantsWith(type: IrType, propertyName: string): IrType {
-  const probe = irProperty({ kind: "identifier", text: propertyName }, irKeyword("unknown"));
+/**
+ * `Extract<T, { name: unknown }>`. The original wrote the name as an identifier even when it is
+ * not one (`{ content-type: unknown }`), which is a syntax error; it is now quoted like any other
+ * property name, and an identifier stays as it was.
+ */
+export function extractVariantsWith(type: IrType, propertyName: string): IrType {
+  const probe = irProperty(toPropertyName(propertyName), irKeyword("unknown"));
   return irReference("Extract", [type, irObject([probe])]);
 }
 
@@ -57,12 +62,12 @@ const DEFS_KEYWORD = "$defs";
  * segments follow it is wrapped in `NonNullable<…>` first; otherwise the next index fails on
  * `undefined` (upstream #2664).
  */
-function indexKeyword(type: IrType, segment: string, isLast: boolean): IrType {
+export function indexKeyword(type: IrType, segment: string, isLast: boolean): IrType {
   const indexed = indexBy(type, segment);
   return segment === DEFS_KEYWORD && !isLast ? irReference("NonNullable", [indexed]) : indexed;
 }
 
-function rootType(rootSegment: string, isDeep: boolean): IrType {
+export function rootType(rootSegment: string, isDeep: boolean): IrType {
   return irReference(isDeep ? `FlattenedDeepRequired<${rootSegment}>` : rootSegment);
 }
 

package/src/application/transform/schema/access-flags.ts

@@ -0,0 +1,63 @@
+import type { Schema, SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { OutputFix } from "../../../domain/output-fixes.js";
+import type { SchemaContext } from "./schema-context.js";
+
+/** Whether a property is `readOnly` or `writeOnly` (JSON Schema 2020-12 Validation §9.4). */
+export interface AccessFlags {
+  readonly isReadOnly: boolean;
+  readonly isWriteOnly: boolean;
+}
+
+const NO_FLAGS: AccessFlags = { isReadOnly: false, isWriteOnly: false };
+
+function ownFlags(schema: SchemaObject): AccessFlags {
+  return { isReadOnly: Boolean(schema.readOnly), isWriteOnly: Boolean(schema.writeOnly) };
+}
+
+function merged(left: AccessFlags, right: AccessFlags): AccessFlags {
+  return {
+    isReadOnly: left.isReadOnly || right.isReadOnly,
+    isWriteOnly: left.isWriteOnly || right.isWriteOnly,
+  };
+}
+
+/**
+ * The flags of a schema and of the schemas that always apply to the same value: the one its
+ * `$ref` names and its `allOf` members, followed until a schema repeats. `readOnly` is an
+ * annotation, and the annotations of those schemas are the value's (2020-12 Core §7.7.1); in
+ * OpenAPI 3.0 a referenced schema is the property's definition. `anyOf` and `oneOf` members apply
+ * only when they match, which the type cannot tell, so they are not read.
+ */
+function appliedFlags(
+  schema: Schema | undefined,
+  context: SchemaContext,
+  seen: ReadonlySet<Schema>,
+): AccessFlags {
+  if (typeof schema !== "object" || schema === null || seen.has(schema)) {
+    return NO_FLAGS;
+  }
+  const inner = new Set([...seen, schema]);
+  // `readOnly` next to a `$ref` is read too, as the generator always has.
+  const object = schema as SchemaObject & { readonly $ref?: unknown };
+  const target =
+    typeof object.$ref === "string" ? (context.refs.resolve(object.$ref) as Schema) : undefined;
+  return (object.allOf ?? []).reduce<AccessFlags>(
+    (flags, member) => merged(flags, appliedFlags(member, context, inner)),
+    merged(ownFlags(object), appliedFlags(target, context, inner)),
+  );
+}
+
+/**
+ * The flags of a property schema. Without the `read-write-refs` fix only the keywords written on
+ * it count, as in openapi-typescript; with it, also those of the schemas its `$ref` and `allOf`
+ * apply (upstream #1938).
+ */
+export function propertyAccessFlags(value: Schema, context: SchemaContext): AccessFlags {
+  if (typeof value !== "object") {
+    return NO_FLAGS;
+  }
+  if (!context.options.fixes.has(OutputFix.READ_WRITE_REFS)) {
+    return ownFlags(value as SchemaObject);
+  }
+  return appliedFlags(value, context, new Set());
+}

package/src/application/transform/schema/array-type.ts

@@ -1,6 +1,12 @@
-import { irArray, irReadonly, irTuple, irTupleElement } from "../../../domain/ir/constructors.js";
-import type { IrType } from "../../../domain/ir/nodes.js";
-import type { SchemaObject } from "../../../domain/openapi/schema-object.js";
+import {
+  irArray,
+  irOptionalTupleElement,
+  irReadonly,
+  irTuple,
+  irTupleElement,
+} from "../../../domain/ir/constructors.js";
+import type { IrTupleElement, IrType } from "../../../domain/ir/nodes.js";
+import type { Schema, SchemaObject } from "../../../domain/openapi/schema-object.js";
 import { OutputFix } from "../../../domain/output-fixes.js";
 import { UNKNOWN_TYPE } from "../shared-types.js";
 import { unionOf } from "../type-combinators.js";
@@ -12,9 +18,15 @@ import type { SchemaRequest } from "./schema-rule.js";
  */
 const MAX_LENGTH_TUPLE_ELEMENTS = 30;
 
-/** The tuple of `prefixItems` (or of an `items` list); null without either. */
+/**
+ * The tuple of `prefixItems` (or of an `items` list); null without either. The original closes a
+ * `prefixItems` tuple and requires every element; the `prefix-items` fix does not.
+ */
 function prefixTupleType(schema: SchemaObject, request: SchemaRequest): IrType | null {
   const { items } = schema;
+  if (schema.prefixItems && isPrefixItemsFixed(schema, request)) {
+    return prefixItemsTupleType(schema.prefixItems, schema, request);
+  }
   if (!schema.prefixItems && !Array.isArray(items)) {
     return null;
   }
@@ -24,6 +36,54 @@ function prefixTupleType(schema: SchemaObject, request: SchemaRequest): IrType |
   );
 }
 
+/** The type of the items after the prefix, or null when there may be none (`false`). */
+function restItemType(schema: Schema, request: SchemaRequest): IrType | null {
+  return schema === false ? null : request.transformNested(schema, request.location);
+}
+
+/**
+ * The type of the items after a `prefixItems` tuple (JSON Schema 2020-12 §10.3.1): `items`, else
+ * `unevaluatedItems`, which does not apply to the items `contains` matches, else any item. Null
+ * when no item may follow. An `items` list is not a schema in 2020-12, so it allows any item.
+ */
+function prefixRestType(schema: SchemaObject, request: SchemaRequest): IrType | null {
+  const { items, unevaluatedItems, contains } = schema;
+  if (items !== undefined && !Array.isArray(items)) {
+    return restItemType(items as Schema, request);
+  }
+  if (unevaluatedItems === undefined || items !== undefined) {
+    return UNKNOWN_TYPE;
+  }
+  const unevaluated = restItemType(unevaluatedItems, request);
+  const matched = contains === undefined ? null : restItemType(contains, request);
+  const types = [unevaluated, matched].filter((type): type is IrType => type !== null);
+  return types.length === 0 ? null : unionOf(types);
+}
+
+/**
+ * The `prefix-items` tuple of `prefixItems`: an array may end before the prefix does, so the
+ * elements from `minItems` on are optional (`T?`), and a rest element types the items after it.
+ */
+function prefixItemsTupleType(
+  prefixItems: readonly Schema[],
+  schema: SchemaObject,
+  request: SchemaRequest,
+): IrType {
+  const { min } = lengthBounds(schema);
+  const elements = prefixItems.map((item, index): IrTupleElement => {
+    const type = request.transformNested(item, request.location);
+    return index < min ? irTupleElement(type) : irOptionalTupleElement(type);
+  });
+  const rest = prefixRestType(schema, request);
+  return irTuple(rest === null ? elements : [...elements, irTupleElement(irArray(rest), true)]);
+}
+
+function isPrefixItemsFixed(schema: SchemaObject, request: SchemaRequest): boolean {
+  return (
+    schema.prefixItems !== undefined && request.context.options.fixes.has(OutputFix.PREFIX_ITEMS)
+  );
+}
+
 /** The type of one item; `unknown` without `items`. */
 function singleItemType(schema: SchemaObject, request: SchemaRequest): IrType {
   const { items } = schema;
@@ -143,7 +203,8 @@ export function arrayType(schema: SchemaObject, request: SchemaRequest): IrType
   }
   const item = itemType(schema, request);
   const bounds = lengthBounds(schema);
-  if (isLengthTupleWanted(bounds, request)) {
+  // A `prefix-items` tuple has its own lengths, so `--array-length` adds no tuples around it.
+  if (!isPrefixItemsFixed(schema, request) && isLengthTupleWanted(bounds, request)) {
     return lengthTupleType(schema, item, bounds);
   }
   // A tuple or an array item is used as the array type itself.

package/src/application/transform/schema/composition-type.ts

@@ -3,6 +3,7 @@ import type { IrType } from "../../../domain/ir/nodes.js";
 import { createRef } from "../../../domain/openapi/json-pointer.js";
 import type { Schema, SchemaObject } from "../../../domain/openapi/schema-object.js";
 import { OutputFix } from "../../../domain/output-fixes.js";
+import { requirableRefType } from "../ref-pointer/pointer-type.js";
 import { UNKNOWN_TYPE } from "../shared-types.js";
 import {
   intersectionOf,
@@ -13,7 +14,9 @@ import {
   withRequiredKeys,
 } from "../type-combinators.js";
 import { coreType } from "./core-type.js";
+import { unionItemOf, unionOwnKeywords } from "./discriminated-union.js";
 import { allOfMembers } from "./presence-members.js";
+import { requiredVariantsType } from "./required-variants.js";
 import type { SchemaRequest } from "./schema-rule.js";
 import { unevaluatedPropertiesType } from "./unevaluated-properties.js";
 
@@ -39,6 +42,28 @@ function isRefItem(item: Schema): item is { readonly $ref: string } {
   return "$ref" in (item as object);
 }
 
+/**
+ * The parent's `required` keys that the target at `ref` defines. A target that the discriminator
+ * scan gave its property got none: the scan made that property required, but the other keys were
+ * lost too. With `discriminator-member-required` only keys the target requires already are left
+ * out (#2162).
+ */
+function keysToRequire(
+  ref: string,
+  target: SchemaObject,
+  required: readonly string[],
+  request: SchemaRequest,
+): readonly string[] {
+  const defined = required.filter((key) => Boolean(target.properties?.[key]));
+  if (!request.context.discriminators.isHandled(ref)) {
+    return defined;
+  }
+  if (!request.context.options.fixes.has(OutputFix.DISCRIMINATOR_MEMBER_REQUIRED)) {
+    return [];
+  }
+  return defined.filter((key) => !target.required?.includes(key));
+}
+
 /** A `$ref` item gets the parent's `required` keys that its target defines (`WithRequired`). */
 function refItemType(
   item: { readonly $ref: string },
@@ -46,21 +71,16 @@ function refItemType(
   request: SchemaRequest,
 ): IrType {
   const type = request.transformNested(item, request.location);
-  const { refs, discriminators, footer } = request.context;
-  const resolved = refs.resolve(item.$ref) as SchemaObject | undefined;
-  const isEligible =
-    resolved &&
-    typeof resolved === "object" &&
-    "properties" in resolved &&
-    !discriminators.isHandled(item.$ref);
-  if (!isEligible) {
+  const resolved = request.context.refs.resolve(item.$ref) as SchemaObject | undefined;
+  if (!resolved || typeof resolved !== "object" || !("properties" in resolved)) {
     return type;
   }
-  const keys = required.filter((key) => Boolean(resolved.properties?.[key]));
-  if (keys.length > 0) {
-    footer.requireWithRequired();
+  const keys = keysToRequire(item.$ref, resolved, required, request);
+  if (keys.length === 0) {
+    return type;
   }
-  return withRequiredKeys(type, keys);
+  request.context.footer.requireWithRequired();
+  return withRequiredKeys(requirableRefType(item.$ref, type, request), keys);
 }
 
 /** An inline item merges the parent's `required` keys with its own. */
@@ -75,22 +95,59 @@ function inlineItemType(item: Schema, required: readonly string[], request: Sche
   );
 }
 
-/** `allOf` items; an item with a discriminator omits that property (the parent redefines it). */
+/**
+ * The union's own keywords at the union's location, so nested names (enums) stay the union's.
+ * Null when the union has none.
+ */
+function ownKeywordsType(own: SchemaObject, ref: string, request: SchemaRequest): IrType | null {
+  return combinedType(own, { ...request, location: { ...request.location, path: ref } });
+}
+
+/**
+ * An `allOf` item; one with a discriminator omits that property (the parent redefines it). A
+ * `$ref` to a discriminated union is not such a parent: for a member of the union it is the
+ * union's own keywords, since the union contains the member (#1665); with
+ * `allof-discriminated-union` it is the union, since `Omit` on a union drops keys (#1464), unless
+ * the union's mapping names the schema: then it is a member, as the discriminator scan has it.
+ */
+function allOfItemType(
+  item: Schema,
+  required: readonly string[],
+  request: SchemaRequest,
+): IrType | null {
+  const isRef = isRefItem(item);
+  const discriminator =
+    (isRef && request.context.discriminators.objectAt(item.$ref)) ||
+    (item as SchemaObject).discriminator;
+  const propertyName = discriminator?.propertyName;
+  const unionItem = isRef && propertyName ? unionItemOf(item.$ref, request) : undefined;
+  if (isRef && propertyName && unionItem?.isMember) {
+    const own = unionOwnKeywords(unionItem.union, propertyName, required);
+    return ownKeywordsType(own, item.$ref, request);
+  }
+  const type = isRef
+    ? refItemType(item, required, request)
+    : inlineItemType(item, required, request);
+  const isUnion =
+    unionItem !== undefined &&
+    !unionItem.isMapped &&
+    request.context.options.fixes.has(OutputFix.ALLOF_DISCRIMINATED_UNION);
+  if (!propertyName || isUnion) {
+    return type;
+  }
+  // With `discriminator-values` the schema also redefines the properties of other owners above
+  // it, so no item may keep a value of its own for them (a parent mapped as `content`).
+  const { path } = request.location;
+  const others = path === undefined ? [] : request.context.discriminators.otherPropertiesAt(path);
+  return omitKeys(type, [propertyName, ...others]);
+}
+
 function allOfTypes(
   items: readonly Schema[],
   required: readonly string[],
   request: SchemaRequest,
 ): IrType[] {
-  return items.map((item) => {
-    const isRef = isRefItem(item);
-    const type = isRef
-      ? refItemType(item, required, request)
-      : inlineItemType(item, required, request);
-    const discriminator =
-      (isRef && request.context.discriminators.objectAt(item.$ref)) ||
-      (item as SchemaObject).discriminator;
-    return discriminator?.propertyName ? omitKeys(type, [discriminator.propertyName]) : type;
-  });
+  return items.flatMap((item) => allOfItemType(item, required, request) ?? []);
 }
 
 function oneOfType(previous: IrType | null, variants: readonly IrType[]): IrType {
@@ -147,7 +204,22 @@ function composedType(schema: SchemaObject, request: SchemaRequest): IrType | nu
     const allOfType = allOf.length > 0 ? [intersectionOf(allOf)] : [];
     type = intersectionOf([...(core === null ? [] : [core]), ...allOfType]);
   }
-  type = anyOfType(type, schema, request);
+  return variantsType(type, schema, request);
+}
+
+/** `anyOf`, then `oneOf`, applied to the core and `allOf` type (`anyof-oneof-required` first). */
+function variantsType(
+  previous: IrType | null,
+  schema: SchemaObject,
+  request: SchemaRequest,
+): IrType | null {
+  const type =
+    requiredVariantsType(previous, schema, schema.anyOf ?? [], request) ??
+    anyOfType(previous, schema, request);
+  const oneOfRequired = requiredVariantsType(type, schema, schema.oneOf ?? [], request);
+  if (oneOfRequired !== null) {
+    return oneOfRequired;
+  }
   const oneOf = variantTypes(oneOfVariants(schema), "oneOf", request);
   return oneOf.length > 0 ? oneOfType(type, oneOf) : type;
 }

package/src/application/transform/schema/core-type.ts

@@ -9,6 +9,7 @@ import type {
 import { unionOf } from "../type-combinators.js";
 import { arrayType } from "./array-type.js";
 import { objectType } from "./object-type.js";
+import { hasRequiredVariants } from "./required-variants.js";
 import type { SchemaRequest, SchemaRule } from "./schema-rule.js";
 
 const PRIMITIVE_TYPE_NAMES: ReadonlySet<SchemaTypeName | null> = new Set([
@@ -34,10 +35,13 @@ function multipleTypes(schema: SchemaObject, request: SchemaRequest): IrType {
     if (isInOneOf) {
       continue;
     }
-    // With oneOf, the member drops it, so oneOf is not applied once per member.
-    const variant = Array.isArray(oneOf)
-      ? { ...schema, type: typeName, oneOf: undefined }
-      : { ...schema, type: typeName };
+    // With oneOf, the member drops it, so oneOf is not applied once per member. Variants that
+    // only require properties (`anyof-oneof-required`) belong to the object member.
+    const isKept = typeName === "object" && hasRequiredVariants(schema, oneOf ?? [], request);
+    const variant =
+      Array.isArray(oneOf) && !isKept
+        ? { ...schema, type: typeName, oneOf: undefined }
+        : { ...schema, type: typeName };
     members.push(
       typeName === "null" || typeName === null
         ? irKeyword("null")

package/src/application/transform/schema/discriminated-union.ts

@@ -0,0 +1,58 @@
+import { unionAt, unionMaps, unionReaches } from "../../../domain/openapi/discriminated-union.js";
+import type { SchemaObject } from "../../../domain/openapi/schema-object.js";
+import type { SchemaRequest } from "./schema-rule.js";
+
+/**
+ * `allOf` items that are a `$ref` to a discriminated union (`oneOf` / `anyOf` and a
+ * discriminator). Such an item cannot be typed as the parent of the inheritance pattern,
+ * `Omit<Union, "kind">`.
+ */
+
+/** The union an `allOf` item refers to, and whether the union's type contains this schema. */
+export interface UnionItem {
+  readonly union: SchemaObject;
+  /**
+   * The schema is one of the union's members: intersecting the union would make it refer to
+   * itself, which does not compile (TS2502, upstream #1665).
+   */
+  readonly isMember: boolean;
+  /** The union's mapping names the schema, so it is a member even where the type is not. */
+  readonly isMapped: boolean;
+}
+
+/** The union at `ref`, if the schema there is one. */
+export function unionItemOf(ref: string, request: SchemaRequest): UnionItem | undefined {
+  const path = request.location.path;
+  const resolve = (target: string) => request.context.refs.resolve(target);
+  const union = unionAt(ref, resolve);
+  if (union === undefined) {
+    return undefined;
+  }
+  const isMember = path !== undefined && unionReaches(union, path, resolve);
+  return { union, isMember, isMapped: path !== undefined && unionMaps(union, path) };
+}
+
+function withoutKey<T>(record: Readonly<Record<string, T>>, key: string): Record<string, T> {
+  return Object.fromEntries(Object.entries(record).filter(([name]) => name !== key));
+}
+
+/**
+ * The keywords of a union that its members inherit: everything but the members and the
+ * discriminator property, which each member redefines (as `Omit` does for a parent). The item's
+ * `required` keys are added, as for an inline `allOf` item.
+ */
+export function unionOwnKeywords(
+  union: SchemaObject,
+  propertyName: string,
+  required: readonly string[],
+): SchemaObject {
+  const { oneOf: _oneOf, anyOf: _anyOf, ...own } = union;
+  const ownRequired = (union.required ?? []).filter((key) => key !== propertyName);
+  return {
+    ...own,
+    ...(union.properties === undefined
+      ? {}
+      : { properties: withoutKey(union.properties, propertyName) }),
+    required: [...required, ...ownRequired],
+  };
+}