nuxt-openapi-hyperfetch 0.1.0-alpha.1

package/eslint.config.js

@@ -0,0 +1,72 @@
+// @ts-check
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import prettierConfig from 'eslint-config-prettier';
+import prettierPlugin from 'eslint-plugin-prettier';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  prettierConfig,
+  {
+    plugins: {
+      prettier: prettierPlugin,
+    },
+    languageOptions: {
+      parserOptions: {
+        project: './tsconfig.json',
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      'prettier/prettier': 'error',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+        },
+      ],
+      '@typescript-eslint/no-floating-promises': 'error',
+      '@typescript-eslint/no-misused-promises': 'error',
+      '@typescript-eslint/no-unsafe-assignment': 'warn',
+      '@typescript-eslint/no-unsafe-member-access': 'warn',
+      '@typescript-eslint/no-unsafe-call': 'warn',
+      '@typescript-eslint/no-unsafe-return': 'warn',
+      '@typescript-eslint/no-unsafe-argument': 'warn',
+      '@typescript-eslint/restrict-template-expressions': 'warn',
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        {
+          'ts-nocheck': 'allow-with-description',
+          minimumDescriptionLength: 10,
+        },
+      ],
+      'no-console': 'off',
+      'prefer-const': 'error',
+      'no-var': 'error',
+      'no-useless-escape': 'warn',
+      eqeqeq: ['error', 'always'],
+      curly: ['error', 'all'],
+    },
+  },
+  {
+    ignores: [
+      'dist/**',
+      'node_modules/**',
+      'swagger/**',
+      'test-*/**',
+      'index.ts',
+      // Ignore runtime files - they run in user's project with different rules
+      'src/generators/*/runtime/**',
+      'src/generators/shared/runtime/**',
+      'src/generators/shared/templates/**',
+      '*.js',
+      '*.mjs',
+      '*.cjs',
+    ],
+  }
+);

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "nuxt-openapi-hyperfetch",
+  "version": "0.1.0-alpha.1",
+  "description": "Nuxt useFetch, useAsyncData and Nuxt server OpenAPI generator",
+  "type": "module",
+  "author": "",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "docs",
+    "src",
+    ".editorconfig",
+    ".prettierignore",
+    ".prettierrc.json",
+    "CONTRIBUTING.md",
+    "eslint.config.js",
+    "index.ts",
+    "INSTRUCTIONS.md",
+    "LICENSE",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "bin": {
+    "nxh": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "tsc && node ./dist/index.js",
+    "generator": "nxh generate -i ./swagger.yaml -o ./swagger",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"**/*.{ts,json,md,yaml,yml}\"",
+    "format:check": "prettier --check \"**/*.{ts,json,md,yaml,yml}\"",
+    "type-check": "tsc --noEmit",
+    "validate": "npm run type-check && npm run lint && npm run format:check"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "@typescript-eslint/parser": "^8.57.1",
+    "eslint": "^10.1.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.57.1"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@hey-api/openapi-ts": "0.94.4",
+    "@openapitools/openapi-generator-cli": "2.30.2",
+    "change-case": "^5.4.4",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4",
+    "globby": "^16.1.1",
+    "gradient-string": "^3.0.0",
+    "prettier": "^3.8.1",
+    "ts-morph": "^27.0.2"
+  },
+  "keywords": []
+}

package/src/cli/config.ts

