@genapi/pipeline 3.7.1 → 4.0.0

package/README.md

@@ -0,0 +1,60 @@
+# @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 AST: request code and typings for each output.
+
+### `config(userConfig)`
+
+Normalizes pipeline config: output paths, responseType, baseURL (from meta), and builds ConfigRead with inputs/outputs.
+
+### `default(config, original, parser, compiler, generate, dest)`
+
+Builds a GenAPI pipeline from five steps: config → original → parser → compiler → generate → dest.
+
+### `dest(configRead)`
+
+Writes output files from configRead.outputs (code to path).
+
+### `generate(configRead)`
+
+Generates code string from AST for each output and formats with Prettier.
+
+### `original(configRead)`
+
+Fetches source: resolves uri/http/json from configRead.inputs and sets configRead.source.
+
+<!-- /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,98 @@ 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.
  */
 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.
  */
 type PipelineFlow<ConfigRead> = (configRead: ConfigRead) => ConfigRead | Promise<ConfigRead>;
 /**
- * Pipeline dest（output）function
+ * Pipeline dest (output) step: writes files from config read.
  */
-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
  */
 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/request.d.ts
+declare function compilerTsRequestDeclaration(configRead: ApiPipeline.ConfigRead): string;
+//#endregion
+//#region src/compiler/typings.d.ts
+/**
+ * Compiles configRead graphs to typings code string using knitwork-x.
+ */
+declare function compilerTsTypingsDeclaration(configRead: ApiPipeline.ConfigRead, comment?: boolean): string;
 //#endregion
 //#region src/compiler/index.d.ts
+/**
+ * Compiles graphs to code string: request and typings for each output.
+ *
+ * @param configRead - ConfigRead with graphs 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
+ */
 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
+ */
+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
+ */
+declare function generate(configRead: ApiPipeline.ConfigRead, options?: any): Promise<ApiPipeline.ConfigRead<ApiPipeline.Config>>;
+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
+ */
 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, compiler, compilerTsRequestDeclaration, compilerTsTypingsDeclaration, config, pipeline as default, dest, formatTypescript, generate, original };

package/dist/index.mjs

@@ -1,114 +1,177 @@
 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
+/**
+* Compiles configRead graphs to typings code string using knitwork-x.
+*/
 function compilerTsTypingsDeclaration(configRead, comment = true) {
 	configRead.graphs.comments = configRead.graphs.comments || [];
 	configRead.graphs.typings = configRead.graphs.typings || [];
 	configRead.graphs.interfaces = configRead.graphs.interfaces || [];
+	const sections = [];
+	if (comment && configRead.graphs.comments.length > 0) sections.push(genComment(configRead.graphs.comments.join("\n"), { block: true }));
 	const typings = configRead.graphs.typings.map((item) => {
-		return createTypeAlias(item.export, item.name, item.value);
+		return genTypeAlias(item.name, item.value, { export: !!item.export });
 	});
+	if (typings.length > 0) sections.push(typings.join("\n"));
 	const interfaces = configRead.graphs.interfaces.map((item) => {
-		return createInterface({
-			export: item.export,
-			name: item.name,
-			properties: item.properties || []
-		});
+		const properties = (item.properties || []).map((p) => ({
+			name: p.name,
+			type: p.type ?? "any",
+			optional: !p.required,
+			jsdoc: p.description
+		}));
+		return genInterface(item.name, properties, { export: !!item.export });
 	});
-	const nodes = [
-		factory.createIdentifier(""),
-		...typings,
-		factory.createIdentifier(""),
-		...interfaces
-	];
-	if (comment) nodes.unshift(createComment("multi", configRead.graphs.comments));
-	return nodes;
+	if (interfaces.length > 0) sections.push(interfaces.join("\n"));
+	return sections.filter(Boolean).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 { graphs, config, outputs } = configRead;
+	const sections = [];
+	const interfaceMap = new Map((graphs.interfaces || []).map((i) => [i.name, i]));
+	if (graphs.comments?.length) sections.push(genComment(graphs.comments.join("\n"), { block: true }));
+	const importLines = (graphs.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 });
 	});
