openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/src/application/transform/schema/enum-rule.ts

@@ -0,0 +1,280 @@
+import {
+  irIndexedAccess,
+  irKeyword,
+  irObject,
+  irReference,
+  irString,
+} from "../../../domain/ir/constructors.js";
+import type { IrType } from "../../../domain/ir/nodes.js";
+import { createRef, parseRefPointer } from "../../../domain/openapi/json-pointer.js";
+import type { SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { OutputFix } from "../../../domain/output-fixes.js";
+import { literalType } from "../literal-type.js";
+import { refType } from "../ref-type.js";
+import { intersectionOf, unionOf } from "../type-combinators.js";
+import type {
+  DiscriminatorEnumParent,
+  EnumDeclarationRequest,
+  EnumMemberMetadata,
+  SchemaOptions,
+} from "./schema-context.js";
+import type { SchemaRequest, SchemaRule } from "./schema-rule.js";
+
+/** Removed from generated names, so `#/components/schemas/Status` gives `Status`. */
+const COMPONENT_SCHEMAS_PREFIX = "components/schemas";
+const UNION_KEYWORDS: ReadonlySet<string> = new Set(["anyOf", "oneOf"]);
+const INDEX_RE = /^\d+$/;
+
+function hasAdditionalProperties(schema: SchemaObject): boolean {
+  return "additionalProperties" in schema && Boolean(schema.additionalProperties);
+}
+
+/** A name from the schema's pointer: `#/components/schemas/Pet/status` → `/Pet/status`. */
+function nameFromPath(path: string | undefined): string {
+  return parseRefPointer(path ?? "")
+    .join("/")
+    .replace(COMPONENT_SCHEMAS_PREFIX, "");
+}
+
+/** `#/components/schemas/Name`, and no deeper pointer. */
+const COMPONENT_SCHEMA_RE = /^#\/components\/schemas\/[^/]+$/;
+
+function hasEnumMetadata(schema: SchemaObject): boolean {
+  return [
+    schema["x-enum-varnames"],
+    schema["x-enumNames"],
+    schema["x-enum-descriptions"],
+    schema["x-enumDescriptions"],
+  ].some(Array.isArray);
+}
+
+/**
+ * The values a TypeScript enum declares, with their positions in `enum`. With the
+ * `nullable-enums` fix a `null` value is left out (upstream #1872): an enum member cannot be
+ * `null`, so the type adds it as `| null` instead (`tsEnumType`).
+ */
+function tsEnumEntries(schema: SchemaObject, options: SchemaOptions): [unknown, number][] {
+  const entries = (schema.enum ?? []).map((value, index): [unknown, number] => [value, index]);
+  return options.fixes.has(OutputFix.NULLABLE_ENUMS)
+    ? entries.filter(([value]) => value !== null)
+    : entries;
+}
+
+/**
+ * `--enum`: string and number enums become TypeScript enums. The original meant to allow `null`
+ * too, but tested `typeof value` against `null`, so an enum containing null stays a union; the
+ * `nullable-enums` fix declares its other values.
+ */
+function isTsEnum(schema: SchemaObject, options: SchemaOptions): boolean {
+  if (!options.enum || !schema.enum) {
+    return false;
+  }
+  const entries = tsEnumEntries(schema, options);
+  // An empty `enum` stays an empty TypeScript enum, as the original made it; an enum of only
+  // `null` has no member left once the fix drops `null`, so it stays a union.
+  const isOnlyNull = entries.length === 0 && schema.enum.length > 0;
+  const isSupported =
+    !isOnlyNull && entries.every(([value]) => ["string", "number"].includes(typeof value));
+  // `--conditional-enums` converts only enums that carry x-enum-* metadata.
+  return isSupported && (!options.conditionalEnums || hasEnumMetadata(schema));
+}
+
+function enumMetadata(
+  schema: SchemaObject,
+  entries: readonly [unknown, number][],
+): EnumMemberMetadata[] {
+  return entries.map(([, index]) => ({
+    name: schema["x-enum-varnames"]?.[index] ?? schema["x-enumNames"]?.[index],
+    description: schema["x-enum-descriptions"]?.[index] ?? schema["x-enumDescriptions"]?.[index],
+  }));
+}
+
+/**
+ * Whether `null` is a valid value: it is in `enum` and the schema's type admits it (`type`
+ * absent or listing `"null"`, or OpenAPI 3.0 `nullable: true`). Both keywords must pass.
+ */
+function isNullAllowed(schema: SchemaObject): boolean {
+  const { type } = schema;
+  const isTypeNullable =
+    type === undefined ||
+    (Array.isArray(type) && type.includes("null")) ||
+    Boolean(schema.nullable);
+  return (schema.enum ?? []).includes(null) && isTypeNullable;
+}
+
+/**
+ * `additionalProperties: true` on a string enum keeps other strings allowed but still offers the
+ * listed values in editors: `"a" | "b" | (string & {})`.
+ */
+function withOtherStrings(type: IrType, schema: SchemaObject): IrType {
+  if (!hasAdditionalProperties(schema) || schema.type !== "string") {
+    return type;
+  }
+  return unionOf([type, intersectionOf([irKeyword("string"), irObject([])])]);
+}
+
+/** The enum declaration of `schema` typed at `path`; its values are strings and numbers. */
+function enumRequest(
+  schema: SchemaObject,
+  path: string | undefined,
+  options: SchemaOptions,
+): EnumDeclarationRequest {
+  const entries = tsEnumEntries(schema, options);
+  return {
+    name: nameFromPath(path),
+    isComponentSchema: COMPONENT_SCHEMA_RE.test(path ?? ""),
+    values: entries.map(([value]) => value as string | number),
+    metadata: enumMetadata(schema, entries),
+  };
+}
+
+/** One member's type; a quoted member cannot follow a dot, `typeof E["+"]` is the same type. */
+function enumMemberType(enumName: string, member: string): IrType {
+  return member.startsWith('"')
+    ? irIndexedAccess(irReference(`typeof ${enumName}`), irString(JSON.parse(member), "escaped"))
+    : irReference(`${enumName}.${member}`);
+}
+
+/**
+ * The `discriminator-values` fix: a member's discriminator value is typed with members of
+ * the owner's enum (`PetType.Cat`), so the member is one of the owner's type (#1700). `key` is the
+ * enum the scan added or the inherited discriminator object. Null when the fix is off, or the
+ * owner's property is no TypeScript enum with every value.
+ */
+export function ownerEnumMembersType(
+  key: object,
+  values: readonly unknown[],
+  request: SchemaRequest,
+): IrType | null {
+  const { options, discriminators, footer } = request.context;
+  const parent: DiscriminatorEnumParent | undefined = options.fixes.has(
+    OutputFix.DISCRIMINATOR_VALUES,
+  )
+    ? discriminators.enumParentOf(key)
+    : undefined;
+  if (parent === undefined || !isTsEnum(parent.schema, options)) {
+    return null;
+  }
+  const reference = { ...enumRequest(parent.schema, parent.path, options), isOwnerReference: true };
+  const name = footer.addEnum(reference);
+  const members = footer.enumMembers(name);
+  const names = values.map((value) => members.get(value as string | number));
+  if (names.length === 0 || names.some((member) => member === undefined)) {
+    return null;
+  }
+  return unionOf(names.map((member) => enumMemberType(name, member as string)));
+}
+
+function tsEnumType(schema: SchemaObject, request: SchemaRequest): IrType {
+  const { options, footer } = request.context;
+  // `isTsEnum` admits only strings and numbers, and the fix leaves `null` out of the members.
+  const values = tsEnumEntries(schema, options).map(([value]) => value);
+  const type =
+    ownerEnumMembersType(schema, values, request) ??
+    withOtherStrings(
+      irReference(footer.addEnum(enumRequest(schema, request.location.path, options))),
+      schema,
+    );
+  return options.fixes.has(OutputFix.NULLABLE_ENUMS) && isNullAllowed(schema)
+    ? unionOf([type, irKeyword("null")])
+    : type;
+}
+
+function isUnionPosition(pointer: readonly string[], index: number): boolean {
+  const next = pointer[index + 1];
+  return UNION_KEYWORDS.has(pointer[index] as string) && next !== undefined && INDEX_RE.test(next);
+}
+
+const PARAMETERS = "parameters";
+
+/** Where the `parameters` of a path item sit in its pointer: `paths/<key>/…`, `components/…`. */
+function pathItemParametersIndex(pointer: readonly string[]): number | null {
+  if (pointer[0] === "paths" || pointer[0] === "webhooks") {
+    return 2;
+  }
+  return pointer[0] === "components" && pointer[1] === "pathItems" ? 3 : null;
+}
+
+/**
+ * The location of a path item parameter repeats `parameters` (`paths/~1a/parameters/parameters/
+ * path/id`), which keeps the generated names as they were. The generated type has the segment
+ * once: `paths["/a"]["parameters"]["path"]["id"]`.
+ */
+function withSingleParametersSegment(pointer: readonly string[]): readonly string[] {
+  const index = pathItemParametersIndex(pointer);
+  const isRepeated =
+    index !== null && pointer[index] === PARAMETERS && pointer[index + 1] === PARAMETERS;
+  return isRepeated ? [...pointer.slice(0, index), ...pointer.slice(index + 1)] : pointer;
+}
+
+/**
+ * The pointer of `--enum-values` arrays without union positions (`anyOf/0`), so names stay
+ * stable. Every property after the first union position is narrowed with `Extract`: a no-op where
+ * all variants have it, and the needed narrowing where only some do.
+ */
+function enumValuesPointer(path: string | undefined): { ref: string; extract: string[] } {
+  const pointer = withSingleParametersSegment(parseRefPointer(path ?? ""));
+  const kept: string[] = [];
+  let firstVariantStart: number | null = null;
+  for (let index = 0; index < pointer.length; index++) {
+    if (isUnionPosition(pointer, index)) {
+      firstVariantStart ??= index + 2;
+      index++;
+      continue;
+    }
+    kept.push(pointer[index] as string);
+  }
+  const extract =
+    firstVariantStart === null
+      ? []
+      : pointer
+          .slice(firstVariantStart)
+          .filter((segment) => !UNION_KEYWORDS.has(segment) && !INDEX_RE.test(segment));
+  return { ref: createRef(kept), extract };
+}
+
+function addEnumValues(schema: SchemaObject, request: SchemaRequest): void {
+  const { ref, extract } = enumValuesPointer(request.location.path);
+  const valuesType = refType(ref, { isDeep: true, extractProperties: extract });
+  request.context.footer.addEnumValues({
+    name: `${nameFromPath(request.location.path)}Values`,
+    // A record value (`additionalProperties`) is reached by indexing with `string`.
+    type: request.isFromAdditionalProperties
+      ? irIndexedAccess(valuesType, irReference("string"))
+      : valuesType,
+    values: (schema.enum ?? []) as (string | number)[],
+  });
+}
+
+function literalEnumType(schema: SchemaObject, request: SchemaRequest): IrType {
+  const values = schema.enum ?? [];
+  const isNullable =
+    (Array.isArray(schema.type) && schema.type.includes("null")) || Boolean(schema.nullable);
+  const literals = [...values.map(literalType), ...(isNullable ? [irKeyword("null")] : [])];
+  const type = withOtherStrings(unionOf(literals), schema);
+  const isListable = values.every(
+    (value) => typeof value === "string" || typeof value === "number",
+  );
+  if (request.context.options.enumValues && isListable) {
+    addEnumValues(schema, request);
+  }
+  return type;
+}
+
+/**
+ * `enum` on anything but an object (object enums are handled as `oneOf`). With
+ * `additionalProperties`, only string enums are handled here; others fall through to composition.
+ */
+export const enumRule: SchemaRule = {
+  name: "enum",
+  matches(schema) {
+    const isCandidate =
+      Array.isArray(schema.enum) && schema.type !== "object" && !("properties" in schema);
+    return isCandidate && (!hasAdditionalProperties(schema) || schema.type === "string");
+  },
+  transform(schema, request) {
+    return isTsEnum(schema, request.context.options)
+      ? tsEnumType(schema, request)
+      : literalEnumType(schema, request);
+  },
+};

package/src/application/transform/schema/inherited-discriminator.ts

@@ -0,0 +1,54 @@
+import type { IrMember } from "../../../domain/ir/nodes.js";
+import { unionAt, unionReaches } from "../../../domain/openapi/discriminated-union.js";
+import type { SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { discriminatorProperty } from "./discriminator-property.js";
+import { ownerEnumMembersType } from "./enum-rule.js";
+import type { Discriminator } from "./schema-context.js";
+import type { SchemaRequest } from "./schema-rule.js";
+
+/**
+ * Whether the schema at `path` is a union that its own members inherit from (upstream #1665).
+ * Each member sets the discriminator value, so a value of the union's own would make every member
+ * `never`. The union's own keywords, which its members get, are typed at the same path.
+ */
+function isInheritedUnion(path: string, request: SchemaRequest): boolean {
+  const resolve = (ref: string) => request.context.refs.resolve(ref);
+  const union = unionAt(path, resolve);
+  return union !== undefined && unionReaches(union, path, resolve);
+}
+
+/** A discriminator a parent's mapping implies for the schema at `path`. */
+export interface InheritedDiscriminator {
+  readonly discriminator: Discriminator;
+  readonly path: string;
+}
+
+/**
+ * The discriminator a parent's mapping implies for this schema, if it adds a property. A schema
+ * with no path (a caller's own schema) is no component, so no mapping names it.
+ */
+export function inheritedDiscriminator(
+  schema: SchemaObject,
+  request: SchemaRequest,
+): InheritedDiscriminator | undefined {
+  const { path } = request.location;
+  if ((!schema.allOf && !schema.anyOf) || path === undefined) {
+    return undefined;
+  }
+  const { discriminators } = request.context;
+  // A schema does not get the discriminator it defines for its children, nor one added already.
+  const isAdded = !schema.discriminator && !discriminators.isHandled(path);
+  const discriminator = isAdded ? discriminators.objectAt(path) : undefined;
+  return discriminator && !isInheritedUnion(path, request) ? { discriminator, path } : undefined;
+}
+
+/** The property of an inherited discriminator, typed as the schema's value. */
+export function discriminatorMember(
+  { discriminator, path }: InheritedDiscriminator,
+  request: SchemaRequest,
+): IrMember {
+  // With `discriminator-values`, the value is a member of the owner's enum (#1700).
+  const valueType = (value: string | undefined) =>
+    ownerEnumMembersType(discriminator, [value], request);
+  return discriminatorProperty(discriminator, path, request.context.options.immutable, valueType);
+}

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

@@ -0,0 +1,289 @@
+import { ERROR_CODES, OpenAPITypesafeError } from "../../../domain/errors.js";
+import {
+  irObject,
+  irProperty,
+  irReference,
+  irStringIndexSignature,
+} from "../../../domain/ir/constructors.js";
+import type { IrMember, IrPropertySignature, IrType } from "../../../domain/ir/nodes.js";
+import { toPropertyName } from "../../../domain/ir/property-name.js";
+import { createRef } from "../../../domain/openapi/json-pointer.js";
+import type { Schema, SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { documentEntries } from "../document-entries.js";
+import { schemaRefType } from "../ref-pointer/pointer-type.js";
+import { schemaCommentOptionsOf, withSchemaComment } from "../schema-comment.js";
+import { UNKNOWN_TYPE } from "../shared-types.js";
+import { intersectionOf, unionOf } from "../type-combinators.js";
+import { type AccessFlags, propertyAccessFlags } from "./access-flags.js";
+import { discriminatorMember, inheritedDiscriminator } from "./inherited-discriminator.js";
+import type { SchemaOptions } from "./schema-context.js";
+import type { SchemaRequest } from "./schema-rule.js";
+
+/** Path parts where a default value cannot make a property required (inputs may omit it). */
+const INPUT_PATH_PARTS = ["parameters", "requestBody", "requestBodies"] as const;
+
+export class InvalidPropertyError extends OpenAPITypesafeError {
+  constructor(path: string | undefined, key: string, value: unknown) {
+    const received = Array.isArray(value) ? "Array" : typeof value;
+    super({
+      code: ERROR_CODES.SCHEMA_PROPERTY_INVALID,
+      message:
+        `${path}: invalid property ${key}. ` + `Expected Schema Object or boolean, got ${received}`,
+      details: { path, property: key, received },
+    });
+    this.name = "InvalidPropertyError";
+  }
+}
+
+/** `--read-write-markers`: `$Read<T>` / `$Write<T>`, unless the property is both or neither. */
+function withReadWriteMarker(type: IrType, flags: AccessFlags, options: SchemaOptions): IrType {
+  if (!options.readWriteMarkers || flags.isReadOnly === flags.isWriteOnly) {
+    return type;
+  }
+  return irReference(flags.isReadOnly ? "$Read" : "$Write", [type]);
+}
+
+/** Apply `transformProperty`, then the schema's JSDoc. */
+function finishProperty(
+  property: IrPropertySignature,
+  schema: Schema,
+  path: string,
+  request: SchemaRequest,
+): IrPropertySignature {
+  const location = { ...request.location, path };
+  const transformed =
+    request.context.callbacks.transformProperty(property, schema, location) ?? property;
+  // The original adds the schema's comment after any comment the callback set.
+  return withSchemaComment(
+    transformed,
+    schema,
+    schemaCommentOptionsOf(request.context.options.fixes),
+  );
+}
+
+/** What the property loop reads from a property schema, in the original order. */
+interface PropertyFacts {
+  readonly ref: string | undefined;
+  readonly flags: AccessFlags;
+  readonly hasDefault: boolean;
+}
+
+function propertyFacts(value: Schema, request: SchemaRequest): PropertyFacts {
+  if (typeof value !== "object") {
+    return { ref: undefined, flags: { isReadOnly: false, isWriteOnly: false }, hasDefault: false };
+  }
+  // `in` throws for a null value, as in the original (which also reads `$ref` first).
+  const ref = "$ref" in value && value.$ref ? value.$ref : undefined;
+  const flags = propertyAccessFlags(value, request.context);
+  return { ref, flags, hasDefault: "default" in value && value.default !== undefined };
+}
+
+function isOptionalProperty(
+  key: string,
+  facts: PropertyFacts,
+  schema: SchemaObject,
+  request: SchemaRequest,
+): boolean {
+  const { options } = request.context;
+  const path = request.location.path;
+  const isDefaultRequired =
+    facts.hasDefault &&
+    options.defaultNonNullable &&
+    !INPUT_PATH_PARTS.some((part) => path?.includes(part));
+  const isRequired =
+    schema.required?.includes(key) ||
+    (schema.required === undefined && options.propertiesRequiredByDefault) ||
+    isDefaultRequired;
+  return !isRequired;
+}
+
+function isExcluded(value: Schema, facts: PropertyFacts, request: SchemaRequest): boolean {
+  if (!request.context.options.excludeDeprecated) {
+    return false;
+  }
+  const resolved = facts.ref ? request.context.refs.resolve(facts.ref) : value;
+  return Boolean((resolved as SchemaObject | undefined)?.deprecated);
+}
+
+/** A type, and whether a callback forced the property optional (null: no override). */
+interface CustomResult {
+  readonly type: IrType;
+  readonly isOptional: true | null;
+}
+
+function propertyType(
+  key: string,
+  value: Schema,
+  facts: PropertyFacts,
+  request: SchemaRequest,
+): CustomResult {
+  const path = createRef([request.location.path, key]);
+  const type = facts.ref
+    ? schemaRefType(facts.ref, request)
+    : request.transformNested(value, { ...request.location, path });
+  const custom = request.context.callbacks.transform(value, request.location);
+  return custom === null
+    ? { type, isOptional: null }
+    : { type: custom.type, isOptional: custom.isOptional || null };
+}
+
+function propertyMember(
+  key: string,
+  value: Schema,
+  schema: SchemaObject,
+  request: SchemaRequest,
+): IrMember | null {
+  if ((typeof value !== "object" && typeof value !== "boolean") || Array.isArray(value)) {
+    throw new InvalidPropertyError(request.location.path, key, value);
+  }
+  const facts = propertyFacts(value, request);
+  if (isExcluded(value, facts, request)) {
+    return null;
+  }
+  const { options } = request.context;
+  const isOptional = isOptionalProperty(key, facts, schema, request);
+  const result = propertyType(key, value, facts, request);
+  const property = irProperty(
+    toPropertyName(key),
+    withReadWriteMarker(result.type, facts.flags, options),
+    {
+      isOptional: result.isOptional ?? isOptional,
+      isReadonly: options.immutable || (!options.readWriteMarkers && facts.flags.isReadOnly),
+    },
+  );
+  return finishProperty(property, value, createRef([request.location.path, key]), request);
+}
+
+function propertyMembers(schema: SchemaObject, request: SchemaRequest): IrMember[] {
+  const members: IrMember[] = [];
+  for (const [key, value] of documentEntries(schema.properties ?? {}, request.context.options)) {
+    const member = propertyMember(key, value, schema, request);
+    if (member !== null) {
+      members.push(member);
+    }
+  }
+  return members;
+}
+
+/**
+ * `$defs` as a nested `$defs?: { … }` member, in document order (never alphabetized). It is
+ * optional because `$defs` is a schema keyword, not data: the original made it required, so a
+ * value of the type needed a `$defs` key (research/legacy-bugs.md, item 17, upstream #2664).
+ */
+function defsMember(
+  defs: Readonly<Record<string, SchemaObject>>,
+  request: SchemaRequest,
+): IrMember {
+  const { options } = request.context;
+  const members = Object.entries(defs).map(([key, value]) => {
+    const path = createRef([request.location.path, "$defs", key]);
+    const flags = propertyAccessFlags(value, request.context);
+    const type = withReadWriteMarker(
+      request.transformNested(value, { ...request.location, path }),
+      flags,
+      options,
+    );
+    const property = irProperty(toPropertyName(key), type, {
+      isReadonly: options.immutable || (!options.readWriteMarkers && flags.isReadOnly),
+    });
+    return finishProperty(property, value, path, request);
+  });
+  return irProperty(toPropertyName("$defs"), irObject(members), { isOptional: true });
+}
+
+function hasObjectKeywords(schema: SchemaObject): boolean {
+  const hasProperties = Boolean(schema.properties && Object.keys(schema.properties).length);
+  return (
+    hasProperties ||
+    Boolean(schema.additionalProperties || schema.patternProperties || schema.$defs)
+  );
+}
+
+/** Value types of the `[key: string]` index signature, in the original order. */
+function indexValueTypes(schema: SchemaObject, request: SchemaRequest): IrType[] {
+  const { additionalProperties } = schema;
+  const isObject = typeof additionalProperties === "object";
+  const hasExplicit = isObject && Object.keys(additionalProperties).length > 0;
+  const hasImplicit =
+    additionalProperties === true || (isObject && Object.keys(additionalProperties).length === 0);
+  const types: IrType[] = [];
+  if (hasExplicit) {
+    types.push(request.transformNested(additionalProperties as Schema, request.location, true));
+  }
+  if (hasImplicit || (!additionalProperties && request.context.options.additionalProperties)) {
+    types.push(UNKNOWN_TYPE);
+  }
+  const patterns = schema.patternProperties;
+  if (typeof patterns === "object" && patterns !== null && Object.keys(patterns).length > 0) {
+    for (const [, value] of documentEntries(patterns, request.context.options)) {
+      types.push(request.transformNested(value, request.location));
+    }
+  }
+  return types;
+}
+
+/**
+ * Whether the schema declares property `key` and the type keeps it: `--exclude-deprecated` drops
+ * a deprecated one.
+ */
+export function isKeptProperty(schema: SchemaObject, key: string, request: SchemaRequest): boolean {
+  const properties = schema.properties ?? {};
+  if (!Object.hasOwn(properties, key)) {
+    return false;
+  }
+  const value = properties[key] as Schema;
+  const isExcludable = request.context.options.excludeDeprecated && typeof value === "object";
+  return !isExcludable || !isExcluded(value, propertyFacts(value, request), request);
+}
+
+/**
+ * The members for the discriminator and `properties`. A schema that declares the discriminator
+ * property itself keeps its own declaration, required as the discriminator needs: both in one
+ * object type do not compile (TS2300, the Apple SiriKit Cloud Media API). A declaration that
+ * `--exclude-deprecated` drops does not count, so the discriminator property stays.
+ */
+function discriminatorAndPropertyMembers(schema: SchemaObject, request: SchemaRequest): IrMember[] {
+  const inherited = inheritedDiscriminator(schema, request);
+  if (inherited === undefined) {
+    return propertyMembers(schema, request);
+  }
+  const name = inherited.discriminator.propertyName;
+  if (!isKeptProperty(schema, name, request)) {
+    return [discriminatorMember(inherited, request), ...propertyMembers(schema, request)];
+  }
+  // Without `required`, `--properties-required-by-default` requires every property already; a
+  // list of one would make the others optional.
+  const isAllRequired =
+    schema.required === undefined && request.context.options.propertiesRequiredByDefault;
+  const required = isAllRequired ? undefined : [...(schema.required ?? []), name];
+  return propertyMembers({ ...schema, required } as SchemaObject, request);
+}
+
+/**
+ * Object keywords: discriminator, `properties`, `$defs`, and an index signature for
+ * `additionalProperties` / `patternProperties` (or `--additional-properties`). Null when the schema
+ * has none of them.
+ */
+export function objectType(schema: SchemaObject, request: SchemaRequest): IrType | null {
+  if (!hasObjectKeywords(schema)) {
+    const inherited = inheritedDiscriminator(schema, request);
+    return inherited ? irObject([discriminatorMember(inherited, request)]) : null;
+  }
+  const members = discriminatorAndPropertyMembers(schema, request);
+  // As in the original, a null `$defs` throws here (Object.keys) instead of being skipped.
+  if (
+    "$defs" in schema &&
+    typeof schema.$defs === "object" &&
+    Object.keys(schema.$defs).length > 0
+  ) {
+    members.push(defsMember(schema.$defs, request));
+  }
+  const valueTypes = indexValueTypes(schema, request);
+  if (valueTypes.length === 0) {
+    return members.length > 0 ? irObject(members) : null;
+  }
+  const index = irObject([
+    irStringIndexSignature("key", unionOf(valueTypes), request.context.options.immutable),
+  ]);
+  return intersectionOf([...(members.length > 0 ? [irObject(members)] : []), index]);
+}