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

package/src/api/unsupported-feature-warnings.ts

@@ -3,6 +3,7 @@ import {
   findUnsupportedFeatures,
   UnsupportedFeature,
 } from "../domain/openapi/unsupported-features.js";
+import { WARNING_CODES, type WarningCode, warningText } from "../domain/warnings.js";
 
 const DOCS_BASE_URL = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs";
 const SUPPORT_DOCS_URL = `${DOCS_BASE_URL}/introduction.md#openapi-3-2-support`;
@@ -15,12 +16,18 @@ const REASONS: Readonly<Record<UnsupportedFeature, string>> = {
     "generated types",
 };
 
+/** The warning code of each feature. */
+const CODES: Readonly<Record<UnsupportedFeature, WarningCode>> = {
+  [UnsupportedFeature.QUERYSTRING_NEXT_TO_QUERY]: WARNING_CODES.QUERYSTRING_NEXT_TO_QUERY,
+};
+
 /**
  * Warn once per use of an OpenAPI 3.2 feature that the generated types leave out, so a missing
  * parameter is never silent (CODING_PRINCIPLES §8.7).
  */
 export function warnUnsupportedFeatures(document: unknown, logger: Logger): void {
   for (const { feature, pointer } of findUnsupportedFeatures(document)) {
-    logger.warn(`${pointer} ${REASONS[feature]}. See ${SUPPORT_DOCS_URL}`);
+    const message = `${pointer} ${REASONS[feature]}. See ${SUPPORT_DOCS_URL}`;
+    logger.warn(warningText(message, CODES[feature]));
   }
 }

package/src/application/ports/redocly-config-source.ts

@@ -10,7 +10,11 @@ export interface RedoclyConfigSource {
    * from the working directory. Undefined when there is none.
    */
   find(explicitPath: string | undefined): string | undefined;
+  /** The config of a file; fails with `CLI_CONFIG_INVALID` when it or its ignore file is bad. */
   load(configPath: string): Promise<RedoclyConfig>;
-  /** The config used when there is no file: the minimal rules. */
+  /**
+   * The config used when there is no file: the minimal rules. Fails with `CLI_CONFIG_INVALID`
+   * when the ignore file of the working directory is bad.
+   */
   createDefault(): Promise<RedoclyConfig>;
 }

package/src/application/print/type-printer.ts

@@ -135,6 +135,12 @@ function writeTupleElement(writer: TextWriter, element: IrTupleElement): void {
   if (element.isRest) {
     writer.write("...");
   }
+  if (element.isOptional) {
+    // TypeScript parenthesizes an optional element as a postfix operand (`(A | B)?`).
+    writeTypeIn(writer, element.type, needsParensAsPostfixOperand);
+    writer.write("?");
+    return;
+  }
   writeType(writer, element.type);
 }
 

package/src/application/transform/document/assignability.ts

