@ygorazambuja/sauron 1.0.0

package/src/cli/main.ts

@@ -0,0 +1,276 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+	createModelsWithOperationTypes,
+	fetchJsonFromUrl,
+	readJsonFile,
+	verifySwaggerComposition,
+} from "../utils";
+import { runHttpPlugins } from "../plugins/runner";
+import { parseArgs, parseCommand, showHelp } from "./args";
+import {
+	createGeneratedFileHeader,
+	formatGeneratedFile,
+	initConfigFile,
+	loadSauronConfig,
+	mergeOptionsWithConfig,
+} from "./config";
+import { isAngularProject, resolveOutputBasePath } from "./project";
+import { DEFAULT_CONFIG_FILE, type CliOptions } from "./types";
+
+/**
+ * Main.
+ * @example
+ * ```ts
+ * main();
+ * ```
+ */
+export async function main() {
+	const command = parseCommand();
+	const cliOptions = parseArgs();
+
+	if (cliOptions.help) {
+		showHelp();
+		return;
+	}
+
+	if (command === "init") {
+		await initConfigFile(cliOptions.config || DEFAULT_CONFIG_FILE);
+		return;
+	}
+
+	let options = cliOptions;
+
+	try {
+		const loadedConfig = await loadSauronConfig(
+			options.config || DEFAULT_CONFIG_FILE,
+		);
+		if (loadedConfig) {
+			options = mergeOptionsWithConfig(cliOptions, loadedConfig);
+			console.log(
+				`⚙️  Using config file: ${options.config || DEFAULT_CONFIG_FILE}`,
+			);
+		}
+
+		let config: unknown;
+		if (options.url) {
+			console.log(`📖 Downloading OpenAPI spec from: ${options.url}`);
+			config = await fetchJsonFromUrl(options.url);
+		}
+		if (!options.url) {
+			console.log(`📖 Reading OpenAPI spec from: ${options.input}`);
+			config = await readJsonFile(options.input);
+		}
+
+		if (typeof config !== "object") {
+			throw new Error("Config is not an object");
+		}
+
+		console.log("✅ Validating OpenAPI schema...");
+		const schema = verifySwaggerComposition(config as Record<string, unknown>);
+
+		const requestedPluginIds = resolveEffectivePluginIds(options);
+		logPluginCompatibilityNotice(options, requestedPluginIds);
+
+		const angularDetected = isAngularProject();
+		const preferAngularOutput = requestedPluginIds.includes("angular");
+		const baseOutputPath = resolveOutputBasePath(options, preferAngularOutput);
+		const modelsPath = join(baseOutputPath, "models", "index.ts");
+		mkdirSync(dirname(modelsPath), { recursive: true });
+
+		const fileHeader = createGeneratedFileHeader(schema);
+
+		console.log("🔧 Generating TypeScript models...");
+		const { models, operationTypes, typeNameMap } =
+			createModelsWithOperationTypes(schema);
+		const formattedModels = await formatGeneratedFile(
+			`${fileHeader}\n${models.join("\n")}`,
+			modelsPath,
+		);
+		writeFileSync(modelsPath, formattedModels);
+
+		const pluginResults = await runHttpPlugins(requestedPluginIds, {
+			schema,
+			options,
+			baseOutputPath,
+			modelsPath,
+			fileHeader,
+			operationTypes,
+			typeNameMap,
+			isAngularProject: angularDetected,
+			writeFormattedFile: async (filePath: string, content: string) => {
+				const formattedContent = await formatGeneratedFile(content, filePath);
+				writeFileSync(filePath, formattedContent);
+			},
+		});
+
+		logPluginReports(pluginResults);
+
+		console.log("\n✅ Generation complete!");
+		console.log(`📄 Models: ${models.length} TypeScript interfaces/types`);
+		logPluginMethodSummary(pluginResults);
+		console.log(`📁 Output: ${resolveOutputDisplayPath(options, angularDetected, preferAngularOutput)}`);
+	} catch (error) {
+		console.error("❌ Error:", error);
+		process.exit(1);
+	}
+}
+
+/**
+ * Resolve effective plugin IDs.
+ * @param options Input parameter `options`.
+ * @returns Resolve effective plugin IDs output as `string[]`.
+ * @example
+ * ```ts
+ * const result = resolveEffectivePluginIds({
+ * 	input: "swagger.json",
+ * 	angular: false,
+ * 	http: true,
+ * 	help: false,
+ * });
+ * // result: string[]
+ * ```
+ */
+function resolveEffectivePluginIds(options: CliOptions): string[] {
+	if (options.plugin && options.plugin.length > 0) {
+		return normalizePluginIds(options.plugin);
+	}
+
+	if (!options.http) {
+		return [];
+	}
+
+	if (options.angular) {
+		return ["angular"];
+	}
+
+	return ["fetch"];
+}
+
+/**
+ * Normalize plugin IDs.
+ * @param pluginIds Input parameter `pluginIds`.
+ * @returns Normalize plugin IDs output as `string[]`.
+ * @example
+ * ```ts
+ * const result = normalizePluginIds(["fetch", "Angular"]);
+ * // result: string[]
+ * ```
+ */
+function normalizePluginIds(pluginIds: string[]): string[] {
+	const normalizedIds: string[] = [];
+	const usedIds = new Set<string>();
+
+	for (const pluginId of pluginIds) {
+		const normalizedId = pluginId.trim().toLowerCase();
+		if (!normalizedId) {
+			continue;
+		}
+		if (usedIds.has(normalizedId)) {
+			continue;
+		}
+		usedIds.add(normalizedId);
+		normalizedIds.push(normalizedId);
+	}
+
+	return normalizedIds;
+}
+
+/**
+ * Log plugin compatibility notice.
+ * @param options Input parameter `options`.
+ * @param effectivePluginIds Input parameter `effectivePluginIds`.
+ * @example
+ * ```ts
+ * logPluginCompatibilityNotice(
+ * 	{ input: "swagger.json", angular: true, http: true, help: false, plugin: ["fetch"] },
+ * 	["fetch"],
+ * );
+ * ```
+ */
+function logPluginCompatibilityNotice(
+	options: CliOptions,
+	effectivePluginIds: string[],
+): void {
+	if (!options.plugin || options.plugin.length === 0) {
+		return;
+	}
+	if (!options.http && !options.angular) {
+		return;
+	}
+	if (effectivePluginIds.length === 0) {
+		return;
+	}
+
+	console.log(
+		"ℹ️  --plugin provided. Ignoring compatibility aliases --http/--angular.",
+	);
+}
+
+/**
+ * Log plugin reports.
+ * @param pluginResults Input parameter `pluginResults`.
+ * @example
+ * ```ts
+ * logPluginReports([]);
+ * ```
+ */
+function logPluginReports(
+	pluginResults: Array<{ reportPath: string; typeCoverageReportPath?: string }>,
+): void {
+	for (const result of pluginResults) {
+		console.log(`🧾 Missing Swagger definitions report: ${result.reportPath}`);
+		if (!result.typeCoverageReportPath) {
+			continue;
+		}
+		console.log(`📊 Type coverage report: ${result.typeCoverageReportPath}`);
+	}
+}
+
+/**
+ * Log plugin method summary.
+ * @param pluginResults Input parameter `pluginResults`.
+ * @example
+ * ```ts
+ * logPluginMethodSummary([]);
+ * ```
+ */
+function logPluginMethodSummary(
+	pluginResults: Array<{ executedPluginId: string; methodCount: number }>,
+): void {
+	for (const result of pluginResults) {
+		console.log(
+			`🔗 HTTP Methods (${result.executedPluginId}): ${result.methodCount} methods`,
+		);
+	}
+}
+
+/**
+ * Resolve output display path.
+ * @param options Input parameter `options`.
+ * @param angularDetected Input parameter `angularDetected`.
+ * @param preferAngularOutput Input parameter `preferAngularOutput`.
+ * @returns Resolve output display path output as `string`.
+ * @example
+ * ```ts
+ * const result = resolveOutputDisplayPath(
+ * 	{ input: "swagger.json", angular: false, http: false, help: false },
+ * 	false,
+ * 	false,
+ * );
+ * // result: string
+ * ```
+ */
+function resolveOutputDisplayPath(
+	options: CliOptions,
+	angularDetected: boolean,
+	preferAngularOutput: boolean,
+): string {
+	if (options.output) {
+		return options.output;
+	}
+	if (preferAngularOutput && angularDetected) {
+		return "src/app/sauron";
+	}
+	return "outputs";
+}

