openapi-typesafe 1.0.0-rc.4 → 1.0.0-rc.5

package/src/cli/cli-arguments.ts

@@ -83,23 +83,95 @@ const REMOVED_FLAGS: readonly (readonly [string, string])[] = [
 ];
 
 /** Flags that only work together with `--root-types`. */
-const ROOT_TYPES_FLAGS = ["--root-types-no-schema-prefix", "--root-types-keep-casing"] as const;
+const ROOT_TYPES_FLAGS = ["rootTypesNoSchemaPrefix", "rootTypesKeepCasing"] as const;
 
-function rejectRemovedFlags(argv: readonly string[]): void {
+const OPTIONS_END = "--";
+const LONG_PREFIX = "--";
+const NEGATION_PREFIX = "--no-";
+const VALUE_SEPARATOR = "=";
+const BOOLEAN_VALUES: ReadonlySet<string> = new Set(["true", "false"]);
+
+/** A flag as written before `--`: its name (`--redoc`, `-o`) and the text after `=`, if any. */
+interface WrittenFlag {
+  readonly name: string;
+  readonly value: string | undefined;
+}
+
+function writtenFlags(argv: readonly string[]): WrittenFlag[] {
+  const end = argv.indexOf(OPTIONS_END);
+  return (end === -1 ? argv : argv.slice(0, end))
+    .filter((arg) => arg.startsWith("-") && arg !== "-")
+    .map((arg) => {
+      const at = arg.indexOf(VALUE_SEPARATOR);
+      return at === -1
+        ? { name: arg, value: undefined }
+        : { name: arg.slice(0, at), value: arg.slice(at + 1) };
+    });
+}
+
+/**
+ * A long flag as yargs-parser reads it: in kebab-case and without `--no-`, so `--immutableTypes`
+ * and `--no-immutable-types` are `--immutable-types`. A short flag stays as written.
+ */
+function canonicalFlagName(name: string): string {
+  if (!name.startsWith(LONG_PREFIX)) {
+    return name;
+  }
+  const bare = name.startsWith(NEGATION_PREFIX)
+    ? name.slice(NEGATION_PREFIX.length)
+    : name.slice(LONG_PREFIX.length);
+  return `${LONG_PREFIX}${kebabCase(bare)}`;
+}
+
+/** An old flag fails by its name in any spelling, also with a value (`--redoc=redocly.yaml`). */
+function rejectRemovedFlags(flags: readonly WrittenFlag[]): void {
+  const names = new Set(flags.map(({ name }) => canonicalFlagName(name)));
   for (const [flag, message] of REMOVED_FLAGS) {
-    if (argv.includes(flag)) {
+    if (names.has(flag)) {
       throw cliError("CLI_FLAG_REMOVED", message);
     }
   }
 }
 
+const ALIASES = { redocly: ["c"], exportType: ["t"], output: ["o"] };
+
+/** The short aliases of boolean flags (`-t`), which take a value the same way (`-t=true`). */
+const BOOLEAN_ALIASES = Object.entries(ALIASES)
+  .filter(([flag]) => CAMEL_CASE_BOOLEAN_FLAGS.includes(flag))
+  .flatMap(([, aliases]) => aliases.map((alias) => `-${alias}`));
+
+const BOOLEAN_FLAG_NAMES: ReadonlySet<string> = new Set([
+  ...BOOLEAN_FLAGS.map((flag) => `${LONG_PREFIX}${flag}`),
+  ...BOOLEAN_ALIASES,
+]);
+
+/**
+ * A boolean flag takes `=true` or `=false`, and its `--no-` form takes no value. yargs-parser read
+ * any other value as false (`--enum=1`, `--alphabetize=yes`), which turned the option off.
+ */
+function rejectInvalidBooleans(flags: readonly WrittenFlag[]): void {
+  for (const { name, value } of flags) {
+    const negated = name.startsWith(NEGATION_PREFIX)
+      ? `${LONG_PREFIX}${name.slice(NEGATION_PREFIX.length)}`
+      : undefined;
+    const isNegatedWithValue = negated !== undefined && BOOLEAN_FLAG_NAMES.has(negated);
+    const isInvalid = BOOLEAN_FLAG_NAMES.has(name) && !BOOLEAN_VALUES.has(value ?? "true");
+    if (value !== undefined && (isNegatedWithValue || isInvalid)) {
+      throw cliError(
+        "CLI_FLAG_INVALID",
+        `${name}=${value}: a boolean flag takes no value, or =true or =false.`,
+      );
+    }
+  }
+}
+
 /** Notices for flags that have no effect in this combination, printed before the run. */
-export function ineffectiveFlagNotices(argv: readonly string[]): string[] {
-  if (argv.includes("--root-types")) {
+export function ineffectiveFlagNotices(flags: GeneratorFlags): string[] {
+  if (flags.rootTypes === true) {
     return [];
   }
-  return ROOT_TYPES_FLAGS.filter((flag) => argv.includes(flag)).map(
-    (flag) => `${flag} has no effect without --root-types flag`,
+  return ROOT_TYPES_FLAGS.filter((flag) => flags[flag] === true).map(
+    (flag) => `--${kebabCase(flag)} has no effect without --root-types flag`,
   );
 }
 
@@ -117,7 +189,10 @@ function optionalString(value: unknown): string | undefined {
   return value === undefined ? undefined : String(value);
 }
 
-/** The last value of a flag that may be given more than once. */
+/**
+ * The last value of a flag that takes one value: given twice, the last one wins, as for the
+ * boolean flags (yargs-parser gives a list of every value).
+ */
 function lastString(value: unknown): string | undefined {
   return optionalString(Array.isArray(value) ? value.at(-1) : value);
 }
@@ -154,8 +229,6 @@ const STRING_FLAGS = [
   ...["localRefRoot", "remoteRefHosts"].flatMap((flag) => [flag, kebabCase(flag)]),
 ];
 
-const ALIASES = { redocly: ["c"], exportType: ["t"], output: ["o"] };
-
 /** Every name yargs-parser can return for a flag this CLI reads. */
 const KNOWN_FLAGS = new Set<string>([
   ...BOOLEAN_FLAGS,
@@ -186,11 +259,14 @@ function writtenFlagName(key: string, argv: readonly string[]): string {
 }
 
 /**
- * Parse the arguments after `node cli.js`. Fails with `CLI_FLAG_REMOVED` for an old flag and with
+ * Parse the arguments after `node cli.js`. Fails with `CLI_FLAG_REMOVED` for an old flag, with
+ * `CLI_FLAG_INVALID` for a boolean flag with another value than true or false, and with
  * `OPTION_FIX_UNKNOWN` for an unknown `--fix` name.
  */
 export function parseCliArguments(argv: readonly string[]): CliArguments {
-  rejectRemovedFlags(argv);
+  const flags = writtenFlags(argv);
+  rejectRemovedFlags(flags);
+  rejectInvalidBooleans(flags);
   const parsed = parser([...argv], {
     boolean: BOOLEAN_FLAGS,
     string: STRING_FLAGS,
@@ -198,8 +274,8 @@ export function parseCliArguments(argv: readonly string[]): CliArguments {
   });
   return {
     input: optionalString(parsed._[0]),
-    output: optionalString(parsed.output),
-    redocly: optionalString(parsed.redocly),
+    output: lastString(parsed.output),
+    redocly: lastString(parsed.redocly),
     isCheck: parsed.check === true,
     isHelp: "help" in parsed,
     isVersion: "version" in parsed,

package/src/cli/cli-dependencies.ts

@@ -1,6 +1,7 @@
 import type { Readable } from "node:stream";
 import type {
   DirectoryCheck,
+  FileCheck,
   FileClaims,
   FileIdentity,
   FileReader,
@@ -33,10 +34,14 @@ export interface GeneratedTypes {
   readonly localFiles: readonly URL[];
 }
 
-/** Generate the types of one schema. */
+/**
+ * Generate the types of one schema. With `apiName`, an API of `redocly.yaml`, every line the
+ * generation logs names that API.
+ */
 export type GenerateTypes = (
   source: SchemaSource,
   options: GeneratorOptions,
+  apiName?: string,
 ) => Promise<GeneratedTypes>;
 
 export interface CliDependencies {
@@ -55,7 +60,7 @@ export interface CliDependencies {
    * input with no prompt, which looks like a hang (upstream #1905).
    */
   readonly isStdinTerminal: () => boolean;
-  readonly files: FileReader & FileWriter & FileIdentity & DirectoryCheck & FileClaims;
+  readonly files: FileReader & FileWriter & FileIdentity & DirectoryCheck & FileCheck & FileClaims;
   readonly redoclyConfigs: RedoclyConfigSource;
   readonly generate: GenerateTypes;
   /** A monotonic time in milliseconds, for the time printed after each output. */

package/src/cli/cli-errors.ts

@@ -99,8 +99,10 @@ const CLI_ERROR_REPORTS: Readonly<Record<ErrorCode, CliErrorReport>> = {
   ENUM_NAME_EMPTY: { exitCode: EXIT_CODES.SCHEMA },
   CALLBACK_RESULT_UNREADABLE: { exitCode: EXIT_CODES.USAGE },
   OPTION_FIX_UNKNOWN: { exitCode: EXIT_CODES.USAGE },
+  OPTION_INVALID: { exitCode: EXIT_CODES.USAGE },
   TYPESCRIPT_NOT_FOUND: { exitCode: EXIT_CODES.USAGE },
   CLI_FLAG_REMOVED: { exitCode: EXIT_CODES.USAGE },
+  CLI_FLAG_INVALID: { exitCode: EXIT_CODES.USAGE },
   CLI_GLOB_UNSUPPORTED: { exitCode: EXIT_CODES.USAGE },
   CLI_CONFIG_NOT_FOUND: { exitCode: EXIT_CODES.USAGE },
   CLI_CONFIG_INVALID: { exitCode: EXIT_CODES.USAGE },
@@ -127,6 +129,10 @@ export interface CliFailure {
  * else is a bug and prints its stack, so it can be reported.
  */
 export function describeCliFailure(error: unknown): CliFailure {
+  if (error instanceof ApiFailure) {
+    const failure = describeCliFailure(error.cause);
+    return { ...failure, message: `API ${error.apiName}: ${failure.message}` };
+  }
   if (!isOpenAPITypesafeError(error)) {
     const text = error instanceof Error ? (error.stack ?? error.message) : String(error);
     return { exitCode: EXIT_CODES.INTERNAL, message: `Unexpected error: ${text}` };
@@ -136,6 +142,22 @@ export function describeCliFailure(error: unknown): CliFailure {
   return { exitCode: report.exitCode, message: `${message} (${error.code})` };
 }
 
+/**
+ * A failure of one API of a Redocly config. The CLI reports its cause with the API named first,
+ * as the config errors of an API are; the cause keeps its code and so its exit code.
+ */
+export class ApiFailure extends Error {
+  override readonly name = "ApiFailure";
+  override readonly cause: unknown;
+  readonly apiName: string;
+
+  constructor(apiName: string, cause: unknown) {
+    super(`API ${apiName} failed`, { cause });
+    this.apiName = apiName;
+    this.cause = cause;
+  }
+}
+
 /** Errors of the CLI itself; its messages are the original CLI's messages. */
 export function cliError(
   code: Extract<ErrorCode, `CLI_${string}` | `OUTPUT_${string}`>,

package/src/cli/cli-output.ts

@@ -2,7 +2,9 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { formatDuration } from "../adapters/terminal-logger/terminal-logger.js";
 import type { RedoclyConfig } from "../application/ports/redocly-config-source.js";
-import { redactUnparsedUrl } from "../domain/url-secrets.js";
+import { hasUrlScheme } from "../domain/location-text.js";
+import { terminalSafeText } from "../domain/terminal-text.js";
+import { redactUnparsedUrl, redactUrlSecrets } from "../domain/url-secrets.js";
 import type { CliArguments } from "./cli-arguments.js";
 import type { CliDependencies, GeneratedTypes } from "./cli-dependencies.js";
 import { cliError } from "./cli-errors.js";
@@ -27,12 +29,6 @@ export interface OutputFile extends NamedOutput {
   readonly file: URL;
 }
 
-/**
- * A scheme of two or more characters (`https:`, `file:`). One letter is a Windows drive (`C:`), so
- * `C:\\specs\\api.yaml` stays a path.
- */
-const URL_SCHEME = /^[a-z][a-z\d+.-]+:/i;
-
 /**
  * The URL of a location the user wrote: a URL, else a file path, absolute or relative to the
  * directory of `base` (a directory or file URL). A relative `file:` URL (`file:api.yaml`) resolves
@@ -41,7 +37,7 @@ const URL_SCHEME = /^[a-z][a-z\d+.-]+:/i;
  * (`http://[::1/x`) fails with `CLI_LOCATION_INVALID`.
  */
 export function resolveLocationUrl(location: string, base: URL): URL {
-  if (URL_SCHEME.test(location)) {
+  if (hasUrlScheme(location)) {
     const url = URL.parse(location, base.href);
     if (url === null) {
       const shown = redactUnparsedUrl(location);
@@ -202,15 +198,20 @@ export function duplicateOutputError(output: NamedOutput, others: readonly strin
 
 /** As `resolveLocationUrl`, but undefined for a URL that does not parse instead of a throw. */
 export function parseLocationUrl(location: string, base: URL): URL | undefined {
-  if (URL_SCHEME.test(location)) {
+  if (hasUrlScheme(location)) {
     return URL.parse(location, base.href) ?? undefined;
   }
   return resolveLocationUrl(location, base);
 }
 
+/**
+ * The line for a written file. It goes to the job log, so a source URL shows no secrets, and a
+ * line break or escape sequence in a name cannot start a forged line.
+ */
 function printDone(run: CliRun, output: OutputFile): void {
   const { style, now } = run.deps;
-  const target = style.green(`${output.source} → ${style.bold(output.output)}`);
+  const source = terminalSafeText(redactUrlSecrets(output.source));
+  const target = style.green(`${source} → ${style.bold(terminalSafeText(output.output))}`);
   const duration = style.dim(`[${formatDuration(now() - run.startedAt)}]`);
   run.deps.console.info(`🚀 ${target} ${duration}`);
 }

package/src/cli/main.ts

@@ -3,11 +3,14 @@ import { isatty } from "node:tty";
 import { pathToFileURL } from "node:url";
 import colors from "ansi-colors";
 import { createNodeFileSystem } from "../adapters/node-file-system/node-file-system.js";
+import { createPipeSafeWriter } from "../adapters/pipe-safe-writer/pipe-safe-writer.js";
 import { createRedoclyConfigSource } from "../adapters/redocly-loader/redocly-config-source.js";
 import { astToString } from "../api/ast-to-string.js";
 import { COMMENT_HEADER } from "../api/comment-header.js";
 import { defaultLogger, monotonicNow, terminalSupportsColor } from "../api/default-ports.js";
 import { defaultGeneratorPorts, generateDocument } from "../api/openapi-ts.js";
+import { terminalSafeText } from "../domain/terminal-text.js";
+import { apiLogger } from "./api-logger.js";
 import type { CliConsole, CliDependencies, GenerateTypes, TextStyle } from "./cli-dependencies.js";
 import { runCli } from "./run-cli.js";
 
@@ -36,8 +39,10 @@ function terminalStyle(): TextStyle {
 
 const STDIN_DESCRIPTOR = 0;
 
-const generateTypes: GenerateTypes = async (source, options) => {
-  const ports = await defaultGeneratorPorts(options);
+const generateTypes: GenerateTypes = async (source, options, apiName) => {
+  const terminalLogger = defaultLogger(options.silent ?? false);
+  const logger = apiName === undefined ? terminalLogger : apiLogger(terminalLogger, apiName);
+  const ports = await defaultGeneratorPorts(options, logger);
   const { declarations, localFiles } = await generateDocument(source, options, ports);
   return { contents: `${COMMENT_HEADER}${astToString(declarations)}`, localFiles };
 };
@@ -46,8 +51,9 @@ function terminalConsole(): CliConsole {
   return {
     // biome-ignore lint/suspicious/noConsole: the CLI's own output lines
     info: (text) => console.info(text),
+    // A notice names flags and API names as written, so it is shown as one plain line.
     // biome-ignore lint/suspicious/noConsole: the CLI's own notices
-    notice: (text) => console.warn(text),
+    notice: (text) => console.warn(terminalSafeText(text)),
   };
 }
 
@@ -58,7 +64,7 @@ function processDependencies(): CliDependencies {
     version: readVersion(),
     logger: defaultLogger(false),
     console: terminalConsole(),
-    writeStdout: (text) => process.stdout.write(text),
+    writeStdout: createPipeSafeWriter(process.stdout),
     stdin: () => process.stdin,
     // `isatty` reads the descriptor without opening `process.stdin`, which would keep the
     // process alive.

package/src/cli/redocly-apis.ts

@@ -10,7 +10,8 @@ import {
   unknownSettingWarnings,
 } from "./api-settings.js";
 import { type GeneratedApi, writeGeneratedApis } from "./api-writes.js";
-import { cliError } from "./cli-errors.js";
+import { ineffectiveFlagNotices } from "./cli-arguments.js";
+import { ApiFailure, cliError } from "./cli-errors.js";
 import {
   type CliRun,
   ensureOutputIsNotSchema,
@@ -24,7 +25,7 @@ import {
 } from "./cli-output.js";
 import { MULTIPLE_SCHEMAS_DOCS_URL } from "./docs-links.js";
 import { fixOption } from "./fix-option.js";
-import { refLimitOptions } from "./ref-limits.js";
+import { type RefLimitOptions, refLimitOptions } from "./ref-limits.js";
 
 /** The `apis` of a Redocly config: each API is generated into its `x-openapi-ts.output`. */
 
@@ -92,16 +93,33 @@ function apiTarget(api: RedoclyApi, configRoot: URL): ApiTarget {
   return { name, root, settings, configRoot };
 }
 
-/** The generator options of one API: its own settings win over the CLI's flags. */
-function apiOptions(run: CliRun, redocly: RedoclyConfig, target: ApiTarget): GeneratorOptions {
+/**
+ * What every API of a run shares: the config, the files of all APIs, and the reference limits of
+ * the command line, which are checked once before any API, so an invalid flag fails the run once.
+ */
+interface ApiRun {
+  readonly redocly: RedoclyConfig;
+  readonly files: ConfigFiles;
+  readonly refLimits: RefLimitOptions;
+}
+
+/**
+ * The generator options of one API: its own settings win over the CLI's flags. A flag that has
+ * no effect with the merged flags is named for this API, since its settings may turn on the flag
+ * that the command line lacks, or set one that has no effect themselves.
+ */
+function apiOptions(run: CliRun, apiRun: ApiRun, target: ApiTarget): GeneratorOptions {
   const { name, settings, configRoot } = target;
+  const flags = { ...run.args.generatorFlags, ...apiFlags(name, settings) };
+  for (const notice of ineffectiveFlagNotices(flags)) {
+    run.deps.console.notice(`API ${name}: ${notice}`);
+  }
   return {
-    ...run.args.generatorFlags,
-    ...apiFlags(name, settings),
-    ...refLimitOptions(run.args, run.deps.cwd),
+    ...flags,
+    ...apiRun.refLimits,
     ...apiRefLimitOptions(name, settings, configRoot),
     ...fixOption(apiFixNames(name, settings) ?? run.args.fix),
-    redocly,
+    redocly: apiRun.redocly,
   };
 }
 
@@ -122,12 +140,8 @@ function otherOutputs(files: ConfigFiles, apiName: string): NamedFile[] {
  * Generate the types of one API. Its output must not be a file the run reads before any API is
  * loaded (the root of any API, the Redocly config) nor another API's output.
  */
-async function generateApi(
-  run: CliRun,
-  redocly: RedoclyConfig,
-  target: ApiTarget,
-  files: ConfigFiles,
-): Promise<GeneratedApi> {
+async function generateApi(run: CliRun, apiRun: ApiRun, target: ApiTarget): Promise<GeneratedApi> {
+  const { files } = apiRun;
   for (const warning of unknownSettingWarnings(target.name, target.settings)) {
     run.deps.logger.warn(warning);
   }
@@ -136,8 +150,13 @@ async function generateApi(
   ensureOutputIsNotSchema(run, outputFile, files.schemas);
   ensureOutputIsOwn(run, outputFile, otherOutputs(files, target.name));
   const source = resolveLocationUrl(target.root, target.configRoot);
-  const types = await run.deps.generate(source, apiOptions(run, redocly, target));
-  return { name: target.name, outputFile, types };
+  const options = apiOptions(run, apiRun, target);
+  try {
+    const types = await run.deps.generate(source, options, target.name);
+    return { name: target.name, outputFile, types };
+  } catch (error) {
+    throw new ApiFailure(target.name, error);
+  }
 }
 
 /**
@@ -192,8 +211,9 @@ async function settledInTurn<T, R>(
 export async function generateRedoclyApis(run: CliRun, redocly: RedoclyConfig): Promise<unknown[]> {
   const apis = redoclyApisOf(redocly);
   const { configRoot, files } = configFilesOf(run, redocly, apis);
+  const apiRun = { redocly, files, refLimits: refLimitOptions(run.args, run.deps.cwd) };
   const results = await settledInTurn(apis, (api) =>
-    generateApi(run, redocly, apiTarget(api, configRoot), files),
+    generateApi(run, apiRun, apiTarget(api, configRoot)),
   );
   const generated = results.flatMap((result) =>
     result.status === "fulfilled" ? [result.value] : [],

package/src/cli/ref-limits.ts

@@ -1,16 +1,35 @@
 import type { GeneratorOptions } from "../types.js";
 import type { CliArguments } from "./cli-arguments.js";
+import { cliError } from "./cli-errors.js";
 import { resolveLocationUrl } from "./cli-output.js";
 
 /** The `$ref` limits of the CLI flags as generator options (threat model R1, R2, ADR-017). */
 
 export type RefLimitOptions = Pick<GeneratorOptions, "localRefRoot" | "remoteRefHosts">;
 
-/** `--local-ref-root` resolves against the working directory, like every other CLI path. */
+const FILE_PROTOCOL = "file:";
+
+/** A local `$ref` root as a URL; undefined for a URL of another protocol, which names no folder. */
+export function localRootUrl(location: string, base: URL): URL | undefined {
+  const url = resolveLocationUrl(location, base);
+  return url.protocol === FILE_PROTOCOL ? url : undefined;
+}
+
+/**
+ * `--local-ref-root` resolves against the working directory, like every other CLI path. A URL of
+ * another protocol (`https://…`) fails with `CLI_FLAG_INVALID`.
+ */
 export function refLimitOptions(args: CliArguments, cwd: URL): RefLimitOptions {
   const { localRefRoot, remoteRefHosts } = args.refLimits;
+  const localRoot = localRefRoot === undefined ? undefined : localRootUrl(localRefRoot, cwd);
+  if (localRefRoot !== undefined && localRoot === undefined) {
+    throw cliError(
+      "CLI_FLAG_INVALID",
+      `--local-ref-root ${localRefRoot}: a directory path or a file: URL.`,
+    );
+  }
   return {
-    ...(localRefRoot === undefined ? {} : { localRefRoot: resolveLocationUrl(localRefRoot, cwd) }),
+    ...(localRoot === undefined ? {} : { localRefRoot: localRoot }),
     ...(remoteRefHosts === undefined ? {} : { remoteRefHosts }),
   };
 }

package/src/cli/run-cli.ts

@@ -1,5 +1,6 @@
 import type { Logger } from "../application/ports/logger.js";
 import type { RedoclyConfig } from "../application/ports/redocly-config-source.js";
+import { hasUrlScheme } from "../domain/location-text.js";
 import { WARNING_CODES, warningText } from "../domain/warnings.js";
 import type { SchemaSource } from "../types.js";
 import { ineffectiveFlagNotices, parseCliArguments } from "./cli-arguments.js";
@@ -52,13 +53,29 @@ function schemaSource(run: CliRun): SchemaSource {
   return run.deps.stdin();
 }
 
+/** The character that made the original CLI read a schema argument as a glob pattern. */
+const GLOB_WILDCARD = "*";
+
+/**
+ * Whether the schema argument is a glob pattern, which the CLI no longer expands: a path with a
+ * `*` that names no file. A URL is no pattern (`?fields=*` is its query), nor a file whose name
+ * has a `*`, which the CLI reads as any other file.
+ */
+function isGlobPattern(run: CliRun, input: string): boolean {
+  return (
+    input.includes(GLOB_WILDCARD) &&
+    !hasUrlScheme(input) &&
+    !run.deps.files.isFile(resolveLocationUrl(input, run.deps.cwd))
+  );
+}
+
 /**
  * One schema from a path, a URL or stdin; without `--output`, the types go to stdout. Warnings and
  * errors go to stderr either way, so they never mix with the types (upstream dropped warnings).
  */
 async function generateSingleSchema(run: CliRun, redocly: RedoclyConfig): Promise<void> {
   const { input, output } = run.args;
-  if (input?.includes("*")) {
+  if (input !== undefined && isGlobPattern(run, input)) {
     throw cliError(
       "CLI_GLOB_UNSUPPORTED",
       "Globbing has been deprecated in favor of redocly.yaml’s `apis` keys. " +
@@ -72,6 +89,9 @@ async function generateSingleSchema(run: CliRun, redocly: RedoclyConfig): Promis
       "--check needs the generated file to compare with: add --output <file>.",
     );
   }
+  for (const notice of ineffectiveFlagNotices(run.args.generatorFlags)) {
+    run.deps.console.notice(notice);
+  }
   const source = schemaSource(run);
   const outputFile = output ? singleOutputFile(run, output, source, redocly) : undefined;
   const options = {
@@ -112,23 +132,35 @@ async function generate(run: CliRun): Promise<unknown[]> {
     await generateSingleSchema(run, redocly);
     return [];
   }
-  if (run.args.input) {
-    run.deps.logger.warn(
+  warnAboutIgnoredArguments(run);
+  return generateRedoclyApis(run, redocly);
+}
+
+/** With the APIs of a Redocly config, the input and the output of the command line are unused. */
+function warnAboutIgnoredArguments(run: CliRun): void {
+  const { args, deps } = run;
+  if (args.input) {
+    deps.logger.warn(
       warningText(
         "APIs are specified both in Redocly Config and CLI argument. Only using Redocly config.",
         WARNING_CODES.CLI_INPUT_IGNORED,
       ),
     );
   }
-  return generateRedoclyApis(run, redocly);
+  if (args.output) {
+    deps.logger.warn(
+      warningText(
+        `APIs are specified in Redocly Config, so --output ${args.output} is ignored: ` +
+          "each API is written to its x-openapi-ts.output.",
+        WARNING_CODES.CLI_OUTPUT_IGNORED,
+      ),
+    );
+  }
 }
 
 /** Run the command; the failures it returns did not stop the other outputs. */
 async function runCommand(argv: readonly string[], deps: CliDependencies): Promise<unknown[]> {
   const startedAt = deps.now();
-  for (const notice of ineffectiveFlagNotices(argv)) {
-    deps.console.notice(notice);
-  }
   const args = parseCliArguments(argv);
   for (const flag of args.unknownFlags) {
     deps.console.notice(`Unknown flag ${flag} is ignored (see --help)`);