@@ -0,0 +1,203 @@
+import type { IrObjectType, IrPropertySignature, IrType } from "../../../domain/ir/nodes.js";
+import { indexSignaturesOf, nameOf, propertiesOf } from "./type-resolution.js";
+
+/**
+ * What the `--path-params-as-types` overlap check knows about one type where another is expected.
+ * `assignable` and `rejected` are proofs of what TypeScript decides (`strict`, without
+ * `exactOptionalPropertyTypes`); `undecided` is a pair the check does not model, such as a utility
+ * type or raw text. Only a rejection changes the output, so an undecided pair keeps the original.
+ */
+export type Assignability = "assignable" | "rejected" | "undecided";
+
+/**
+ * All of the relations: rejected when one is, assignable when each is. The relations are computed
+ * lazily, so a rejection stops the rest.
+ */
+export function everyOf<T>(
+  items: readonly T[],
+  relate: (item: T, index: number) => Assignability,
+): Assignability {
+  let result: Assignability = "assignable";
+  for (const [index, item] of items.entries()) {
+    const each = relate(item, index);
+    if (each === "rejected") {
+      return "rejected";
+    }
+    if (each === "undecided") {
+      result = "undecided";
+    }
+  }
+  return result;
+}
+
+/** One of the relations: assignable when one is, rejected when each is. */
+export function someOf<T>(items: readonly T[], relate: (item: T) => Assignability): Assignability {
+  let result: Assignability = "rejected";
+  for (const item of items) {
+    const each = relate(item);
+    if (each === "assignable") {
+      return "assignable";
+    }
+    if (each === "undecided") {
+      result = "undecided";
+    }
+  }
+  return result;
+}
+
+/** Assignable when the condition holds, rejected when it does not. */
+export function provenBy(condition: boolean): Assignability {
+  return condition ? "assignable" : "rejected";
+}
+
+/**
+ * The kinds of resolved types the check tells apart. A type of one kind is never assignable to a
+ * type of another, except that a primitive or a list may fit an object type (`string` fits
+ * `{ length: number }`), which the check models only in part. `opaque` is any type it cannot
+ * read.
+ */
+type TypeCategory = "primitive" | "list" | "object" | "opaque";
+
+function categoryOf(type: IrType): TypeCategory {
+  switch (type.kind) {
+    case "keyword":
+    case "stringLiteral":
+    case "numberLiteral":
+    case "booleanLiteral":
+      return "primitive";
+    case "array":
+    case "tuple":
+    case "readonly":
+      return "list";
+    case "object":
+      return "object";
+    default:
+      return "opaque";
+  }
+}
+
+/** Keywords that are no object: `{}` rejects them under `strictNullChecks`. */
+const NO_OBJECT_KEYWORDS: ReadonlySet<string> = new Set(["null", "undefined", "unknown", "never"]);
+
+/**
+ * The members of `ReadonlyArray` and `Array` in the TypeScript libraries up to ESNext. An object
+ * type that needs a property of another name is no list; a numeric name may be a tuple element.
+ */
+const ARRAY_MEMBER_NAMES: ReadonlySet<string> = new Set([
+  "length",
+  "toString",
+  "toLocaleString",
+  "pop",
+  "push",
+  "concat",
+  "join",
+  "reverse",
+  "shift",
+  "slice",
+  "sort",
+  "splice",
+  "unshift",
+  "indexOf",
+  "lastIndexOf",
+  "every",
+  "some",
+  "forEach",
+  "map",
+  "filter",
+  "reduce",
+  "reduceRight",
+  "find",
+  "findIndex",
+  "fill",
+  "copyWithin",
+  "entries",
+  "keys",
+  "values",
+  "includes",
+  "flatMap",
+  "flat",
+  "at",
+  "findLast",
+  "findLastIndex",
+  "toReversed",
+  "toSorted",
+  "toSpliced",
+  "with",
+]);
+
+const ARRAY_LENGTH = "length";
+/** A tuple element's name: `"0"`, `"1"`. */
+const ELEMENT_NAME_RE = /^\d+$/;
+
+function isListMemberName(name: string): boolean {
+  return ARRAY_MEMBER_NAMES.has(name) || ELEMENT_NAME_RE.test(name);
+}
+
+/**
+ * Whether a list fits an object type. It does not when the object needs a property no list has
+ * (TS2741), or when the object is a weak type and no list has one of its properties (TS2559).
+ */
+function listToObject(target: IrObjectType): Assignability {
+  const properties = [...propertiesOf(target).values()];
+  const isForeign = (property: IrPropertySignature) => !isListMemberName(nameOf(property));
+  const needsForeign = properties.some((property) => !property.isOptional && isForeign(property));
+  const isWeak =
+    properties.length > 0 &&
+    indexSignaturesOf(target).length === 0 &&
+    properties.every((property) => property.isOptional);
+  return needsForeign || (isWeak && properties.every(isForeign)) ? "rejected" : "undecided";
+}
+
+/**
+ * Whether a primitive fits an object type: `null`, `undefined` and `unknown` never do; any other
+ * may (`{}`, `{ length: number }`), which is not modelled.
+ */
+function primitiveToObject(source: IrType): Assignability {
+  const isNoObject = source.kind === "keyword" && NO_OBJECT_KEYWORDS.has(source.keyword);
+  return isNoObject ? "rejected" : "undecided";
+}
+
+/** An object type fits an array only with all of its members; `length` is the first it needs. */
+function objectToList(source: IrObjectType): Assignability {
+  return propertiesOf(source).has(ARRAY_LENGTH) ? "undecided" : "rejected";
+}
+
+/**
+ * The relation of two types of different categories, or null when they are of the same one.
+ * Primitive and list targets accept nothing of another category; see `TypeCategory`.
+ */
+export function crossCategoryRelation(source: IrType, target: IrType): Assignability | null {
+  const from = categoryOf(source);
+  const to = categoryOf(target);
+  if (from === "opaque" || to === "opaque") {
+    return "undecided";
+  }
+  if (from === to) {
+    return null;
+  }
+  if (to !== "object") {
+    return source.kind === "object" && to === "list" ? objectToList(source) : "rejected";
+  }
+  return from === "primitive" ? primitiveToObject(source) : listToObject(target as IrObjectType);
+}
+
+/** The keyword a literal type belongs to. */
+const LITERAL_KEYWORDS = {
+  stringLiteral: "string",
+  numberLiteral: "number",
+  booleanLiteral: "boolean",
+} as const;
+
+/**
+ * The relation of two primitive types written differently (the same text is assignable). A
+ * literal fits its keyword; any other pair is rejected: different keywords, different literals,
+ * a keyword for one literal (a union of literals is compared in `type-assignability.ts`), and
+ * anything for `never`.
+ */
+export function primitiveRelation(source: IrType, target: IrType): Assignability {
+  if (target.kind !== "keyword" || source.kind === "keyword") {
+    return "rejected";
+  }
+  const keyword = (LITERAL_KEYWORDS as Partial<Record<IrType["kind"], string>>)[source.kind];
+  return provenBy(keyword === target.keyword);
+}