-	const variables = configRead.graphs.variables.map((item) => {
-		return createVariable(item.export, varFlags[item.flag], item.name, item.value);
+	if (config.meta?.mockjs) importLines.push(genImport("better-mock", { name: "Mock" }));
+	if (importLines.length) sections.push(importLines.join("\n"));
+	const variables = (graphs.variables || []).map((item) => genVariable(item.name, item.value ?? "", {
+		export: !!item.export,
+		kind: item.flag
+	}));
+	if (variables.length) sections.push(variables.join("\n"));
+	const functions = genFunctionsWithMock(graphs.functions || [], interfaceMap, config);
+	if (functions.length) sections.push(functions.join("\n\n"));
+	const isGenerateType = outputs.some((v) => v.type === "typings");
+	const isTsRequest = outputs.some((v) => v.type === "request" && v.path.endsWith(".ts"));
+	if (!isGenerateType && isTsRequest) sections.push(compilerTsTypingsDeclaration(configRead, false));
+	return sections.filter(Boolean).join("\n\n");
+}
+const RE_NAMESPACE = /^(Types\.|import\(['"][^'"]+['"]\)\.)/g;
+const RE_ARRAY_TYPE = /^(.+)\[\]$/;
+/**
+* 优化后的 Mock 模板生成函数
+*/
+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}`;
+		}
+		const innerTemplate = generateMockTemplate(propType, interfaceMap, nextVisited);
+		return `'${prop.name}': ${innerTemplate}`;
 	});
-	const functions = configRead.graphs.functions.flatMap((item) => {
-		return createFunction({
+	visited.delete(cleanTypeName);
+	return properties.length > 0 ? `{\n    ${properties.join(",\n    ")}\n  }` : "{}";
+}
+function genFunctionsWithMock(functions, interfaceMap, config) {
+	const functionBlocks = [];
+	(functions || []).forEach((item) => {
+		const functionCode = 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
+			jsdoc: item.description
 		});
+		functionBlocks.push(functionCode);
+		const responseType = inject(item.name)?.responseType;
+		if (!config.meta?.mockjs || !responseType || responseType === "void" || responseType === "any") return;
+		const mockTemplate = generateMockTemplate(responseType, interfaceMap);
+		functionBlocks.push(`${item.name}.mock = () => Mock.mock(${mockTemplate});`);
 	});
-	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));
-	}
-	return nodes;
+	return functionBlocks;
 }
 
 //#endregion
 //#region src/compiler/index.ts
+/**
+* Compiles graphs to code string: request and typings for each output.
+*
+* @param configRead - ConfigRead with graphs and outputs
+* @returns Same configRead with output.code set
+* @group Pipeline
+*/
 function compiler(configRead) {
 	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 (output.type === "request" && !configRead.config.meta?.onlyDeclaration) output.code = compilerTsRequestDeclaration(configRead);
+		if (output.type === "typings") output.code = compilerTsTypingsDeclaration(configRead);
 	}
 	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
+*/
 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 importTypePath = userConfig.meta.import.type || getImportTypePath(userConfig.output.main, userConfig.output.type || "");
 	const imports = [isTypescript && isGenerateType && {
 		name: "Types",
 		value: importTypePath,
@@ -120,10 +183,10 @@ function config(userConfig) {
 		root: path.join(userRoot, path.dirname(userConfig.output.main)),
 		path: path.join(userRoot, userConfig.output.main)
 	}];
-	const typings = [!!userConfig.responseType.infer && {
+	const typings = [!!userConfig.meta.responseType?.infer && {
 		export: true,
 		name: "Infer<T>",
-		value: userConfig.responseType.infer
+		value: userConfig.meta.responseType.infer
 	}];
 	if (userConfig.output.type !== false) outputs.push({
 		type: "typings",
@@ -145,7 +208,7 @@ function config(userConfig) {
 			functions: [],
 			interfaces: [],
 			typings: typings.filter(Boolean),
-			response: userConfig.responseType
+			response: userConfig.meta.responseType
 		}
 	};
 	provide({
@@ -154,8 +217,8 @@ function config(userConfig) {
 	});
 	return configRead;
 }
-function prefix(path$1) {
-	return path$1.startsWith(".") ? path$1 : `./${path$1}`;
+function prefix(path) {
+	return path.startsWith(".") ? path : `./${path}`;
 }
 function getImportTypePath(main, type) {
 	let importTypePath = path.dirname(main);
@@ -166,61 +229,109 @@ function getImportTypePath(main, type) {
 
 //#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
+*/
+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
+*/
+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, {
+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
+*/
 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
+*/
+function pipeline(config, original, parser, compiler, generate, dest) {
+	return pPipe(config, original, parser, compiler, generate, dest);
 }
 pipeline.config = config;
 pipeline.original = original;
@@ -234,4 +345,4 @@ pipeline.dest = dest;
 var src_default = pipeline;
 
 //#endregion
-export { compiler, config, src_default as default, dest, generate, original };
+export { compiler, compilerTsRequestDeclaration, compilerTsTypingsDeclaration, 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.0.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.2.0",
+    "ofetch": "^1.5.1",
+    "p-pipe": "^4.0.0",
+    "prettier": "^3.8.1",
+    "@genapi/shared": "4.0.0",
+    "@genapi/transform": "4.0.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"
+  }
 }