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

package/src/domain/ir/nodes.ts

@@ -1,8 +1,10 @@
 /**
  * Type IR: the closed set of immutable nodes that describes the TypeScript types and declarations
  * the generator emits (ENGINEERING_PLAN §4.2, ADR-002). Nodes are plain readonly data with a `kind`
- * discriminator; every consumer dispatches with an exhaustive `switch`, so a new kind breaks the
- * build wherever it must be handled.
+ * discriminator; every consumer in this package dispatches with an exhaustive `switch`, so a new
+ * kind breaks the build wherever it must be handled. For users the set is open: a minor release
+ * may add a kind (ADR-034), so code outside the package must keep a node of an unknown kind as it
+ * is, and a `switch` over `kind` needs a `default` branch.
  *
  * Utility types (`Omit`, `Record`, `WithRequired`, `Extract`) are `reference` nodes with type
  * arguments, built by named constructors: the printer has nothing special to do for them.
@@ -35,7 +37,8 @@ export interface IrKeywordType {
 export interface IrStringLiteralType {
   readonly kind: "stringLiteral";
   readonly value: string;
-  readonly encoding: IrStringEncoding;
+  /** How the printer writes the value; unset is `json`. A detail of the printer. */
+  readonly encoding?: IrStringEncoding;
 }
 
 /** Finite number; a negative value prints with a leading minus sign. */
@@ -61,10 +64,11 @@ export interface IrArrayType {
   readonly element: IrType;
 }
 
