@qraft/plugin 1.0.0-beta.0

package/src/lib/getRedocAPIsToQraft.ts

@@ -0,0 +1,92 @@
+import type { Config } from '@redocly/openapi-core';
+import { isAbsolute } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { CommanderError } from 'commander';
+import { Ora } from 'ora';
+
+export const OPENAPI_QRAFT_REDOC_CONFIG_KEY = 'x-openapi-qraft';
+export const ASYNCAPI_QRAFT_REDOC_CONFIG_KEY = 'x-asyncapi-qraft';
+
+export function getRedocAPIsToQraft(
+  redoc: Config,
+  cwd: URL,
+  spinner: Ora,
+  configKey: string = OPENAPI_QRAFT_REDOC_CONFIG_KEY,
+  apiName?: string
+) {
+  const hasRedoclyApis = Object.keys(redoc?.apis ?? {}).length > 0;
+  if (!hasRedoclyApis) {
+    throw new CommanderError(
+      1,
+      'ERR_MISSING_APIS',
+      'No "apis" found in Redocly config. Please specify the APIs to be generated.'
+    );
+  }
+  if (!redoc.configFile) {
+    throw new CommanderError(
+      1,
+      'ERR_MISSING_CONFIG_FILE',
+      'No "configFile" found in Redocly config. Please specify the path to the Redocly config file.'
+    );
+  }
+
+  const configRoot = isAbsolute(redoc.configFile)
+    ? new URL(pathToFileURL(redoc.configFile))
+    : new URL(redoc.configFile, cwd);
+
+  const apisToQraftEntries = Object.entries(redoc.apis)
+    .map(([itemApiName, api]) => {
+      if (apiName && apiName !== itemApiName) return;
+
+      const qraftConfig =
+        configKey in api
+          ? (api as Record<string, unknown>)[configKey]
+          : undefined;
+
+      if (!qraftConfig) {
+        return void spinner.warn(
+          `API ${itemApiName} is missing an \`${configKey}\` key. Skipping...`
+        );
+      }
+
+      if (typeof qraftConfig !== 'object') {
+        throw new CommanderError(
+          1,
+          'ERR_MISSING_API_CONFIG',
+          `API ${itemApiName} is missing an \`${configKey}\` key. See https://openapi-qraft.github.io/openapi-qraft/docs/codegen/CLI/redocly-config.`
+        );
+      }
+
+      const {
+        o,
+        ['output-dir']: outputPath = o,
+        ...qraftConfigRest
+      } = qraftConfig as {
+        ['output-dir']?: string;
+        o?: string;
+      };
+
+      if (!outputPath) {
+        throw new CommanderError(
+          1,
+          'ERR_MISSING_API_OUTPUT',
+          `API ${itemApiName} is missing an "output-dir" key. See https://openapi-qraft.github.io/openapi-qraft/docs/codegen/CLI/redocly-config.`
+        );
+      }
+
+      return [
+        itemApiName,
+        {
+          ...api,
+          root: new URL(api.root, configRoot),
+          [configKey]: {
+            ...qraftConfigRest,
+            ['output-dir']: fileURLToPath(new URL(outputPath, configRoot)),
+          },
+        },
+      ] as const;
+    })
+    .filter((api) => !!api);
+
+  return Object.fromEntries(apisToQraftEntries);
+}

package/src/lib/handleSchemaInput.ts

@@ -0,0 +1,58 @@
+import type { Ora } from 'ora';
+import process from 'node:process';
+import { URL } from 'node:url';
+
+/**
+ * Validates Schema's `input` and return `Readable` stream or `URL`
+ * @throws {Error} if input is invalid
+ */
+export function handleSchemaInput(
+  input: unknown,
+  cwd: URL,
+  spinner: Ora,
+  schemaName: string
+) {
+  if (!input) {
+    /**
+     * Handle `stdin`, if no input file is provided
+     * @example
+     * ```bash
+     * cat schema.json | script.js
+     * ```
+     */
+    if (process.stdin.isTTY) {
+      spinner.fail(
+        `Input file not found or stdin is empty. Please specify \`input\` argument or pipe ${schemaName} to stdin.`
+      );
+
+      throw new Error('Invalid input.');
+    }
+
+    return process.stdin;
+  }
+
+  /**
+   * Handle single file
+   * @example
+   * ```bash
+   * script.js schema.json
+   * ```
+   */
+
+  if (typeof input !== 'string') {
+    spinner.fail('Invalid input. Please specify a single file or URL.');
+
+    throw new Error('Invalid input.');
+  }
+
+  // throw error on glob
+  if (input.includes('*')) {
+    spinner.fail(
+      'Globbing is not supported. Please specify a single file or URL.'
+    );
+
+    throw new Error('Globbing is not supported.');
+  }
+
+  return new URL(input, cwd);
+}

package/src/lib/loadRedoclyConfig.ts