package/src/cli/project.ts

@@ -0,0 +1,113 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { CliOptions } from "./types";
+
+/**
+ * Is angular project.
+ * @returns Is angular project output as `boolean`.
+ * @example
+ * ```ts
+ * const result = isAngularProject();
+ * // result: boolean
+ * ```
+ */
+export function isAngularProject(): boolean {
+	if (existsSync("angular.json")) {
+		return true;
+	}
+
+	try {
+		const packageJsonPath = join(process.cwd(), "package.json");
+		if (existsSync(packageJsonPath)) {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+			const deps = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+			};
+			return "@angular/core" in deps;
+		}
+	} catch (_error) {
+		// Ignore errors when checking package.json
+	}
+
+	return false;
+}
+
+/**
+ * Get output paths.
+ * @param options Input parameter `options`.
+ * @returns Get output paths output as `unknown`.
+ * @example
+ * ```ts
+ * const result = getOutputPaths({});
+ * // result: unknown
+ * ```
+ */
+export function getOutputPaths(options: CliOptions): {
+	modelsPath: string;
+	servicePath: string | undefined;
+} {
+	const basePath = resolveOutputBasePath(options, options.angular);
+
+	mkdirSync(join(basePath, "models"), { recursive: true });
+
+	let servicePath: string;
+	if (options.http) {
+		const serviceDir =
+			options.angular && isAngularProject()
+				? "angular-http-client"
+				: "http-client";
+		mkdirSync(join(basePath, serviceDir), { recursive: true });
+
+		const serviceFileName =
+			options.angular && isAngularProject()
+				? "sauron-api.service.ts"
+				: "sauron-api.client.ts";
+
+		servicePath = join(basePath, serviceDir, serviceFileName);
+	} else {
+		servicePath = "";
+	}
+
+	return {
+		modelsPath: join(basePath, "models", "index.ts"),
+		servicePath,
+	};
+}
+
+/**
+ * Resolve output base path.
+ * @param options Input parameter `options`.
+ * @param preferAngularOutput Input parameter `preferAngularOutput`.
+ * @returns Resolve output base path output as `string`.
+ * @example
+ * ```ts
+ * const result = resolveOutputBasePath(
+ * 	{ input: "swagger.json", angular: false, http: false, help: false },
+ * 	false,
+ * );
+ * // result: string
+ * ```
+ */
+export function resolveOutputBasePath(
+	options: CliOptions,
+	preferAngularOutput: boolean,
+): string {
+	if (options.output) {
+		return resolve(options.output);
+	}
+
+	const angularDetected = isAngularProject();
+	if (preferAngularOutput && angularDetected) {
+		console.log("✅ Angular project detected! Generating in src/app/sauron/");
+		return "src/app/sauron";
+	}
+
+	if (options.angular && !angularDetected) {
+		console.warn(
+			"⚠️  --angular flag used but Angular project not detected. Generating in outputs/ instead.",
+		);
+	}
+
+	return "outputs";
+}