-/** A tuple element; `isRest` prints `...T`. */
+/** A tuple element; `isRest` prints `...T`, `isOptional` prints `T?` (never both). */
 export interface IrTupleElement {
   readonly type: IrType;
   readonly isRest: boolean;
+  readonly isOptional: boolean;
 }
 
 export interface IrTupleType {
@@ -111,9 +115,9 @@ export interface IrRawType {
   readonly kind: "raw";
   readonly text: string;
   /**
-   * The outside node the text was printed from, opaque to the IR. While the Node API still
-   * returns `ts.Node`s (until Phase 6), the bridge hands this node back unchanged, exactly as the
-   * original did. Removed with the reverse bridge in Phase 6.
+   * @internal The TypeScript node the bridge printed the text from. The reverse bridge (the
+   * deprecated `ts.Node` callbacks, ADR-004) hands it back unchanged. Set by the generator only:
+   * read it as opaque, never set it, and expect it to go away in 2.0.
    */
   readonly origin?: unknown;
 }

package/src/domain/openapi/admitted-values.ts

@@ -0,0 +1,113 @@
+import { parseRefPointer } from "./json-pointer.js";
+
+/**
+ * The values a schema admits when it admits only finitely many (`enum`, `const`, and `allOf` /
+ * `anyOf` / `oneOf` of those), read from the document. Null means "any value" as far as this
+ * reading goes: a schema of any other shape, or a `$ref` it cannot follow, is never assumed to
+ * exclude a value.
+ */
+
+export type AdmittedValue = string | number | boolean | null;
+/** A finite set of values, or null for every value. */
+export type AdmittedValues = ReadonlySet<AdmittedValue> | null;
+
+type JsonObject = Readonly<Record<string, unknown>>;
+
+/** How deep `$ref`s and compositions are followed; deeper schemas admit every value. */
+const MAX_DEPTH = 16;
+const LOCAL_REF_PREFIX = "#/";
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** The node at a local `$ref` (`#/...`) of the document, or undefined. */
+export function resolveLocalRef(document: unknown, ref: string): unknown {
+  if (!ref.startsWith(LOCAL_REF_PREFIX)) {
+    return undefined;
+  }
+  let node: unknown = document;
+  for (const segment of parseRefPointer(ref)) {
+    node = isObject(node) || Array.isArray(node) ? (node as JsonObject)[segment] : undefined;
+  }
+  return node;
+}
+
+function intersect(left: AdmittedValues, right: AdmittedValues): AdmittedValues {
+  if (left === null || right === null) {
+    return left ?? right;
+  }
+  return new Set([...left].filter((value) => right.has(value)));
+}
+
+function unite(sets: readonly AdmittedValues[]): AdmittedValues {
+  return sets.some((set) => set === null) ? null : new Set(sets.flatMap((set) => [...(set ?? [])]));
+}
+
+function isAdmittedValue(value: unknown): value is AdmittedValue {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+
+interface Walk {
+  readonly document: unknown;
+  readonly depth: number;
+  /** `$ref`s whose targets are left out: they add nothing to the generated type here. */
+  readonly skipped: ReadonlySet<string>;
+}
+
+function follow(node: unknown, walk: Walk): unknown {
+  if (!isObject(node) || typeof node.$ref !== "string") {
+    return node;
+  }
+  return walk.skipped.has(node.$ref) ? undefined : resolveLocalRef(walk.document, node.$ref);
+}
+
+function members(node: JsonObject, keyword: string): readonly unknown[] {
+  const list = node[keyword];
+  return Array.isArray(list) ? list : [];
+}
+
+/** `enum` and `const` of the schema itself, before its compositions. */
+function ownValues(node: JsonObject): AdmittedValues {
+  const listed = Array.isArray(node.enum) ? node.enum.filter(isAdmittedValue) : null;
+  const constant = "const" in node && isAdmittedValue(node.const) ? new Set([node.const]) : null;
+  return intersect(listed === null ? null : new Set(listed), constant);
+}
+
+function schemaValues(schema: unknown, walk: Walk): AdmittedValues {
+  const node = follow(schema, walk);
+  if (!isObject(node) || walk.depth > MAX_DEPTH) {
+    return null;
+  }
+  const next = { ...walk, depth: walk.depth + 1 };
+  const parts = members(node, "allOf").map((part) => schemaValues(part, next));
+  const variants = [...members(node, "anyOf"), ...members(node, "oneOf")];
+  const union = variants.length === 0 ? null : unite(variants.map((v) => schemaValues(v, next)));
+  return [...parts, union].reduce<AdmittedValues>(intersect, ownValues(node));
+}
+
+function propertyValues(schema: unknown, key: string, walk: Walk): AdmittedValues {
+  const node = follow(schema, walk);
+  if (!isObject(node) || walk.depth > MAX_DEPTH) {
+    return null;
+  }
+  const next = { ...walk, depth: walk.depth + 1 };
+  const properties = isObject(node.properties) ? node.properties : {};
+  const own = Object.hasOwn(properties, key) ? schemaValues(properties[key], next) : null;
+  const parts = members(node, "allOf").map((part) => propertyValues(part, key, next));
+  return parts.reduce<AdmittedValues>(intersect, own);
+}
+
+/**
+ * The values property `key` of an object schema admits: the intersection over the schema's own
+ * `properties` and its `allOf` parts (followed through `$ref`s, except `skipped` ones); null for
+ * every value.
+ */
+export function admittedPropertyValues(
+  schema: unknown,
+  key: string,
+  document: unknown,
+  skipped: ReadonlySet<string> = new Set(),
+): AdmittedValues {
+  return propertyValues(schema, key, { document, depth: 0, skipped });
+}

package/src/domain/openapi/discriminated-union.ts

@@ -0,0 +1,109 @@
+import { escapePointerSegment } from "./json-pointer.js";
+import type { Schema, SchemaObject } from "./schema-object.js";
+
+/**
+ * A discriminator owner is either a parent that its members `allOf` (an object with the
+ * discriminator property) or a union (`oneOf` / `anyOf` of the members). The generated type of a
+ * union is a TypeScript union, so it cannot be used like a parent: `Omit<Union, "kind">` keeps
+ * only the keys that every member has, and a member that intersects the union it belongs to
+ * refers to itself (TS2502, upstream #1665).
+ */
+
+/** Resolves a `$ref` of the document; `undefined` when it points nowhere. */
+export type ResolveSchemaRef = (ref: string) => unknown;
+
+const UNION_KEYWORDS = ["oneOf", "anyOf"] as const;
+const COMPOSITION_KEYWORDS = ["allOf", ...UNION_KEYWORDS] as const;
+
+function isSchemaObject(value: unknown): value is SchemaObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function keywordItems(schema: SchemaObject, keywords: readonly string[]): readonly Schema[] {
+  const record = schema as Readonly<Record<string, unknown>>;
+  return keywords.flatMap((keyword) => {
+    const items = record[keyword];
+    return Array.isArray(items) ? (items as readonly Schema[]) : [];
+  });
+}
+
+/** The `oneOf` and `anyOf` members of a schema; empty when it is not a union. */
+export function unionMembers(schema: unknown): readonly Schema[] {
+  return isSchemaObject(schema) ? keywordItems(schema, UNION_KEYWORDS) : [];
+}
+
+/** The schema at `ref` when it is a union (has `oneOf` or `anyOf` members), else undefined. */
+export function unionAt(ref: string, resolve: ResolveSchemaRef): SchemaObject | undefined {
+  const schema = resolve(ref);
+  return isSchemaObject(schema) && unionMembers(schema).length > 0 ? schema : undefined;
+}
+
+/** What one search for a `$ref` has seen, so that a `$ref` cycle ends. */
+interface Search {
+  readonly target: string;
+  readonly resolve: ResolveSchemaRef;
+  readonly visited: Set<string>;
+}
+
+function reaches(schema: Schema, search: Search): boolean {
+  if (!isSchemaObject(schema)) {
+    return false;
+  }
+  const ref = (schema as { readonly $ref?: unknown }).$ref;
+  if (typeof ref === "string") {
+    if (ref === search.target) {
+      return true;
+    }
+    if (search.visited.has(ref)) {
+      return false;
+    }
+    search.visited.add(ref);
+    return reaches(search.resolve(ref) as Schema, search);
+  }
+  return keywordItems(schema, COMPOSITION_KEYWORDS).some((item) => reaches(item, search));
+}
+
+/**
+ * Whether the type of `union` contains the schema at `target` without an object in between: one
+ * of its members is a `$ref` to it, or `allOf` / `oneOf` / `anyOf` such a `$ref`, at any depth.
+ * Such a reference is resolved at once by TypeScript, unlike one in a property or an array.
+ */
+export function unionReaches(
+  union: SchemaObject,
+  target: string,
+  resolve: ResolveSchemaRef,
+): boolean {
+  const search = { target, resolve, visited: new Set<string>() };
+  return unionMembers(union).some((member) => reaches(member, search));
+}
+
+const COMPONENT_SCHEMAS = "#/components/schemas/";
+
+/** A mapping value as a `$ref`: a bare name is a component schema's name. */
+function mappingRef(target: unknown): string | undefined {
+  if (typeof target !== "string") {
+    return undefined;
+  }
+  return target.startsWith("#") ? target : `${COMPONENT_SCHEMAS}${escapePointerSegment(target)}`;
+}
+
+/** Whether the discriminator `mapping` of `union` names the schema at `target`. */
+export function unionMaps(union: SchemaObject, target: string): boolean {
+  const mapping = (union.discriminator as { readonly mapping?: unknown } | undefined)?.mapping;
+  if (!isSchemaObject(mapping)) {
+    return false;
+  }
+  return Object.values(mapping).some((value) => mappingRef(value) === target);
+}
+
+/**
+ * Whether the schema at `target` is a member of `union`: the union's type contains it, or the
+ * discriminator `mapping` names it, which gives it a value of the union as a member does.
+ */
+export function isUnionMember(
+  union: SchemaObject,
+  target: string,
+  resolve: ResolveSchemaRef,
+): boolean {
+  return unionMaps(union, target) || unionReaches(union, target, resolve);
+}

package/src/domain/openapi/discriminator-conflicts.ts

@@ -0,0 +1,251 @@
+import { admittedPropertyValues, resolveLocalRef } from "./admitted-values.js";
+import { isUnionMember, unionAt } from "./discriminated-union.js";
+import { createRef, escapePointerSegment, parseRefPointer } from "./json-pointer.js";
+
+/**
+ * Discriminator members whose discriminator value their own property does not allow. By the
+ * Discriminator Object rule, a member that no `mapping` entry names has its schema name as the
+ * value, so with a property `enum` (or `const`) that does not list it no value of the member
+ * matches, and where the generator adds the value to the member the property type is `never`.
+ * Each one gets a warning (CODING_PRINCIPLES §8.7).
+ */
+
+export interface DiscriminatorValueConflict {
+  /** The member schema, such as `#/components/schemas/EpisodeObject`. */
+  readonly member: string;
+  /** The schema that has the Discriminator Object. */
+  readonly owner: string;
+  readonly propertyName: string;
+  /** The values the discriminator gives the member: its mapping keys, or its name. */
+  readonly values: readonly string[];
+  /** The values the member's property allows. */
+  readonly allowed: readonly (string | number | boolean | null)[];
+  /** Whether no mapping entry names the member, so its value is its schema name. */
+  readonly isImplicit: boolean;
+}
+
+type JsonObject = Readonly<Record<string, unknown>>;
+
+const COMPONENT_SCHEMAS = "#/components/schemas/";
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface Owner {
+  readonly pointer: string;
+  readonly propertyName: string;
+  readonly mapping: Readonly<Record<string, string>>;
+  readonly memberRefs: readonly string[];
+}
+
+function refsOf(list: unknown): string[] {
+  return (Array.isArray(list) ? list : []).flatMap((item) =>
+    isObject(item) && typeof item.$ref === "string" ? [item.$ref] : [],
+  );
+}
+
+function mappingTarget(target: string): string {
+  return target.startsWith("#") ? target : `${COMPONENT_SCHEMAS}${escapePointerSegment(target)}`;
+}
+
+function ownerAt(node: JsonObject, pointer: () => string): Owner | null {
+  const discriminator = node.discriminator;
+  if (!isObject(discriminator) || typeof discriminator.propertyName !== "string") {
+    return null;
+  }
+  const mapping = isObject(discriminator.mapping)
+    ? (discriminator.mapping as Readonly<Record<string, string>>)
+    : {};
+  const mapped = Object.values(mapping)
+    .filter((t) => typeof t === "string")
+    .map(mappingTarget);
+  const memberRefs = [...refsOf(node.oneOf), ...refsOf(node.anyOf), ...mapped];
+  return { pointer: pointer(), propertyName: discriminator.propertyName, mapping, memberRefs };
+}
+
+/** A node of the document walk; the pointer is built only for the nodes that need it. */
+interface Visit {
+  readonly node: unknown;
+  readonly key: string | null;
+  readonly parent: Visit | null;
+}
+
+function pointerOf(visit: Visit): string {
+  const segments: string[] = [];
+  for (let current: Visit | null = visit; current?.key != null; current = current.parent) {
+    segments.unshift(current.key);
+  }
+  return createRef(segments);
+}
+
+function childrenOf(visit: Visit): Visit[] {
+  const { node } = visit;
+  const entries: [string, unknown][] = Array.isArray(node)
+    ? node.map((item, index) => [String(index), item])
+    : isObject(node)
+      ? Object.entries(node)
+      : [];
+  return entries.map(([key, child]) => ({ node: child, key, parent: visit }));
+}
+
+/**
+ * Every Discriminator Object of the document, depth first, with its pointer. The walk keeps its
+ * own stack, so a document nested past the call stack fails in the transform, as it did before.
+ */
+function ownersIn(document: unknown): Owner[] {
+  const found: Owner[] = [];
+  const stack: Visit[] = [{ node: document, key: null, parent: null }];
+  for (let visit = stack.pop(); visit !== undefined; visit = stack.pop()) {
+    const owner = isObject(visit.node) ? ownerAt(visit.node, () => pointerOf(visit)) : null;
+    if (owner !== null) {
+      found.push(owner);
+    }
+    stack.push(...childrenOf(visit).reverse());
+  }
+  return found;
+}
+
+/** A member and the `$ref`s whose properties its type leaves out (`Omit` of its parents). */
+interface Member {
+  readonly ref: string;
+  readonly skipped: ReadonlySet<string>;
+}
+
+interface Child {
+  readonly ref: string;
+  readonly schema: JsonObject;
+}
+
+/** How the run types an `allOf` of a discriminated union. */
+export interface ConflictOptions {
+  /**
+   * `allof-discriminated-union`: a schema that `allOf`s a union which does not contain it reuses
+   * the union and gets no value, so neither it nor the schemas below it are members.
+   */
+  readonly isUnionReused: boolean;
+}
+
+/** What the search for conflicts reads: the document and its `allOf` children by parent. */
+interface ConflictSearch extends ConflictOptions {
+  readonly document: unknown;
+  readonly children: ReadonlyMap<string, readonly Child[]>;
+}
+
+/** The `allOf` children of the owner that inherit its discriminator. */
+function inheritingChildren(owner: Owner, search: ConflictSearch): readonly Child[] {
+  const children = search.children.get(owner.pointer) ?? [];
+  const resolve = (ref: string) => resolveLocalRef(search.document, ref);
+  const union = search.isUnionReused ? unionAt(owner.pointer, resolve) : undefined;
+  return union === undefined
+    ? children
+    : children.filter((child) => isUnionMember(union, child.ref, resolve));
+}
+
+/** The component schemas whose `allOf` holds a `$ref`, by that `$ref`, in document order. */
+function allOfChildren(document: unknown): Map<string, Child[]> {
+  const schemas = resolveLocalRef(document, "#/components/schemas");
+  const children = new Map<string, Child[]>();
+  for (const [name, schema] of Object.entries(isObject(schemas) ? schemas : {})) {
+    if (!isObject(schema)) {
+      continue;
+    }
+    const child = { ref: `${COMPONENT_SCHEMAS}${escapePointerSegment(name)}`, schema };
+    for (const parent of new Set(refsOf(schema.allOf))) {
+      const siblings = children.get(parent) ?? [];
+      siblings.push(child);
+      children.set(parent, siblings);
+    }
+  }
+  return children;
+}
+
+/** Whether a schema defines a discriminator of the property itself: it is the owner below. */
+function ownsProperty(schema: JsonObject, propertyName: string): boolean {
+  const discriminator = schema.discriminator;
+  return isObject(discriminator) && discriminator.propertyName === propertyName;
+}
+
+/**
+ * Component schemas that inherit the owner through `allOf`, also through a chain
+ * (`Lion: { allOf: [Cat] }`, `Cat: { allOf: [Pet] }`). Each parent on the way is left out of the
+ * member's values, as its type omits the property. A schema with its own discriminator of the
+ * property is a member, but the schemas below it are its own members.
+ */
+function inheritingMembers(owner: Owner, search: ConflictSearch): Member[] {
+  const found: Member[] = [];
+  const visited = new Set([owner.pointer]);
+  const parents: Member[] = [{ ref: owner.pointer, skipped: new Set([owner.pointer]) }];
+  for (let parent = parents.shift(); parent !== undefined; parent = parents.shift()) {
+    const children =
+      parent.ref === owner.pointer
+        ? inheritingChildren(owner, search)
+        : (search.children.get(parent.ref) ?? []);
+    for (const child of children) {
+      if (visited.has(child.ref)) {
+        continue;
+      }
+      visited.add(child.ref);
+      found.push({ ref: child.ref, skipped: parent.skipped });
+      if (!ownsProperty(child.schema, owner.propertyName)) {
+        parents.push({ ref: child.ref, skipped: new Set([...parent.skipped, child.ref]) });
+      }
+    }
+  }
+  return found;
+}
+
+/** The members of an owner, each once: the listed and mapped ones, then the inheriting ones. */
+function membersOf(owner: Owner, search: ConflictSearch): Member[] {
+  const listed = owner.memberRefs.map((ref) => ({ ref, skipped: new Set([owner.pointer]) }));
+  const members = new Map<string, Member>();
+  for (const member of [...listed, ...inheritingMembers(owner, search)]) {
+    if (!members.has(member.ref)) {
+      members.set(member.ref, member);
+    }
+  }
+  return [...members.values()];
+}
+
+function memberValues(owner: Owner, member: string): { values: string[]; isImplicit: boolean } {
+  const values = Object.entries(owner.mapping)
+    .filter(([, target]) => typeof target === "string" && mappingTarget(target) === member)
+    .map(([key]) => key);
+  const name = parseRefPointer(member).pop() ?? "";
+  return values.length > 0 ? { values, isImplicit: false } : { values: [name], isImplicit: true };
+}
+
+function conflictOf(owner: Owner, { ref: member, skipped }: Member, document: unknown) {
+  // The owner's own property is left out of an inheriting member's type (`Omit`).
+  const allowed = admittedPropertyValues(
+    resolveLocalRef(document, member),
+    owner.propertyName,
+    document,
+    skipped,
+  );
+  const { values, isImplicit } = memberValues(owner, member);
+  if (allowed === null || values.some((value) => allowed.has(value))) {
+    return null;
+  }
+  const { pointer, propertyName } = owner;
+  return { member, owner: pointer, propertyName, values, allowed: [...allowed], isImplicit };
+}
+
+/** The conflicts of the document, one per member and value list, in document order. */
+export function findDiscriminatorValueConflicts(
+  document: unknown,
+  options: ConflictOptions = { isUnionReused: false },
+): readonly DiscriminatorValueConflict[] {
+  const conflicts = new Map<string, DiscriminatorValueConflict>();
+  const search = { ...options, document, children: allOfChildren(document) };
+  for (const owner of ownersIn(document)) {
+    for (const member of membersOf(owner, search)) {
+      const conflict = conflictOf(owner, member, document);
+      const key = JSON.stringify([member.ref, conflict?.propertyName, conflict?.values]);
+      if (conflict !== null && !conflicts.has(key)) {
+        conflicts.set(key, conflict);
+      }
+    }
+  }
+  return [...conflicts.values()];
+}

package/src/domain/openapi/parameter-object.ts

@@ -23,6 +23,10 @@ export interface ParameterObject {
   readonly in: ParameterLocation | typeof QUERYSTRING_LOCATION;
   readonly required?: boolean;
   readonly deprecated?: boolean;
+  /** How the value is serialized; `form` for `in: query` when absent (§4.8.12.4). */
+  readonly style?: string;
+  /** Whether an array or object value is sent as several values; true for `form` when absent. */
+  readonly explode?: boolean;
   readonly schema?: Schema;
   readonly content?: ContentMap;
 }

package/src/domain/openapi/path-templates.ts

@@ -0,0 +1,32 @@
+/**
+ * The Paths Object rule (OpenAPI 3.1 §4.8.8): "Templated paths with the same hierarchy but
+ * different templated names MUST NOT exist as they are identical." Such paths, `/a/{id}` and
+ * `/a/{name}`, match the same URLs, so a client cannot tell which one a request is for.
+ */
+
+/** `[^{}]` keeps the scan linear: `[^}]` retried from every `{` of a long run of them. */
+const PATH_PARAMETER_RE = /\{[^{}]+\}/g;
+const PATH_PREFIX = "/";
+const UNNAMED_PARAMETER = "{}";
+
+function isObject(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * The groups of paths that differ only in the names of their template parameters, each group in
+ * document order, the groups in the order of their first path. Keys that are no path, such as an
+ * `x-` extension, are left out.
+ */
+export function findIdenticalPathTemplates(document: unknown): string[][] {
+  const paths = isObject(document) && isObject(document.paths) ? document.paths : {};
+  const byHierarchy = new Map<string, string[]>();
+  for (const url of Object.keys(paths)) {
+    if (!url.startsWith(PATH_PREFIX) || !url.includes("{")) {
+      continue;
+    }
+    const hierarchy = url.replace(PATH_PARAMETER_RE, UNNAMED_PARAMETER);
+    byHierarchy.set(hierarchy, [...(byHierarchy.get(hierarchy) ?? []), url]);
+  }
+  return [...byHierarchy.values()].filter((urls) => urls.length > 1);
+}

package/src/domain/openapi/schema-object.ts

@@ -42,6 +42,8 @@ export interface SchemaObject {
   readonly $defs?: Readonly<Record<string, SchemaObject>>;
   readonly items?: Schema | readonly Schema[];
   readonly prefixItems?: readonly Schema[];
+  readonly unevaluatedItems?: Schema;
+  readonly contains?: Schema;
   readonly minItems?: number;
   readonly maxItems?: number;
   readonly allOf?: readonly Schema[];

package/src/domain/output-fixes.ts

@@ -6,14 +6,43 @@ import { ERROR_CODES, OpenAPITypesafeError } from "./errors.js";
  * default.
  */
 export const OutputFix = {
+  /** An `allOf` `$ref` to a discriminated union is the union, without `Omit` or a schema name. */
+  ALLOF_DISCRIMINATED_UNION: "allof-discriminated-union",
   /** An `allOf` member with only `required` makes those properties of the others required. */
   ALLOF_REQUIRED: "allof-required",
+  /** The JSDoc of a schema lists the descriptions of its `anyOf` and `oneOf` members. */
+  ANYOF_ONEOF_DESCRIPTIONS: "anyof-oneof-descriptions",
+  /** `anyOf` / `oneOf` variants with only `required` make those keys of the parent required. */
+  ANYOF_ONEOF_REQUIRED: "anyof-oneof-required",
   /** `anyOf` next to object keywords or `allOf` is intersected with them, not added to a union. */
   ANYOF_PROPERTIES: "anyof-properties",
   /** `--array-length` tuples have `min` to `max` items, nest right and follow `--immutable`. */
   ARRAY_LENGTH_TUPLES: "array-length-tuples",
-  /** A schema two discriminators name gets one enum of their values, a mapping before its name. */
+  /** `--dedupe-enums` names a shared enum by all of its schemas, not by the first one. */
+  DEDUPE_ENUM_NAMES: "dedupe-enum-names",
+  /** `required` next to an `allOf` `$ref` to a discriminator member still gives `WithRequired`. */
+  DISCRIMINATOR_MEMBER_REQUIRED: "discriminator-member-required",
+  /**
+   * The value a discriminator member gets: one enum of every discriminator's values, a mapping
+   * before the schema name, a schema's own mapping before an inherited one, none where the member
+   * declares it, and with `--enum` a member of the owner's enum.
+   */
   DISCRIMINATOR_VALUES: "discriminator-values",
+  /** An exploded object query parameter's properties are keys of `query`, as they are sent. */
+  EXPLODED_QUERY_OBJECTS: "exploded-query-objects",
+  /** `--enum` declares an enum that lists `null` without it, and the type adds `| null`. */
+  NULLABLE_ENUMS: "nullable-enums",
+  /** `--path-params-as-types` gives each `{name}` its placeholder, `{number}` included. */
+  PATH_PARAM_TYPE_NAMES: "path-param-type-names",
+  /** A `prefixItems` tuple is open unless `items` or `unevaluatedItems` closes it (2020-12). */
+  PREFIX_ITEMS: "prefix-items",
+  /** `readOnly` and `writeOnly` of the schema a `$ref` names, or of `allOf` members, count. */
+  READ_WRITE_REFS: "read-write-refs",
+  /**
+   * A `$ref` into schema keywords (`content/<type>/schema`, `items`, `allOf/0`) gets the type it
+   * points at, also where the original type compiles through an index signature.
+   */
+  REF_POINTERS: "ref-pointers",
   /** Schemas of one root type name without the prefix each get an alias, the earlier numbered. */
   ROOT_TYPE_NUMBERING: "root-type-numbering",
   /** `unevaluatedProperties` types the keys no other keyword declares (an index signature). */
@@ -58,11 +87,18 @@ export function resolveOutputFixes(names: readonly OutputFixName[]): ReadonlySet
 
 /** A generator option that a fix works with; without it, the fix changes nothing (ADR-021). */
 export interface OutputFixRequirement {
-  readonly option: "arrayLength" | "rootTypes" | "rootTypesNoSchemaPrefix";
+  readonly option:
+    | "arrayLength"
+    | "dedupeEnums"
+    | "enum"
+    | "pathParamsAsTypes"
+    | "rootTypes"
+    | "rootTypesNoSchemaPrefix";
   readonly flag: string;
 }
 
 const ROOT_TYPES = { option: "rootTypes", flag: "--root-types" } as const;
+const ENUM = { option: "enum", flag: "--enum" } as const;
 const NO_SCHEMA_PREFIX = {
   option: "rootTypesNoSchemaPrefix",
   flag: "--root-types-no-schema-prefix",
@@ -71,6 +107,11 @@ const NO_SCHEMA_PREFIX = {
 /** The options each fix needs, by fix name; `all` has none. */
 const REQUIREMENTS: Readonly<Partial<Record<OutputFixName, readonly OutputFixRequirement[]>>> = {
   [OutputFix.ARRAY_LENGTH_TUPLES]: [{ option: "arrayLength", flag: "--array-length" }],
+  [OutputFix.DEDUPE_ENUM_NAMES]: [ENUM, { option: "dedupeEnums", flag: "--dedupe-enums" }],
+  [OutputFix.NULLABLE_ENUMS]: [ENUM],
+  [OutputFix.PATH_PARAM_TYPE_NAMES]: [
+    { option: "pathParamsAsTypes", flag: "--path-params-as-types" },
+  ],
   [OutputFix.ROOT_TYPE_NUMBERING]: [ROOT_TYPES, NO_SCHEMA_PREFIX],
 };
 

package/src/domain/url-credentials.ts

@@ -0,0 +1,18 @@
+/**
+ * URLs with user info (`https://user:token@host/…`) can reach a message: the CLI input, a `$ref`,
+ * a redirect. Messages end up in CI job logs, so the user info is hidden in every one (audit B2,
+ * F12). Fetch refuses such URLs anyway, so a message never needs the credentials.
+ */
+
+/**
+ * The user info after a scheme: everything up to an `@` that comes before the end of the
+ * authority. The class stops at `/`, so a scan never runs past the next `://`; it stays linear.
+ */
+const URL_USER_INFO = /:\/\/[^\s/?#@]*@/g;
+
+const REDACTED_USER_INFO = "://***@";
+
+/** The text with the user info of every URL in it replaced by `***`. */
+export function redactUrlCredentials(text: string): string {
+  return text.replace(URL_USER_INFO, () => REDACTED_USER_INFO);
+}