@genapi/pipeline 3.7.1 → 4.1.0

package/LICENSE.md

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025-PRESENT Hairyf <https://github.com/hairyf>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025-PRESENT Hairyf <https://github.com/hairyf>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @genapi/pipeline
+
+<!-- automd:badges -->
+
+[![npm version](https://img.shields.io/npm/v/@genapi/pipeline)](https://npmjs.com/package/@genapi/pipeline)
+[![npm downloads](https://img.shields.io/npm/dm/@genapi/pipeline)](https://npm.chart.dev/@genapi/pipeline)
+
+<!-- /automd -->
+
+GenAPI pipeline core: config reading, data source fetching, parsing, compilation, generation, and output. Composable for custom generation flows.
+
+## Installation
+
+```bash
+pnpm add @genapi/pipeline
+```
+
+## API
+
+<!-- automd:jsdocs src=src/index.ts -->
+
+## Pipeline
+
+### `compiler(configRead)`
+
+Compiles graphs to code string: request and typings for each output.
+
+**Example:**
+
+```ts
+compiler(configRead)
+configRead.outputs.forEach(o => console.log(o.code))
+```
+
+### `config(userConfig)`
+
+Normalizes pipeline config: output paths, responseType, baseURL, and builds ConfigRead with inputs/outputs.
+
+**Example:**
+
+```ts
+const configRead = config(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+```
+
+### `default(config, original, parser, compiler, generate, dest)`
+
+Builds a GenAPI pipeline from five steps: config → original → parser → compiler → generate → dest.
+
+**Example:**
+
+```ts
+const run = pipeline(config, original, parser, compiler, generate, dest)
+await run(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+```
+
+### `dest(configRead)`
+
+Writes output files from configRead.outputs (code to path).
+
+**Example:**
+
+```ts
+await dest(configRead)
+// Writes configRead.outputs[].code to configRead.outputs[].path
+```
+
+### `generate(configRead, options?)`
+
+Formats code for each output with Prettier.
+
+**Example:**
+
+```ts
+await generate(configRead)
+await generate(configRead, { printWidth: 100 })
+```
+
+### `original(configRead)`
+
+Fetches source: resolves uri/http/json from configRead.inputs and sets configRead.source. Transforms the source based on parser configuration (wpapi -> swagger2, swagger -> unchanged). Supports YAML source URLs (e.g. .yaml / .yml); uses confbox for parsing (same as undocs).
+
+**Example:**
+
+```ts
+await original(configRead)
+// configRead.source is set from uri/http/json; wpapi transformed to swagger2 if parser is 'wpapi'
+```
+
+### `formatTypescript(code, options?)`
+
+Formats TypeScript/JavaScript code string with Prettier.
+
+**Example:**
+
+```ts
+const formatted = await formatTypescript('const x=1')
+```
+
+<!-- /automd -->
+
+## License
+
+[MIT](https://github.com/hairyf/genapi/blob/main/LICENSE)
+
+<!-- automd:with-automd -->
+
+---
+
+_🤖 auto updated with [automd](https://automd.unjs.io)_
+
+<!-- /automd -->

package/dist/index.d.mts

@@ -2,55 +2,133 @@ import { ApiPipeline } from "@genapi/shared";
 
 //#region src/pipeline/index.d.ts
 /**
- * Pipeline read（input）function
+ * Pipeline read (input) step: turns raw config into internal config + inputs.
+ * @description First step: normalizes user config and builds ConfigRead (inputs, outputs, graphs).
  */
 type PipelineRead<Config, ConfigRead> = (config: Config) => ConfigRead | Promise<ConfigRead>;
 /**
- * Transfer data in pipeline
+ * Middle step that receives and returns config read; used for original, parser, compiler, generate.
+ * @description Each step may mutate configRead (e.g. set source, graphs, output.code).
  */
 type PipelineFlow<ConfigRead> = (configRead: ConfigRead) => ConfigRead | Promise<ConfigRead>;
 /**
- * Pipeline dest（output）function
+ * Pipeline dest (output) step: writes files from config read.
+ * @description Last step: writes configRead.outputs[].code to configRead.outputs[].path.
  */
-type PipelineDest<ConfigRead> = (configRead: ApiPipeline.ConfigRead) => void;
+type PipelineDest<ConfigRead> = (configRead: ApiPipeline.ConfigRead) => void | Promise<void>;
 /**
- * create genapi pipeline process
- * @param config read config pa
- * @param original get the source according to config
- * @param parser resolve source as available data
- * @param compiler compile parse info conversion AST tree
- * @param generate generate code
- * @param dest dest file
+ * Builds a GenAPI pipeline from five steps: config → original → parser → compiler → generate → dest.
+ *
+ * @param config - Reads config and returns ConfigRead
+ * @param original - Fetches source (e.g. OpenAPI JSON)
+ * @param parser - Parses source into graphs
+ * @param compiler - Compiles graphs to AST
+ * @param generate - Generates code string
+ * @param dest - Writes output files
+ * @returns A function that runs the pipeline for a given config
+ * @group Pipeline
+ * @example
+ * ```ts
+ * const run = pipeline(config, original, parser, compiler, generate, dest)
+ * await run(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+ * ```
  */
 declare function pipeline<Config = ApiPipeline.Config, ConfigRead = ApiPipeline.ConfigRead>(config: PipelineRead<Config, ConfigRead>, original: PipelineFlow<ConfigRead>, parser: PipelineFlow<ConfigRead>, compiler: PipelineFlow<ConfigRead>, generate: PipelineFlow<ConfigRead>, dest: PipelineDest<ConfigRead>): ApiPipeline.Pipeline;
 declare namespace pipeline {
-    var config: typeof config;
-    var original: typeof original;
-    var parser: typeof original;
-    var compiler: typeof compiler;
-    var generate: typeof generate;
-    var dest: typeof dest;
+  var config: typeof config;
+  var original: typeof original;
+  var parser: typeof original;
+  var compiler: typeof compiler;
+  var generate: typeof generate;
+  var dest: typeof dest;
 }
-
+//#endregion
+//#region src/compiler/scope.d.ts
+/**
+ * 统一编译：按 scope 从 graphs.scopes[scope] 生成一段完整 TS 代码（comments → imports → variables → functions → typings → interfaces）。
+ */
+declare function compile(configRead: ApiPipeline.ConfigRead, scope: string): string;
 //#endregion
 //#region src/compiler/index.d.ts
+/**
+ * Compiles each output from graphs.scopes[output.type]; onlyDeclaration 时仅编译 type 为 "type" 的 output。
+ *
+ * @param configRead - ConfigRead with graphs.scopes and outputs
+ * @returns Same configRead with output.code set
+ * @group Pipeline
+ */
 declare function compiler(configRead: ApiPipeline.ConfigRead): ApiPipeline.ConfigRead<ApiPipeline.Config>;
-
 //#endregion
 //#region src/config/index.d.ts
+/**
+ * Normalizes pipeline config: output paths, responseType, baseURL, and builds ConfigRead with inputs/outputs.
+ *
+ * @param userConfig - Raw config from defineConfig
+ * @returns ConfigRead (config + inputs + outputs)
+ * @group Pipeline
+ * @example
+ * ```ts
+ * const configRead = config(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+ * ```
+ */
 declare function config(userConfig: ApiPipeline.Config): ApiPipeline.ConfigRead<Required<ApiPipeline.Config>>;
-
 //#endregion
 //#region src/dest/index.d.ts
-declare function dest(configRead: ApiPipeline.ConfigRead): void;
-
+/**
+ * Writes output files from configRead.outputs (code to path).
+ *
+ * @param configRead - ConfigRead with outputs[].path and outputs[].code
+ * @group Pipeline
+ * @example
+ * ```ts
+ * await dest(configRead)
+ * // Writes configRead.outputs[].code to configRead.outputs[].path
+ * ```
+ */
+declare function dest(configRead: ApiPipeline.ConfigRead): Promise<void>;
 //#endregion
 //#region src/generate/index.d.ts
-declare function generate(configRead: ApiPipeline.ConfigRead): ApiPipeline.ConfigRead<ApiPipeline.Config>;
-
+/**
+ * Formats code for each output with Prettier.
+ *
+ * @param configRead - ConfigRead with outputs[].code
+ * @returns Same configRead with outputs[].code formatted
+ * @group Pipeline
+ * @example
+ * ```ts
+ * await generate(configRead)
+ * await generate(configRead, { printWidth: 100 })
+ * ```
+ */
+declare function generate(configRead: ApiPipeline.ConfigRead, options?: any): Promise<ApiPipeline.ConfigRead<ApiPipeline.Config>>;
+/**
+ * Formats TypeScript/JavaScript code string with Prettier.
+ *
+ * @param code - Source code to format
+ * @param options - Prettier options (merged with parser: 'typescript', printWidth: 800)
+ * @returns Formatted code string
+ * @example
+ * ```ts
+ * const formatted = await formatTypescript('const x=1')
+ * ```
+ */
+declare function formatTypescript(code: string, options?: any): Promise<string>;
 //#endregion
 //#region src/original/index.d.ts
+/**
+ * Fetches source: resolves uri/http/json from configRead.inputs and sets configRead.source.
+ * Transforms the source based on parser configuration (wpapi -> swagger2, swagger -> unchanged).
+ * Supports YAML source URLs (e.g. .yaml / .yml); uses confbox for parsing (same as undocs).
+ *
+ * @param configRead - ConfigRead with inputs (uri, http, or json)
+ * @returns Same configRead with source set and transformed if needed
+ * @group Pipeline
+ * @example
+ * ```ts
+ * await original(configRead)
+ * // configRead.source is set from uri/http/json; wpapi transformed to swagger2 if parser is 'wpapi'
+ * ```
+ */
 declare function original(configRead: ApiPipeline.ConfigRead): Promise<ApiPipeline.ConfigRead<ApiPipeline.Config>>;
-
 //#endregion
-export { PipelineDest, PipelineFlow, PipelineRead, compiler, config, pipeline as default, dest, generate, original };
+export { type PipelineDest, type PipelineFlow, type PipelineRead, compile, compiler, config, pipeline as default, dest, formatTypescript, generate, original };

package/dist/index.mjs

@@ -1,136 +1,211 @@
 import pPipe from "p-pipe";
-import { astNodeToCode, codeToAstNode, createComment, createFunction, createImport, createInterface, createTypeAlias, createVariable } from "ts-factory-extra";
-import { NodeFlags, factory } from "typescript";
+import { inject, provide } from "@genapi/shared";
+import { genComment, genFunction, genImport, genInterface, genTypeAlias, genVariable } from "knitwork-x";
 import path from "node:path";
 import process from "node:process";
-import { provide } from "@genapi/shared";
 import fs from "fs-extra";
 import { format } from "prettier";
-import got from "got";
+import { wpapiToSwagger2 } from "@genapi/transform";
+import { parseYAML } from "confbox";
+import { ofetch } from "ofetch";
 
-//#region src/compiler/typings.ts
-function compilerTsTypingsDeclaration(configRead, comment = true) {
-	configRead.graphs.comments = configRead.graphs.comments || [];
-	configRead.graphs.typings = configRead.graphs.typings || [];
-	configRead.graphs.interfaces = configRead.graphs.interfaces || [];
-	const typings = configRead.graphs.typings.map((item) => {
-		return createTypeAlias(item.export, item.name, item.value);
-	});
-	const interfaces = configRead.graphs.interfaces.map((item) => {
-		return createInterface({
-			export: item.export,
-			name: item.name,
-			properties: item.properties || []
-		});
+//#region src/compiler/scope.ts
+const RE_NAMESPACE = /^(Types\.|import\(['"][^'"]+['"]\)\.)/g;
+const RE_ARRAY_TYPE = /^(.+)\[\]$/;
+function generateMockTemplate(typeName, interfaceMap, visited = /* @__PURE__ */ new Set()) {
+	const cleanTypeName = typeName.replace(RE_NAMESPACE, "").trim();
+	const arrayMatch = cleanTypeName.match(RE_ARRAY_TYPE);
+	if (arrayMatch) return `[${generateMockTemplate(arrayMatch[1], interfaceMap, visited)}]`;
+	const primitiveMap = {
+		string: "'@string'",
+		number: "'@integer'",
+		boolean: "'@boolean'",
+		Date: "'@datetime'",
+		void: "null",
+		any: "'@string'"
+	};
+	if (primitiveMap[cleanTypeName]) return primitiveMap[cleanTypeName];
+	if (cleanTypeName.includes("|")) return "{}";
+	const interfaceDef = interfaceMap.get(cleanTypeName);
+	if (!interfaceDef?.properties || visited.has(cleanTypeName)) return "{}";
+	visited.add(cleanTypeName);
+	const properties = interfaceDef.properties.filter((prop) => prop.type).map((prop) => {
+		const propType = prop.type.replace(RE_NAMESPACE, "").trim();
+		const nextVisited = new Set(visited);
+		if (propType.endsWith("[]")) {
+			const itemTemplate = generateMockTemplate(propType.slice(0, -2), interfaceMap, nextVisited);
+			return `'${prop.name}|1-5': ${itemTemplate}`;
+		}
+		return `'${prop.name}': ${generateMockTemplate(propType, interfaceMap, nextVisited)}`;
 	});
-	const nodes = [
-		factory.createIdentifier(""),
-		...typings,
-		factory.createIdentifier(""),
-		...interfaces
-	];
-	if (comment) nodes.unshift(createComment("multi", configRead.graphs.comments));
-	return nodes;
+	visited.delete(cleanTypeName);
+	return properties.length > 0 ? `{\n    ${properties.join(",\n    ")}\n  }` : "{}";
 }
-
-//#endregion
-//#region src/compiler/request.ts
-const varFlags = {
-	let: NodeFlags.Let,
-	const: NodeFlags.Const,
-	var: NodeFlags.None
-};
-function compilerTsRequestDeclaration(configRead) {
-	configRead.graphs.imports = configRead.graphs.imports || [];
-	configRead.graphs.comments = configRead.graphs.comments || [];
-	configRead.graphs.variables = configRead.graphs.variables || [];
-	configRead.graphs.functions = configRead.graphs.functions || [];
-	const isGenerateType = configRead.outputs.some((v) => v.type === "typings");
-	const isTypescript = configRead.outputs.some((v) => v.type === "request" && v.path.endsWith(".ts"));
-	const comments = [createComment("multi", configRead.graphs.comments)];
-	const imports = configRead.graphs.imports?.map((item) => {
-		return createImport(item.name, item.names, item.value, item.namespace);
-	});
-	const variables = configRead.graphs.variables.map((item) => {
-		return createVariable(item.export, varFlags[item.flag], item.name, item.value);
-	});
-	const functions = configRead.graphs.functions.flatMap((item) => {
-		return createFunction({
+function genFunctionsWithMock(functions, interfaceMap, config) {
+	const functionBlocks = [];
+	for (const item of functions || []) {
+		functionBlocks.push(genFunction({
 			export: true,
-			comment: item.description,
 			name: item.name,
-			parameters: item.parameters,
-			body: item.body?.map(codeToAstNode),
+			parameters: (item.parameters || []).map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: !p.required
+			})),
+			body: item.body || [],
 			async: item.async,
 			returnType: item.returnType,
 			generics: item.generics,
-			generator: item.generator
-		});
-	});
-	const nodes = [
-		...comments,
-		factory.createIdentifier(""),
-		...imports,
-		factory.createIdentifier(""),
-		...variables,
-		factory.createIdentifier(""),
-		...functions
-	];
-	if (!isGenerateType && isTypescript) {
-		nodes.push(factory.createIdentifier(""));
-		nodes.push(factory.createIdentifier(""));
-		nodes.push(...compilerTsTypingsDeclaration(configRead, false));
+			jsdoc: item.description
+		}));
+		const responseType = inject(item.name)?.responseType;
+		if (config.meta?.mockjs && responseType && responseType !== "void" && responseType !== "any") {
+			const mockTemplate = generateMockTemplate(responseType, interfaceMap);
+			functionBlocks.push(`${item.name}.mock = () => Mock.mock(${mockTemplate});`);
+		}
 	}
-	return nodes;
+	return functionBlocks;
+}
+function emptySlice() {
+	return {
+		comments: [],
+		functions: [],
+		imports: [],
+		variables: [],
+		typings: [],
+		interfaces: []
+	};
+}
+function varFiledToRaw(name) {
+	if (name.length >= 2 && name.startsWith("'") && name.endsWith("'")) return name.slice(1, -1);
+	return name;
+}
+/**
+* 统一编译：按 scope 从 graphs.scopes[scope] 生成一段完整 TS 代码（comments → imports → variables → functions → typings → interfaces）。
+*/
+function compile(configRead, scope) {
+	const slice = configRead.graphs.scopes[scope] ?? emptySlice();
+	const { config } = configRead;
+	const sections = [];
+	if (slice.comments?.length) sections.push(genComment(slice.comments.join("\n"), { block: true }));
+	const importLines = (slice.imports || []).map((item) => {
+		const isType = !!item.type;
+		if (item.namespace) return genImport(item.value, {
+			name: "*",
+			as: item.name
+		}, { type: isType });
+		if (item.name && !item.names) return genImport(item.value, item.name, { type: isType });
+		const names = item.names || [];
+		const imports = item.name ? [{
+			name: "default",
+			as: item.name
+		}, ...names.map((n) => ({ name: n }))] : names;
+		return genImport(item.value, imports, { type: isType });
+	});
+	if (config.meta?.mockjs) importLines.push(genImport("better-mock", { name: "Mock" }));
+	if (importLines.length) sections.push(importLines.join("\n"));
+	const variables = (slice.variables || []).map((item) => genVariable(item.name, item.value ?? "", {
+		export: !!item.export,
+		kind: item.flag
+	}));
+	if (variables.length) sections.push(variables.join("\n"));
+	const interfaceMap = new Map((slice.interfaces || []).map((i) => [i.name, i]));
+	const functions = genFunctionsWithMock(slice.functions || [], interfaceMap, config);
+	if (functions.length) sections.push(functions.join("\n\n"));
+	const typings = (slice.typings || []).map((item) => genTypeAlias(item.name, item.value, { export: !!item.export }));
+	if (typings.length) sections.push(typings.join("\n"));
+	const interfaces = (slice.interfaces || []).map((item) => {
+		const properties = (item.properties || []).map((p) => ({
+			name: varFiledToRaw(p.name),
+			type: p.type ?? "any",
+			optional: !p.required,
+			jsdoc: p.description
+		}));
+		return genInterface(item.name, properties, { export: !!item.export });
+	});
+	if (interfaces.length) sections.push(interfaces.join("\n"));
+	return sections.filter(Boolean).join("\n\n");
 }
 
 //#endregion
 //#region src/compiler/index.ts
+/**
+* Compiles each output from graphs.scopes[output.type]; onlyDeclaration 时仅编译 type 为 "type" 的 output。
+*
+* @param configRead - ConfigRead with graphs.scopes and outputs
+* @returns Same configRead with output.code set
+* @group Pipeline
+*/
 function compiler(configRead) {
+	const onlyDeclaration = !!configRead.config.meta?.onlyDeclaration;
 	for (const output of configRead.outputs) {
-		if (output.type === "request" && !configRead.config.onlyDeclaration) output.ast = compilerTsRequestDeclaration(configRead);
-		if (output.type === "typings") output.ast = compilerTsTypingsDeclaration(configRead);
+		if (onlyDeclaration && output.type !== "type") continue;
+		output.code = compile(configRead, output.type);
 	}
 	return configRead;
 }
 
 //#endregion
 //#region src/config/index.ts
+/**
+* Normalizes pipeline config: output paths, responseType, baseURL, and builds ConfigRead with inputs/outputs.
+*
+* @param userConfig - Raw config from defineConfig
+* @returns ConfigRead (config + inputs + outputs)
+* @group Pipeline
+* @example
+* ```ts
+* const configRead = config(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+* ```
+*/
 function config(userConfig) {
-	userConfig.import = userConfig.import || {};
-	userConfig.responseType = userConfig.responseType || {};
+	userConfig.meta = userConfig.meta || {};
+	userConfig.meta.import = userConfig.meta.import || {};
+	userConfig.meta.responseType = userConfig.meta.responseType || {};
 	if (typeof userConfig.output === "string") userConfig.output = { main: userConfig.output };
 	userConfig.output = userConfig.output || {};
 	userConfig.output.main = userConfig.output.main || "src/api/index.ts";
-	if (typeof userConfig.baseURL === "string") userConfig.baseURL = userConfig.baseURL.endsWith("/\"") ? userConfig.baseURL = `${userConfig.baseURL.slice(0, userConfig.baseURL.length - 2)}"` : userConfig.baseURL;
+	if (typeof userConfig.meta.baseURL === "string") userConfig.meta.baseURL = userConfig.meta.baseURL.endsWith("/\"") ? userConfig.meta.baseURL = `${userConfig.meta.baseURL.slice(0, userConfig.meta.baseURL.length - 2)}"` : userConfig.meta.baseURL;
 	if (userConfig.output?.type !== false) userConfig.output.type = userConfig.output.type || userConfig.output.main.replace(/\.ts|\.js/g, ".type.ts");
-	if (typeof userConfig.responseType === "string") userConfig.responseType = { infer: userConfig.responseType };
+	if (typeof userConfig.meta.responseType === "string") userConfig.meta.responseType = { infer: userConfig.meta.responseType };
 	const userRoot = process.cwd();
 	const isTypescript = userConfig.output.main.endsWith(".ts");
 	const isGenerateType = userConfig.output?.type !== false;
-	const importTypePath = userConfig.import.type || getImportTypePath(userConfig.output.main, userConfig.output.type || "");
-	const imports = [isTypescript && isGenerateType && {
-		name: "Types",
-		value: importTypePath,
-		type: true,
-		namespace: true
-	}];
-	const outputs = [{
-		type: "request",
-		root: path.join(userRoot, path.dirname(userConfig.output.main)),
-		path: path.join(userRoot, userConfig.output.main)
-	}];
-	const typings = [!!userConfig.responseType.infer && {
-		export: true,
-		name: "Infer<T>",
-		value: userConfig.responseType.infer
-	}];
-	if (userConfig.output.type !== false) outputs.push({
-		type: "typings",
-		root: path.join(userRoot, path.dirname(userConfig.output.type)),
-		import: importTypePath,
-		path: path.join(userRoot, userConfig.output.type)
-	});
+	const importTypePath = userConfig.meta.import.type || getImportTypePath(userConfig.output.main, userConfig.output.type || "");
+	const outputs = [];
+	const scopes = {};
+	const outputKeys = [
+		"main",
+		...userConfig.output.type !== false ? ["type"] : [],
+		...objectOutputKeys(userConfig.output)
+	];
+	for (const key of outputKeys) {
+		const outPath = key === "main" ? userConfig.output.main : key === "type" ? userConfig.output.type : userConfig.output[key];
+		if (typeof outPath !== "string") continue;
+		outputs.push({
+			type: key,
+			root: path.join(userRoot, path.dirname(outPath)),
+			path: path.join(userRoot, outPath),
+			...key === "type" ? { import: importTypePath } : {}
+		});
+		scopes[key] = {
+			comments: [],
+			functions: [],
+			imports: key === "main" && isTypescript && isGenerateType ? [{
+				name: "Types",
+				value: importTypePath,
+				type: true,
+				namespace: true
+			}] : [],
+			variables: [],
+			typings: key === "type" && userConfig.meta.responseType?.infer ? [{
+				export: true,
+				name: "Infer<T>",
+				value: userConfig.meta.responseType.infer
+			}] : [],
+			interfaces: []
+		};
+	}
 	const inputs = {};
 	if (typeof userConfig.input === "string") inputs.uri = userConfig.input;
 	if (typeof userConfig.input === "object") Object.assign(inputs, userConfig.input);
@@ -139,23 +214,45 @@ function config(userConfig) {
 		inputs,
 		outputs,
 		graphs: {
-			imports: imports.filter(Boolean),
-			variables: [],
-			comments: [],
-			functions: [],
-			interfaces: [],
-			typings: typings.filter(Boolean),
-			response: userConfig.responseType
+			scopes,
+			response: userConfig.meta.responseType
 		}
 	};
 	provide({
 		config: userConfig,
-		configRead
+		configRead,
+		imports: block(configRead, "imports")
 	});
 	return configRead;
 }
-function prefix(path$1) {
-	return path$1.startsWith(".") ? path$1 : `./${path$1}`;
+function block(configRead, key) {
+	return {
+		add(scope, item) {
+			let slice = configRead.graphs.scopes[scope];
+			if (!slice) {
+				slice = {
+					comments: [],
+					functions: [],
+					imports: [],
+					variables: [],
+					typings: [],
+					interfaces: []
+				};
+				configRead.graphs.scopes[scope] = slice;
+			}
+			if (Array.isArray(slice[key])) slice[key].push(item);
+		},
+		values(scope) {
+			const slice = configRead.graphs.scopes[scope];
+			return slice && Array.isArray(slice[key]) ? slice[key] : [];
+		},
+		all() {
+			return Object.values(configRead.graphs.scopes).flatMap((s) => s[key] || []);
+		}
+	};
+}
+function prefix(path) {
+	return path.startsWith(".") ? path : `./${path}`;
 }
 function getImportTypePath(main, type) {
 	let importTypePath = path.dirname(main);
@@ -163,64 +260,148 @@ function getImportTypePath(main, type) {
 	importTypePath = prefix(importTypePath).replace(".ts", "");
 	return importTypePath;
 }
+/** 从 output 对象中取除 main/type 外的 key（如 api），且值为 string 的 */
+function objectOutputKeys(output) {
+	if (typeof output !== "object" || output == null) return [];
+	return Object.keys(output).filter((k) => k !== "main" && k !== "type" && typeof output[k] === "string");
+}
 
 //#endregion
 //#region src/dest/index.ts
-function dest(configRead) {
-	configRead.outputs.map(async (output) => {
+/**
+* Writes output files from configRead.outputs (code to path).
+*
+* @param configRead - ConfigRead with outputs[].path and outputs[].code
+* @group Pipeline
+* @example
+* ```ts
+* await dest(configRead)
+* // Writes configRead.outputs[].code to configRead.outputs[].path
+* ```
+*/
+async function dest(configRead) {
+	await Promise.all(configRead.outputs.map(async (output) => {
 		await fs.ensureDir(output.root);
 		await fs.writeFile(output.path, output.code || "", { flag: "w" });
-	});
+	}));
 }
 
 //#endregion
 //#region src/generate/index.ts
-function generate(configRead) {
-	for (const output of configRead.outputs || []) {
-		if (output.ast) output.code = astNodeToCode(output.ast);
-		if (output.code) output.code = formatTypescript(output.code);
-	}
+/**
+* Formats code for each output with Prettier.
+*
+* @param configRead - ConfigRead with outputs[].code
+* @returns Same configRead with outputs[].code formatted
+* @group Pipeline
+* @example
+* ```ts
+* await generate(configRead)
+* await generate(configRead, { printWidth: 100 })
+* ```
+*/
+async function generate(configRead, options) {
+	for (const output of configRead.outputs || []) if (output.code) output.code = await formatTypescript(output.code, options);
 	return configRead;
 }
-function formatTypescript(code) {
-	return format(code, {
+/**
+* Formats TypeScript/JavaScript code string with Prettier.
+*
+* @param code - Source code to format
+* @param options - Prettier options (merged with parser: 'typescript', printWidth: 800)
+* @returns Formatted code string
+* @example
+* ```ts
+* const formatted = await formatTypescript('const x=1')
+* ```
+*/
+async function formatTypescript(code, options) {
+	return await format(code, {
 		printWidth: 800,
+		...options,
 		parser: "typescript"
 	});
 }
 
 //#endregion
 //#region src/original/index.ts
+function isYamlUrl(url) {
+	try {
+		const pathname = new URL(url).pathname;
+		return pathname.endsWith(".yaml") || pathname.endsWith(".yml");
+	} catch {
+		return false;
+	}
+}
+async function fetchSource(url, options) {
+	if (isYamlUrl(url)) return parseYAML(await ofetch(url, {
+		...options,
+		responseType: "text"
+	}));
+	if (options && Object.keys(options).length > 0) return await ofetch(url, options);
+	return await ofetch(url);
+}
+/**
+* Fetches source: resolves uri/http/json from configRead.inputs and sets configRead.source.
+* Transforms the source based on parser configuration (wpapi -> swagger2, swagger -> unchanged).
+* Supports YAML source URLs (e.g. .yaml / .yml); uses confbox for parsing (same as undocs).
+*
+* @param configRead - ConfigRead with inputs (uri, http, or json)
+* @returns Same configRead with source set and transformed if needed
+* @group Pipeline
+* @example
+* ```ts
+* await original(configRead)
+* // configRead.source is set from uri/http/json; wpapi transformed to swagger2 if parser is 'wpapi'
+* ```
+*/
 async function original(configRead) {
-	if (configRead.inputs.uri) configRead.source = await got({
-		url: configRead.inputs.uri,
-		responseType: "json"
-	}).json();
-	if (configRead.inputs.http) configRead.source = await got({
-		...configRead.inputs.http,
-		responseType: "json"
-	}).json();
+	if (configRead.inputs.uri) configRead.source = await fetchSource(configRead.inputs.uri);
+	if (configRead.inputs.http) {
+		const { url, ...options } = configRead.inputs.http;
+		configRead.source = await fetchSource(url || configRead.inputs.uri || "", options);
+	}
 	if (configRead.inputs.json) configRead.source = await readJsonSource(configRead.inputs.json);
 	if (!configRead.source) throw new Error("No source found, please check your input config.");
+	if ((configRead.config.parser || "swagger") === "wpapi") configRead.source = wpapiToSwagger2(configRead.source);
 	if (!configRead.source.schemes?.length) {
+		const effectiveUrl = configRead.inputs.http?.url || configRead.inputs.uri || "";
 		const schemes = [];
-		if (configRead.inputs.uri?.startsWith("https://")) schemes.push("https", "http");
-		if (configRead.inputs.uri?.startsWith("http://")) schemes.push("http");
-		configRead.source.schemes = schemes;
+		if (effectiveUrl.startsWith("https://")) schemes.push("https", "http");
+		if (effectiveUrl.startsWith("http://")) schemes.push("http");
+		if (schemes.length > 0) configRead.source.schemes = schemes;
 	}
 	return configRead;
 }
 function readJsonSource(json) {
-	if (!json) return;
-	if (typeof json === "object") return json;
-	else return import(json).then((mod) => mod.default);
+	if (!json) return Promise.resolve(void 0);
+	if (typeof json === "object") return Promise.resolve(json);
+	const trimmed = String(json).trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return Promise.resolve(JSON.parse(json));
+	return import(json).then((mod) => mod.default);
 }
 
 //#endregion
 //#region src/pipeline/index.ts
-function pipeline(config$1, original$1, parser, compiler$1, generate$1, dest$1) {
-	const pipe = pPipe(config$1, original$1, parser, compiler$1, generate$1, dest$1);
-	return pipe;
+/**
+* Builds a GenAPI pipeline from five steps: config → original → parser → compiler → generate → dest.
+*
+* @param config - Reads config and returns ConfigRead
+* @param original - Fetches source (e.g. OpenAPI JSON)
+* @param parser - Parses source into graphs
+* @param compiler - Compiles graphs to AST
+* @param generate - Generates code string
+* @param dest - Writes output files
+* @returns A function that runs the pipeline for a given config
+* @group Pipeline
+* @example
+* ```ts
+* const run = pipeline(config, original, parser, compiler, generate, dest)
+* await run(defineConfig({ input: 'openapi.json', output: { main: 'src/api.ts' } }))
+* ```
+*/
+function pipeline(config, original, parser, compiler, generate, dest) {
+	return pPipe(config, original, parser, compiler, generate, dest);
 }
 pipeline.config = config;
 pipeline.original = original;
@@ -234,4 +415,4 @@ pipeline.dest = dest;
 var src_default = pipeline;
 
 //#endregion
-export { compiler, config, src_default as default, dest, generate, original };
+export { compile, compiler, config, src_default as default, dest, formatTypescript, generate, original };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genapi/pipeline",
   "type": "module",
-  "version": "3.7.1",
+  "version": "4.1.0",
   "author": "Hairyf <wwu710632@gmail.com>",
   "license": "MIT",
   "homepage": "https://github.com/hairyf/genapi#readme",
@@ -15,29 +15,32 @@
     "shared"
   ],
   "sideEffects": false,
-  "main": "./dist/index.mjs",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "fs-extra": "^11.1.0",
-    "got": "11.8.6",
-    "p-pipe": "^3",
-    "prettier": "^2.8.4",
-    "ts-factory-extra": "^0.0.5",
-    "typescript": "^5.0.0",
-    "@genapi/shared": "3.7.1"
+    "confbox": "^0.2.4",
+    "fs-extra": "^11.3.3",
+    "knitwork-x": "^0.3.1",
+    "ofetch": "^1.5.1",
+    "p-pipe": "^4.0.0",
+    "prettier": "^3.8.1",
+    "@genapi/shared": "4.1.0",
+    "@genapi/transform": "4.1.0"
   },
   "devDependencies": {
-    "@types/fs-extra": "^11.0.1"
+    "@types/fs-extra": "^11.0.4",
+    "@types/prettier": "^2.7.3"
   },
   "scripts": {
     "build": "tsdown",
-    "start": "tsx src/index.ts"
-  },
-  "exports": {
-    ".": "./dist/index.mjs"
-  },
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts"
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "automd": "automd"
+  }
 }