@@ -0,0 +1,140 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import * as p from '@clack/prompts';
+import type { GeneratorBackend, ConfigGenerator } from './types.js';
+
+const { existsSync } = fs;
+
+/**
+ * Configuration options for the generator
+ */
+export interface GeneratorConfig {
+  /** Path or URL to OpenAPI specification */
+  input?: string;
+  /** Output directory for generated files */
+  output?: string;
+  /** Base URL for API requests */
+  baseUrl?: string;
+  /** Generation mode: client or server */
+  mode?: 'client' | 'server';
+  /** Generate only specific tags */
+  tags?: string[];
+  /** Exclude specific tags */
+  excludeTags?: string[];
+  /** Overwrite existing files without prompting */
+  overwrite?: boolean;
+  /** Preview changes without writing files */
+  dryRun?: boolean;
+  /** Enable verbose logging */
+  verbose?: boolean;
+  /** Watch mode - regenerate on file changes */
+  watch?: boolean;
+  /** Generator types to use */
+  generators?: ('useFetch' | 'useAsyncData' | 'nuxtServer')[];
+  /** Server route path (for nuxtServer mode) */
+  serverRoutePath?: string;
+  /** Enable BFF pattern (for nuxtServer mode) */
+  enableBff?: boolean;
+  /** Generator backend: official (Java) or heyapi (Node.js) */
+  backend?: GeneratorBackend;
+  /**
+   * Generation engine to use.
+   * - 'openapi': @openapitools/openapi-generator-cli (requires Java 11+)
+   * - 'heyapi': @hey-api/openapi-ts (Node.js native, no Java required)
+   * When set, the CLI will not ask which engine to use.
+   */
+  generator?: ConfigGenerator;
+}
+
+/**
+ * Load configuration from nxh.config.js, nuxt-openapi-generator.config.js, or package.json
+ */
+export async function loadConfig(cwd: string = process.cwd()): Promise<GeneratorConfig | null> {
+  // Try different config file names
+  const configFiles = [
+    'nxh.config.js',
+    'nxh.config.mjs',
+    'nuxt-openapi-hyperfetch.js',
+    'nuxt-openapi-hyperfetch.mjs',
+  ];
+
+  for (const configFile of configFiles) {
+    const configPath = join(cwd, configFile);
+    if (existsSync(configPath)) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const config = await import(`file://${configPath}`);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
+        const exportedConfig = config.default || config;
+        return exportedConfig as GeneratorConfig;
+      } catch (error) {
+        p.log.warn(`Failed to load config from ${configFile}: ${String(error)}`);
+      }
+    }
+  }
+
+  // Try package.json
+  const packageJsonPath = join(cwd, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const packageJson = await import(`file://${packageJsonPath}`, {
+        assert: { type: 'json' },
+      });
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (packageJson.default?.['nuxt-openapi-hyperfetch']) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return packageJson.default['nuxt-openapi-hyperfetch'] as GeneratorConfig;
+      }
+    } catch {
+      // Silently ignore package.json errors
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Merge CLI options with config file, CLI takes precedence
+ */
+export function mergeConfig(
+  fileConfig: GeneratorConfig | null,
+  cliOptions: Partial<GeneratorConfig>
+): GeneratorConfig {
+  return {
+    ...fileConfig,
+    ...cliOptions,
+    // Handle arrays specially - CLI should override completely
+    tags: cliOptions.tags || fileConfig?.tags,
+    excludeTags: cliOptions.excludeTags || fileConfig?.excludeTags,
+    generators: cliOptions.generators || fileConfig?.generators,
+  };
+}
+
+/**
+ * Parse comma-separated tags string into array
+ */
+export function parseTags(tagsString?: string): string[] | undefined {
+  if (!tagsString) {
+    return undefined;
+  }
+  return tagsString
+    .split(',')
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Parse generators string into array
+ */
+export function parseGenerators(
+  generatorsString?: string
+): ('useFetch' | 'useAsyncData' | 'nuxtServer')[] | undefined {
+  if (!generatorsString) {
+    return undefined;
+  }
+  const parts = generatorsString.split(',').map((g) => g.trim());
+  return parts.filter((g): g is 'useFetch' | 'useAsyncData' | 'nuxtServer' =>
+    ['useFetch', 'useAsyncData', 'nuxtServer'].includes(g)
+  );
+}

package/src/cli/logger.ts

@@ -0,0 +1,66 @@
+/**
+ * Centralized logging utilities using @clack/prompts
+ * Re-exports @clack for easy use across the project
+ */
+import * as p from '@clack/prompts';
+
+/**
+ * Re-export @clack/prompts for consistent usage
+ */
+export { p };
+
+/**
+ * Create and manage a spinner for long operations
+ *
+ * @example
+ * const spinner = createSpinner();
+ * spinner.start('Processing files');
+ * // do work
+ * spinner.stop('Files processed');
+ */
+export function createSpinner() {
+  return p.spinner();
+}
+
+/**
+ * Log a success message (replaces console.log with ✓)
+ */
+export function logSuccess(message: string) {
+  p.log.success(message);
+}
+
+/**
+ * Log an error message
+ */
+export function logError(message: string) {
+  p.log.error(message);
+}
+
+/**
+ * Log a warning message
+ */
+export function logWarning(message: string) {
+  p.log.warn(message);
+}
+
+/**
+ * Log an info message
+ */
+export function logInfo(message: string) {
+  p.log.info(message);
+}
+
+/**
+ * Display a note/box with multiple lines of information
+ * Great for "Next steps" sections
+ */
+export function logNote(message: string, title?: string) {
+  p.note(message, title);
+}
+
+/**
+ * Display section separator
+ */
+export function logStep(message: string) {
+  p.log.step(message);
+}

package/src/cli/logo.ts

@@ -0,0 +1,25 @@
+import gradient from 'gradient-string';
+
+const NUXT_LOGO = `███╗   ██╗██╗   ██╗██╗  ██╗████████╗
+████╗  ██║██║   ██║╚██╗██╔╝╚══██╔══╝
+██╔██╗ ██║██║   ██║ ╚███╔╝    ██║   
+██║╚██╗██║██║   ██║ ██╔██╗    ██║   
+██║ ╚████║╚██████╔╝██╔╝ ██╗   ██║   
+╚═╝  ╚═══╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝`;
+
+const SUBTITLE = '   Swagger OpenAPI Generator v1.0';
+
+/**
+ * Display the Nuxt logo with gradient colors
+ * - Green gradient for Nuxt logo (official Nuxt color #00DC82)
+ * - Blue gradient for Swagger subtitle
+ */
+export function displayLogo(): void {
+  const nuxtGradient = gradient('#00DC82', '#00E090');
+  const swaggerGradient = gradient('#3B82F6', '#0EA5E9');
+
+  console.log('\n');
+  console.log(nuxtGradient(NUXT_LOGO));
+  console.log(swaggerGradient(SUBTITLE));
+  console.log('\n');
+}

package/src/cli/messages.ts

@@ -0,0 +1,97 @@
+/**
+ * Centralized messages and text content for CLI
+ */
+import type { GeneratorBackend } from './types.js';
+
+/**
+ * Main messages used throughout the CLI
+ */
+export const MESSAGES = {
+  // Intro/Outro messages
+  intro: '🎨 Nuxt Swagger Generator',
+  outro: {
+    success: '🎉 All done! Your files are ready.',
+    cancelled: '👋 Operation cancelled.',
+    noComposables: '✓ OpenAPI files generated successfully!\nNo composables selected.',
+  },
+
+  // Prompt messages
+  prompts: {
+    selectBackend: 'Select the OpenAPI code generator:',
+    inputPath: 'Enter the path to your OpenAPI/Swagger file:',
+    outputPath: 'Enter the output directory for generated files:',
+    selectComposables: 'Select which composables you want to generate:',
+    serverPath: 'Where do you want to generate server routes?',
+    customPath: 'Enter custom server route path:',
+    enableBff: 'Enable BFF (Backend for Frontend) with transformers and auth?',
+  },
+
+  // Process step messages
+  steps: {
+    generatingOpenApi: 'Generating OpenAPI files',
+  },
+};
+
+/**
+ * Predefined choices for select/multiselect prompts
+ */
+export const CHOICES = {
+  // Generator backend options
+  backends: [
+    {
+      value: 'official' as const,
+      label: 'OpenAPI Generator (official)',
+      hint: 'Requires Java 11+',
+    },
+    {
+      value: 'heyapi' as const,
+      label: '@hey-api/openapi-ts (Node.js)',
+      hint: 'No Java required',
+    },
+  ] satisfies { value: GeneratorBackend; label: string; hint: string }[],
+
+  // Composables selection
+  composables: [
+    {
+      value: 'useFetch',
+      label: 'useFetch - Nuxt useFetch composables',
+      hint: 'Recommended for most use cases',
+    },
+    {
+      value: 'useAsyncData',
+      label: 'useAsyncData - Nuxt useAsyncData composables',
+    },
+    {
+      value: 'nuxtServer',
+      label: 'Nuxt Server Routes - Generate server/api/* proxy routes',
+    },
+  ],
+
+  // Server path options
+  serverPaths: [
+    {
+      value: 'server/api',
+      label: 'server/api (recommended)',
+      hint: 'Standard Nuxt server directory',
+    },
+    {
+      value: 'src/server/api',
+      label: 'src/server/api',
+    },
+    {
+      value: 'custom',
+      label: 'Custom path...',
+    },
+  ],
+};
+
+/**
+ * Default values for prompts
+ */
+export const DEFAULTS = {
+  inputPath: './swagger.yaml',
+  outputPath: './swagger',
+  serverPath: 'server/api',
+  customPath: './server/api',
+  enableBff: true,
+};

package/src/cli/prompts.ts

@@ -0,0 +1,143 @@
+/**
+ * All CLI prompts using @clack/prompts
+ * Each function handles a specific prompt flow and returns typed data
+ */
+import * as p from '@clack/prompts';
+import { checkCancellation, validateNonEmpty } from './utils.js';
+import { MESSAGES, CHOICES, DEFAULTS } from './messages.js';
+import type {
+  InitialInputs,
+  ComposablesSelection,
+  BffConfig,
+  ComposableType,
+  GeneratorBackend,
+} from './types.js';
+
+/**
+ * Ask which OpenAPI generator backend to use
+ */
+export async function promptGeneratorBackend(
+  provided?: GeneratorBackend
+): Promise<GeneratorBackend> {
+  if (provided) {
+    return provided;
+  }
+  const result = await p.select({
+    message: MESSAGES.prompts.selectBackend,
+    options: CHOICES.backends,
+    initialValue: 'official' as const,
+  });
+  checkCancellation(result);
+  return result as GeneratorBackend;
+}
+
+/**
+ * Ask for input and output paths
+ * Only asks for paths that weren't provided via CLI arguments
+ */
+export async function promptInitialInputs(
+  inputProvided?: string,
+  outputProvided?: string
+): Promise<InitialInputs> {
+  let inputPath = inputProvided;
+  let outputPath = outputProvided;
+
+  // Ask for input path if not provided
+  if (!inputPath) {
+    const result = await p.text({
+      message: MESSAGES.prompts.inputPath,
+      placeholder: DEFAULTS.inputPath,
+      defaultValue: DEFAULTS.inputPath,
+    });
+    checkCancellation(result);
+    inputPath = result as string;
+  }
+
+  // Ask for output path if not provided
+  if (!outputPath) {
+    const result = await p.text({
+      message: MESSAGES.prompts.outputPath,
+      placeholder: DEFAULTS.outputPath,
+      defaultValue: DEFAULTS.outputPath,
+    });
+    checkCancellation(result);
+    outputPath = result as string;
+  }
+
+  return { inputPath, outputPath };
+}
+
+/**
+ * Ask for the input path only (used when only nuxtServer is selected)
+ */
+export async function promptInputPath(provided?: string): Promise<string> {
+  if (provided) {
+    return provided;
+  }
+  const result = await p.text({
+    message: MESSAGES.prompts.inputPath,
+    placeholder: DEFAULTS.inputPath,
+    defaultValue: DEFAULTS.inputPath,
+  });
+  checkCancellation(result);
+  return result as string;
+}
+
+/**
+ * Ask which composables to generate (multiselect)
+ * Allows user to select none, one, or multiple composables
+ */
+export async function promptComposablesSelection(): Promise<ComposablesSelection> {
+  const result = await p.multiselect({
+    message: MESSAGES.prompts.selectComposables,
+    options: CHOICES.composables,
+    initialValues: ['useFetch'], // useFetch checked by default
+    required: false, // Allow empty selection
+  });
+  checkCancellation(result);
+
+  return { composables: result as ComposableType[] };
+}
+
+/**
+ * Ask for server route path
+ * If user selects 'custom', prompts for custom path
+ * Returns the final path to use
+ */
+export async function promptServerRoutePath(): Promise<string> {
+  // First, ask for the path type
+  const pathResult = await p.select({
+    message: MESSAGES.prompts.serverPath,
+    options: CHOICES.serverPaths,
+    initialValue: DEFAULTS.serverPath,
+  });
+  checkCancellation(pathResult);
+
+  // If custom selected, ask for custom path
+  if (pathResult === 'custom') {
+    const customResult = await p.text({
+      message: MESSAGES.prompts.customPath,
+      placeholder: DEFAULTS.customPath,
+      defaultValue: DEFAULTS.customPath,
+      validate: validateNonEmpty,
+    });
+    checkCancellation(customResult);
+    return customResult as string;
+  }
+
+  return pathResult as string;
+}
+
+/**
+ * Ask about BFF (Backend for Frontend) support
+ * Returns whether BFF should be enabled
+ */
+export async function promptBffConfig(): Promise<BffConfig> {
+  const result = await p.confirm({
+    message: MESSAGES.prompts.enableBff,
+    initialValue: DEFAULTS.enableBff,
+  });
+  checkCancellation(result);
+
+  return { enableBff: result as boolean };
+}

package/src/cli/types.ts

@@ -0,0 +1,50 @@
+/**
+ * TypeScript types for CLI prompts and responses
+ */
+
+/**
+ * Generator backend selector (internal)
+ */
+export type GeneratorBackend = 'official' | 'heyapi';
+
+/**
+ * Generator engine value for nxh.config — user-facing alias
+ * 'openapi' maps to the official Java-based OpenAPI Generator
+ * 'heyapi' maps to @hey-api/openapi-ts (Node.js native)
+ */
+export type ConfigGenerator = 'openapi' | 'heyapi';
+
+/**
+ * Initial input and output paths
+ */
+export interface InitialInputs {
+  inputPath: string;
+  outputPath: string;
+}
+
+/**
+ * Composables selection (checkbox response)
+ */
+export interface ComposablesSelection {
+  composables: Array<'useFetch' | 'useAsyncData' | 'nuxtServer'>;
+}
+
+/**
+ * Server route path configuration
+ */
+export interface ServerRouteConfig {
+  serverPath: string;
+  customPath?: string;
+}
+
+/**
+ * BFF (Backend for Frontend) configuration
+ */
+export interface BffConfig {
+  enableBff: boolean;
+}
+
+/**
+ * Valid composable types
+ */
+export type ComposableType = 'useFetch' | 'useAsyncData' | 'nuxtServer';