@@ -0,0 +1,47 @@
+import { fileURLToPath, URL } from 'node:url';
+import {
+  Config,
+  CONFIG_FILE_NAMES,
+  findConfig,
+  loadConfig,
+} from '@redocly/openapi-core';
+import { CommanderError } from 'commander';
+
+/**
+ * Loads Redocly config from the default config file:
+ * 'redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'
+ */
+export async function loadRedoclyConfig(
+  configPath: null | undefined | true,
+  cwd: URL
+): Promise<Config>;
+/**
+ * Loads Redocly config from the specified path or from the default config file.
+ */
+export async function loadRedoclyConfig(
+  configPath: string,
+  cwd: URL
+): Promise<Config>;
+export async function loadRedoclyConfig(
+  configPath: string | null | undefined | true,
+  cwd: URL
+): Promise<Config> {
+  const normalizedConfigPath =
+    typeof configPath === 'string'
+      ? configPath
+      : findConfig(fileURLToPath(cwd));
+
+  if (!normalizedConfigPath) {
+    throw new CommanderError(
+      1,
+      'INVALID_REDOCLY_CONFIG_PATH',
+      typeof configPath === 'string'
+        ? `Could not find Redocly config file at ${configPath}`
+        : `Could not find Redocly config file in ${cwd}. Searched in: ${CONFIG_FILE_NAMES.join(', ')}`
+    );
+  }
+
+  return await loadConfig({
+    configPath: normalizedConfigPath,
+  });
+}

package/src/lib/maybeEscapeShellArg.ts

@@ -0,0 +1,10 @@
+import { shouldQuoteCommandLineArg } from './shouldQuoteCommandLineArg.js';
+
+export function maybeEscapeShellArg(arg: string): string {
+  if (shouldQuoteCommandLineArg(arg)) {
+    // bash-safe single-quote escaping
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+  }
+
+  return arg;
+}

package/src/lib/parseConfigToArgs.ts

@@ -0,0 +1,134 @@
+/**
+ * Converts a parsed YAML configuration into command line arguments
+ * @param config The parsed YAML configuration object
+ * @returns Array of command line arguments
+ */
+export function parseConfigToArgs(config: Record<string, unknown>): string[] {
+  const args: string[] = [];
+
+  const isPrimitive = (val: any): val is string | number | boolean =>
+    typeof val === 'string' ||
+    typeof val === 'number' ||
+    typeof val === 'boolean';
+
+  function flattenMapping(node: any, prefixKeys: string[]): string[] {
+    const results: string[] = [];
+
+    if (isPrimitive(node)) {
+      if (typeof node === 'boolean') {
+        if (node) {
+          results.push(prefixKeys.join(':'));
+        }
+      } else {
+        results.push(`${prefixKeys.join(':')}:${node.toString()}`);
+      }
+      return results;
+    }
+
+    if (Array.isArray(node)) {
+      if (node.every((el) => isPrimitive(el))) {
+        const primitives = node.filter(
+          (el) => el !== null && el !== undefined
+        ) as (string | number | boolean)[];
+        const joined = primitives.map((el) => el.toString()).join(',');
+        if (joined) {
+          results.push(`${prefixKeys.join(':')}:${joined}`);
+        }
+        return results;
+      }
+
+      for (const el of node) {
+        if (el == null) {
+          continue;
+        }
+        results.push(...flattenMapping(el, prefixKeys));
+      }
+      return results;
+    }
+
+    if (typeof node === 'object' && node !== null) {
+      for (const [key, value] of Object.entries(node)) {
+        results.push(...flattenMapping(value, [...prefixKeys, key]));
+      }
+      return results;
+    }
+
+    return results;
+  }
+
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value === 'string' || typeof value === 'number') {
+      args.push(`--${key}`, value.toString());
+    } else if (typeof value === 'boolean') {
+      if (value) {
+        args.push(`--${key}`);
+      }
+    } else if (value == null) {
+      continue;
+    } else if (Array.isArray(value)) {
+      if (value.every((el) => isPrimitive(el))) {
+        const primitives = value.filter(
+          (el) => el !== null && el !== undefined
+        ) as (string | number | boolean)[];
+        args.push(`--${key}`, ...primitives.map((el) => el.toString()));
+      } else {
+        for (const el of value) {
+          if (el == null) {
+            continue;
+          }
+          if (typeof el === 'object') {
+            const mappingPaths = flattenMapping(el, []);
+            if (mappingPaths.length) {
+              args.push(`--${key}`, ...mappingPaths);
+            }
+          } else if (isPrimitive(el)) {
+            args.push(`--${key}`, el.toString());
+          }
+        }
+      }
+    } else if (typeof value === 'object') {
+      for (const [childKey, childValue] of Object.entries(
+        value as Record<string, unknown>
+      )) {
+        if (typeof childValue === 'string' || typeof childValue === 'number') {
+          args.push(`--${key}`, childKey, childValue.toString());
+        } else if (typeof childValue === 'boolean') {
+          if (childValue) {
+            args.push(`--${key}`, childKey);
+          }
+        } else if (childValue == null) {
+          continue;
+        } else if (Array.isArray(childValue)) {
+          if (childValue.every((el) => isPrimitive(el))) {
+            const primitives = childValue.filter(
+              (el) => el !== null && el !== undefined
+            ) as (string | number | boolean)[];
+            const joined = primitives.map((el) => el.toString()).join(',');
+            args.push(`--${key}`, childKey, joined);
+          } else {
+            for (const el of childValue) {
+              if (el == null) {
+                continue;
+              }
+              if (typeof el === 'object') {
+                const mappingPaths = flattenMapping(el, [childKey]);
+                if (mappingPaths.length) {
+                  args.push(`--${key}`, ...mappingPaths);
+                }
+              } else if (isPrimitive(el)) {
+                args.push(`--${key}`, childKey, el.toString());
+              }
+            }
+          }
+        } else if (typeof childValue === 'object') {
+          const mappingPaths = flattenMapping(childValue, []);
+          if (mappingPaths.length) {
+            args.push(`--${key}`, childKey, ...mappingPaths);
+          }
+        }
+      }
+    }
+  }
+
+  return args;
+}