package/src/cli/types.ts

@@ -0,0 +1,22 @@
+export interface CliOptions {
+	input: string;
+	url?: string;
+	angular: boolean;
+	http: boolean;
+	plugin?: string[];
+	output?: string;
+	config?: string;
+	help: boolean;
+}
+
+export interface SauronConfig {
+	input?: string;
+	url?: string;
+	angular?: boolean;
+	http?: boolean;
+	plugin?: string[];
+	output?: string;
+}
+
+export const DEFAULT_CONFIG_FILE = "sauron.config.ts";
+export const DEFAULT_SAURON_VERSION = "1.0.0";

package/src/generators/angular.ts

@@ -0,0 +1,76 @@
+/**
+ * Generate angular service.
+ * @param methods Input parameter `methods`.
+ * @param imports Input parameter `imports`.
+ * @param _isAngularProject Input parameter `_isAngularProject`.
+ * @param paramsInterfaces Input parameter `paramsInterfaces`.
+ * @returns Generate angular service output as `string`.
+ * @example
+ * ```ts
+ * const result = generateAngularService([], [], true, []);
+ * // result: string
+ * ```
+ */
+export function generateAngularService(
+  methods: string[],
+  imports: string[],
+  _isAngularProject: boolean,
+  paramsInterfaces: string[] = [],
+): string {
+  const importStatement = buildModelImportStatement(imports);
+  const interfacesBlock = buildInterfacesBlock(paramsInterfaces);
+  const methodsBlock = methods.join("\n\n");
+
+  const serviceTemplate = `import { Injectable, inject } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { Observable } from "rxjs";
+
+${importStatement}\n${interfacesBlock}\n\n
+@Injectable({
+  providedIn: "root"
+})
+export class SauronApiService {
+  private readonly httpClient = inject(HttpClient);
+
+${methodsBlock}
+}
+`;
+
+  return serviceTemplate;
+}
+
+/**
+ * Build model import statement.
+ * @param imports Input parameter `imports`.
+ * @returns Build model import statement output as `string`.
+ * @example
+ * ```ts
+ * const result = buildModelImportStatement([]);
+ * // result: string
+ * ```
+ */
+function buildModelImportStatement(imports: string[]): string {
+  if (imports.length === 0) {
+    return "";
+  }
+  const importList = imports.join(", ");
+  const importPath = "../models";
+  return `import { ${importList} } from "${importPath}";\n`;
+}
+
+/**
+ * Build interfaces block.
+ * @param paramsInterfaces Input parameter `paramsInterfaces`.
+ * @returns Build interfaces block output as `string`.
+ * @example
+ * ```ts
+ * const result = buildInterfacesBlock([]);
+ * // result: string
+ * ```
+ */
+function buildInterfacesBlock(paramsInterfaces: string[]): string {
+  if (paramsInterfaces.length === 0) {
+    return "";
+  }
+  return `${paramsInterfaces.join("\n\n")}\n\n`;
+}