package/src/application/transform/document/components.ts

@@ -23,7 +23,7 @@ import { OutputFix } from "../../../domain/output-fixes.js";
 import { type DeprecatedEntryFilter, documentEntries } from "../document-entries.js";
 import type { SchemaLocation } from "../schema/schema-context.js";
 import { transformSchema } from "../schema/schema-transform.js";
-import { withSchemaComment } from "../schema-comment.js";
+import { schemaCommentOptionsOf, withSchemaComment } from "../schema-comment.js";
 import type { TransformContext } from "../transform-context.js";
 import { headerType } from "./header.js";
 import { contentEntryType } from "./media-type.js";
@@ -31,7 +31,7 @@ import { parameterType } from "./parameter.js";
 import { pathItemType } from "./path-item.js";
 import { requestBodyType } from "./request-body.js";
 import { responseType } from "./response.js";
-import { numberDisplacedAliases, rootTypeAlias } from "./root-type-aliases.js";
+import { rootTypeAlias } from "./root-type-aliases.js";
 
 type ComponentTransform = (
   item: never,
@@ -69,7 +69,7 @@ function componentMember(
     isOptional: custom?.isOptional ?? false,
     isReadonly: context.options.immutable,
   });
-  return withSchemaComment(property, item);
+  return withSchemaComment(property, item, schemaCommentOptionsOf(context.options.fixes));
 }
 
 /**
@@ -112,8 +112,8 @@ function rootTypeName(
  * Add a root alias. When its exported name is taken (two schemas of one PascalCase name without
  * the prefix), the later schema takes the name, as in the original. Without the
  * `root-type-numbering` fix the earlier one then has no alias: that output is valid, so a number
- * for it would change it (backlog 30). With the fix the earlier alias is kept aside and numbered
- * at the end.
+ * for it would change it (backlog 30). With the fix the earlier alias is kept aside and follows
+ * the others under the same name; `renameTakenAliases` numbers it once every name is known.
  */
 function addRootAlias(request: ComponentsRequest, alias: IrTypeAliasDeclaration): void {
   const { aliases, displaced } = request;
@@ -184,6 +184,6 @@ export function componentsType(
   const rootTypes = Object.values(aliases);
   return {
     type: irObject(members),
-    rootTypes: [...rootTypes, ...numberDisplacedAliases(displaced ?? [], rootTypes)],
+    rootTypes: [...rootTypes, ...(displaced ?? [])],
   };
 }

package/src/application/transform/document/declared-types.ts

@@ -0,0 +1,93 @@
+import type { IrDeclaration, IrMember, IrType } from "../../../domain/ir/nodes.js";
+
+/**
+ * The type a reference of the generated file names, read from the file's declarations: the
+ * `--path-params-as-types` overlap check compares two path items through the operations and
+ * components they reference (upstream #1752).
+ */
+
+/** The declared type a reference names, or null when the type is no such reference. */
+export type DeclaredTypeLookup = (type: IrType) => IrType | null;
+
+/** Knows no declaration: every reference stays unresolved. */
+export const NO_DECLARED_TYPES: DeclaredTypeLookup = () => null;
+
+/** A reference without type arguments and the string keys indexing it: `components["schemas"]`. */
+interface IndexedName {
+  readonly name: string;
+  readonly keys: readonly string[];
+}
+
+function indexedNameOf(type: IrType): IndexedName | null {
+  if (type.kind === "reference") {
+    return type.typeArguments.length === 0 ? { name: type.name, keys: [] } : null;
+  }
+  if (type.kind !== "indexedAccess" || type.index.kind !== "stringLiteral") {
+    return null;
+  }
+  const object = indexedNameOf(type.object);
+  return object === null ? null : { ...object, keys: [...object.keys, type.index.value] };
+}
+
+function memberName(member: IrMember): string | null {
+  if (member.kind !== "property") {
+    return null;
+  }
+  return member.name.kind === "string" ? member.name.value : member.name.text;
+}
+
+/**
+ * The type of the required property `key`. An optional one is `T | undefined` when indexed, which
+ * is not the declared type, so it is not followed.
+ */
+function propertyType(type: IrType, key: string): IrType | null {
+  if (type.kind !== "object") {
+    return null;
+  }
+  const member = type.members.find((candidate) => memberName(candidate) === key);
+  return member?.kind === "property" && !member.isOptional ? member.type : null;
+}
+
+function declarationType(declaration: IrDeclaration): IrType | null {
+  switch (declaration.kind) {
+    case "interface":
+      return { kind: "object", members: declaration.members };
+    case "typeAlias":
+      return declaration.type;
+    case "enum":
+    case "constArray":
+    case "rawDeclaration":
+      return null;
+  }
+}
+
+/**
+ * A lookup over the declarations. Only a name declared once is read: a second declaration of an
+ * interface merges with the first, which this lookup does not model.
+ */
+export function declaredTypeLookup(declarations: readonly IrDeclaration[]): DeclaredTypeLookup {
+  const byName = new Map<string, IrType | null>();
+  for (const declaration of declarations) {
+    if ("name" in declaration && declaration.name !== undefined) {
+      const isRepeated = byName.has(declaration.name);
+      byName.set(declaration.name, isRepeated ? null : declarationType(declaration));
+    }
+  }
+  // References being resolved: a reference that indexes into itself names no type.
+  const resolving = new Set<IrType>();
+  const lookup: DeclaredTypeLookup = (type) => {
+    const indexed = indexedNameOf(type);
+    if (indexed === null || indexed.keys.length === 0 || resolving.has(type)) {
+      return null;
+    }
+    resolving.add(type);
+    // A key may index a property whose type is a reference again (`paths["/a"]["get"]`).
+    const declared = indexed.keys.reduce<IrType | null>((object, key) => {
+      const named = object === null || object.kind === "object" ? object : lookup(object);
+      return named === null ? null : propertyType(named, key);
+    }, byName.get(indexed.name) ?? null);
+    resolving.delete(type);
+    return declared;
+  };
+  return lookup;
+}

package/src/application/transform/document/document.ts

@@ -1,4 +1,4 @@
-import { irKeyword, irRecord } from "../../../domain/ir/constructors.js";
+import { irKeyword, irObject, irRecord } from "../../../domain/ir/constructors.js";
 import type {
   IrDeclaration,
   IrIntersectionType,
@@ -12,9 +12,10 @@ import type { PathsObject } from "../../../domain/openapi/path-item-object.js";
 import { READ_WRITE_MARKER_TYPES } from "../helper-types.js";
 import type { TransformContext, TransformOptions } from "../transform-context.js";
 import { componentsType } from "./components.js";
+import { type DeclaredTypeLookup, declaredTypeLookup } from "./declared-types.js";
 import { defsRootType } from "./defs-root.js";
 import { keptDeprecatedComponents } from "./kept-deprecated.js";
-import { pathsType } from "./paths.js";
+import { pathMembers, pathsObjectType } from "./paths.js";
 import { apiPathsEnumDeclaration } from "./paths-enum.js";
 import { webhooksType } from "./webhooks.js";
 
@@ -30,6 +31,11 @@ const EMPTY_ROOT_TYPE = irRecord(irKeyword("string"), irKeyword("never"));
 interface RootResult {
   readonly type: IrType;
   readonly aliases: readonly IrTypeAliasDeclaration[];
+  /**
+   * The root's final type, for a root that reads the types the whole file declares (`paths`, whose
+   * overlap check follows references). `type` then only tells whether the root has members.
+   */
+  readonly withDeclaredTypes?: (lookup: DeclaredTypeLookup) => IrType;
 }
 
 type RootTransform = (
@@ -46,7 +52,14 @@ function keptDeprecated(document: DocumentObject, context: TransformContext): Re
 }
 
 const ROOT_TRANSFORMS: Readonly<Record<RootKey, RootTransform>> = {
-  paths: (node, context) => ({ type: pathsType(node as PathsObject, context), aliases: [] }),
+  paths: (node, context) => {
+    const members = pathMembers(node as PathsObject, context);
+    return {
+      type: irObject(members.map(({ member }) => member)),
+      aliases: [],
+      withDeclaredTypes: (lookup) => pathsObjectType(members, lookup),
+    };
+  },
   webhooks: (node, context) => ({ type: webhooksType(node as PathsObject, context), aliases: [] }),
   components: (node, context, document) => {
     const kept = keptDeprecated(document, context);
@@ -84,6 +97,15 @@ function rootDeclaration(
     : { kind: "interface", name, isExported: true, members: type.members, comments: [] };
 }
 
+/**
+ * The declarations of one root: its type, then its aliases. `finish` gives the root's declaration
+ * again from the types the whole file declares, for a root with `withDeclaredTypes`.
+ */
+interface RootDeclarations {
+  readonly declarations: readonly IrDeclaration[];
+  readonly finish?: (lookup: DeclaredTypeLookup) => IrDeclaration;
+}
+
 /**
  * The declarations of one root. A root that is missing, or whose type has no members, is
  * `Record<string, never>`. Only an object type (or the `paths` intersection) counts as having
@@ -93,21 +115,51 @@ function rootDeclarations(
   root: RootKey,
   document: DocumentObject,
   context: TransformContext,
-): IrDeclaration[] {
+): RootDeclarations {
   const node: unknown = document[root];
   if (!node || typeof node !== "object") {
     context.diagnostics.debug(`${root} done (skipped)`, 0);
-    return [emptyAlias(root)];
+    return { declarations: [emptyAlias(root)] };
   }
   const startedAt = context.diagnostics.now();
-  const { type, aliases } = ROOT_TRANSFORMS[root](node, context, document);
+  const { type, aliases, withDeclaredTypes } = ROOT_TRANSFORMS[root](node, context, document);
   if (!isRootBody(type)) {
     context.diagnostics.debug(`${root} done (skipped)`, 0);
-    return [emptyAlias(root), ...aliases];
+    return { declarations: [emptyAlias(root), ...aliases] };
   }
   const declaration = rootDeclaration(root, type, context.options);
   context.diagnostics.debug(`${root} done`, context.diagnostics.now() - startedAt);
-  return [declaration, ...aliases];
+  const finish =
+    withDeclaredTypes &&
+    ((lookup: DeclaredTypeLookup) => {
+      const finished = withDeclaredTypes(lookup);
+      return isRootBody(finished) ? rootDeclaration(root, finished, context.options) : declaration;
+    });
+  return { declarations: [declaration, ...aliases], ...(finish ? { finish } : {}) };
+}
+
+/**
+ * Every root's declarations in output order. A root with `finish` gets its declaration from the
+ * types of the other roots and of the footer (the `operations` interface), which exist only once
+ * every root is transformed.
+ */
+function rootsDeclarations(
+  document: DocumentObject,
+  context: TransformContext,
+  footer: () => readonly IrDeclaration[],
+): IrDeclaration[] {
+  const roots = ROOT_KEYS.map((root) => rootDeclarations(root, document, context));
+  const transformed = roots.flatMap(({ declarations }) => declarations);
+  if (roots.every(({ finish }) => finish === undefined)) {
+    return transformed;
+  }
+  const lookup = declaredTypeLookup([...transformed, ...footer()]);
+  return roots.flatMap(({ declarations, finish }) => {
+    const [declaration, ...aliases] = declarations;
+    return finish === undefined || declaration === undefined
+      ? declarations
+      : [finish(lookup), ...aliases];
+  });
 }
 
 /**
@@ -118,11 +170,19 @@ function withoutBlankLinesAround(text: string): string {
   return text.replace(/^(?:[ \t]*\r?\n)+/, "").trimEnd();
 }
 
+/** No footer declarations: the roots' references to `operations` stay unresolved. */
+const NO_FOOTER = (): readonly IrDeclaration[] => [];
+
 /**
  * The document's declarations before the footer: helper types, injected code, then one root type
- * per root key with the aliases that follow it.
+ * per root key with the aliases that follow it. `footer` reads the footer's declarations once the
+ * roots are transformed.
  */
-export function documentBody(document: DocumentObject, context: TransformContext): IrDeclaration[] {
+export function documentBody(
+  document: DocumentObject,
+  context: TransformContext,
+  footer: () => readonly IrDeclaration[] = NO_FOOTER,
+): IrDeclaration[] {
   const declarations: IrDeclaration[] = [];
   if (context.options.readWriteMarkers) {
     declarations.push({ kind: "rawDeclaration", text: READ_WRITE_MARKER_TYPES });
@@ -131,9 +191,7 @@ export function documentBody(document: DocumentObject, context: TransformContext
   if (inject !== "") {
     declarations.push({ kind: "rawDeclaration", text: inject });
   }
-  for (const root of ROOT_KEYS) {
-    declarations.push(...rootDeclarations(root, document, context));
-  }
+  declarations.push(...rootsDeclarations(document, context, footer));
   return declarations;
 }
 

package/src/application/transform/document/exploded-query.ts

@@ -0,0 +1,91 @@
+import type { ParameterObject } from "../../../domain/openapi/parameter-object.js";
+import type { Schema, SchemaObject } from "../../../domain/openapi/schema-object.js";
+import type { RefResolver } from "../schema/schema-context.js";
+
+/**
+ * Exploded object query parameters (OpenAPI 3.2 §4.8.12.4, upstream #2361). A query parameter has
+ * `style: form` and, with it, `explode: true` by default. An object value is then sent as its own
+ * `key=value` pairs, `?page=1&limit=10`: the parameter's name is not in the URL. So with the
+ * `exploded-query-objects` fix, the object's properties are keys of `query`, not one key named
+ * after the parameter.
+ */
+
+const FORM_STYLE = "form";
+
+/** Whether a `$ref` chain has been followed already, so a cycle ends. */
+type SeenRefs = ReadonlySet<string>;
+
+function resolvedSchema(schema: Schema, refs: RefResolver, seen: SeenRefs): SchemaObject | null {
+  if (typeof schema !== "object" || schema === null) {
+    return null;
+  }
+  if (!("$ref" in schema)) {
+    return schema;
+  }
+  if (seen.has(schema.$ref)) {
+    return null;
+  }
+  const target = refs.resolve(schema.$ref) as Schema | undefined;
+  return target === undefined
+    ? null
+    : resolvedSchema(target, refs, new Set([...seen, schema.$ref]));
+}
+
+/** The types of a `type` keyword other than `null`; empty when it has none. */
+function nonNullTypes(schema: SchemaObject): readonly unknown[] {
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+  return types.filter((type) => type !== undefined && type !== null && type !== "null");
+}
+
+/** Whether every member of a composition is an object schema; false for an empty list. */
+function isObjectComposition(
+  members: readonly Schema[] | undefined,
+  refs: RefResolver,
+  seen: SeenRefs,
+): boolean {
+  return (
+    members !== undefined &&
+    members.length > 0 &&
+    members.every((member) => isObjectSchemaWith(member, refs, seen))
+  );
+}
+
+function isObjectSchemaWith(schema: Schema, refs: RefResolver, seen: SeenRefs): boolean {
+  const resolved = resolvedSchema(schema, refs, seen);
+  if (resolved === null) {
+    return false;
+  }
+  const types = nonNullTypes(resolved);
+  if (types.length > 0) {
+    return types.every((type) => type === "object");
+  }
+  return (
+    resolved.properties !== undefined ||
+    resolved.additionalProperties !== undefined ||
+    resolved.patternProperties !== undefined ||
+    isObjectComposition(resolved.allOf, refs, seen) ||
+    isObjectComposition(resolved.oneOf, refs, seen) ||
+    isObjectComposition(resolved.anyOf, refs, seen)
+  );
+}
+
+/**
+ * Whether the schema describes only objects: `type: object` (with `null` or not), or no `type`
+ * and object keywords, or a composition of such schemas. A `$ref` is followed.
+ */
+export function isObjectSchema(schema: Schema, refs: RefResolver): boolean {
+  return isObjectSchemaWith(schema, refs, new Set());
+}
+
+/** Whether an `in: query` parameter sends its object value as the object's own keys. */
+export function isExplodedQueryObject(parameter: ParameterObject, refs: RefResolver): boolean {
+  const style = parameter.style ?? FORM_STYLE;
+  const explode = parameter.explode ?? style === FORM_STYLE;
+  return (
+    parameter.in === "query" &&
+    style === FORM_STYLE &&
+    explode &&
+    parameter.schema !== undefined &&
+    isObjectSchema(parameter.schema, refs)
+  );
+}