package/src/lib/shouldQuoteCommandLineArg.ts

@@ -0,0 +1,32 @@
+/**
+ * Checks if a command-line argument needs to be quoted when used in a command line.
+ *
+ * Arguments containing special characters like spaces, quotes, or shell metacharacters
+ * need to be wrapped in quotes to be properly interpreted by the shell.
+ *
+ * @param arg The command-line argument to check
+ * @returns True if the argument needs quotes, false otherwise
+ */
+export function shouldQuoteCommandLineArg(arg: string): boolean {
+  if (!arg) return false;
+
+  // Check for spaces
+  if (arg.includes(' ')) return true;
+
+  // Check for quotes
+  if (arg.includes('"') || arg.includes("'")) return true;
+
+  // Check for shell metacharacters and special characters
+  const shellSpecialChars = /[&|<>(){}[\]$;!*?~`\n\r\t#]/;
+  if (shellSpecialChars.test(arg)) return true;
+
+  // Check for control characters
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x1F\x7F]/.test(arg)) return true;
+
+  // Check if argument starts with a dash (to avoid confusion with options)
+  if (arg.startsWith('-') && !arg.startsWith('--')) return true;
+
+  // Check for wildcards
+  return arg.includes('*') || arg.includes('?');
+}

package/src/lib/writeGeneratorFiles.ts

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import c from 'ansi-colors';
+import { Ora } from 'ora';
+import { GeneratorFile } from './GeneratorFile.js';
+
+export const writeGeneratorFiles = async ({
+  spinner,
+  fileItems,
+}: {
+  spinner: Ora;
+  fileItems: GeneratorFile[];
+}) => {
+  await setupDirectories(spinner, fileItems);
+  await writeFiles(spinner, fileItems);
+};
+
+const setupDirectories = async (spinner: Ora, fileItems: GeneratorFile[]) => {
+  for (const fileItem of fileItems) {
+    if (!('directory' in fileItem)) continue;
+
+    if (fileItem.clean) {
+      spinner.text = `Cleaning ${c.magenta(fileItem.directory.pathname)}`;
+
+      try {
+        await fs.promises.rm(fileItem.directory, {
+          recursive: true,
+          force: true,
+        });
+      } catch (error) {
+        spinner.fail(
+          c.redBright(
+            `Error occurred during ${c.magenta(
+              fileItem.directory.pathname
+            )} directory cleaning`
+          )
+        );
+
+        throw error;
+      }
+    }
+
+    try {
+      spinner.text = `Creating directory ${c.magenta(fileItem.directory.pathname)}`;
+
+      await fs.promises.mkdir(fileItem.directory, { recursive: true });
+    } catch (error) {
+      spinner.fail(
+        c.redBright(
+          `Error occurred during ${c.magenta(
+            fileItem.directory.pathname
+          )} directory creation`
+        )
+      );
+
+      throw error;
+    }
+  }
+};
+
+const writeFiles = async (spinner: Ora, fileItems: GeneratorFile[]) => {
+  for (const fileItem of fileItems) {
+    if ('directory' in fileItem) continue;
+
+    const { file, code } = fileItem;
+
+    spinner.text = `Writing ${c.magenta(file.pathname)}`;
+
+    try {
+      await fs.promises.writeFile(file, code, {
+        encoding: 'utf-8',
+      });
+    } catch (error) {
+      spinner.fail(
+        c.redBright(
+          `Error occurred during ${c.magenta(file.pathname)} file writing`
+        )
+      );
+
+      throw error;
+    }
+  }
+};

package/src/packageVersion.ts

@@ -0,0 +1,2 @@
+// This file was generated automatically
+export const packageVersion = '1.0.0-beta.0';