@povio/openapi-codegen-cli 3.2.0-rc.8 → 3.3.0-rc.1

package/README.md

@@ -89,8 +89,7 @@ bunx openapi-codegen generate --config my-config.ts
   --modelsInCommon                    Keep all schema declarations in defaultTag models and emit per-module proxy exports (default: false)
   --replaceOptionalWithNullish        Replace `.optional()` chains with `.nullish()` in generated Zod schemas (default: false)
 
-  --restClient                        REST transport to generate: 'axios' or 'native' (default: 'axios')
-  --axiosRequestConfig                Include transport request config parameters in query hooks (default: false)
+  --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)
   --infiniteQueries                   Generate infinite queries for paginated API endpoints (default: false)
   --mutationEffects                   Add mutation effects options to mutation hooks (default: true)
   --mutationScope                     Serialize mutations for the same path-param resource via TanStack scope.id (default: false).
@@ -139,7 +138,7 @@ bun install
 # run tests
 bun run test
 
-# run TypeScript sources directly with Bun
+# run sources with tsx
 bun run start --help
 bun run start generate --input ./test/petstore.yaml --verbose
 
@@ -151,58 +150,10 @@ bun run start --help
 bun run start:dist generate --input ./test/petstore.yaml --verbose
 ```
 
-### Native Bun code generation
-
-The Bun and Node.js CLIs and the Vite plugin automatically use the bundled Rust code-generation core when a compatible native binary is available. Generated files remain byte-for-byte compatible with the TypeScript implementation, which is retained as the fallback when the addon cannot be loaded.
-
-Set `OPENAPI_CODEGEN_NATIVE=0` to force the TypeScript path, or `OPENAPI_CODEGEN_NATIVE=1` to require the native path and fail when its binary is unavailable.
-
-Release packages include native binaries for Linux x64, macOS arm64, and Windows x64. Build a binary for the current platform with `bun run build:native`.
-
 ## Common Issues
 
 ### App REST Client Interceptors
 
-Select the fetch-based client without changing endpoint and query APIs:
-
-```ts
-import type { OpenAPICodegenConfig } from "@povio/openapi-codegen-cli";
-
-export default {
-  restClient: "native",
-} satisfies OpenAPICodegenConfig;
-```
-
-Native mode imports common request/response contracts from `@povio/openapi-codegen-cli/rest` and the concrete
-`NativeRestClient` from `@povio/openapi-codegen-cli/native`. It uses `fetch` for normal requests and uploads, switching
-to `XMLHttpRequest` in browsers only when an upload progress callback is provided.
-
-Native interceptors use the common transport interface:
-
-```ts
-import { NativeRestClient } from "@povio/openapi-codegen-cli/native";
-import type { RestTransportInterceptor } from "@povio/openapi-codegen-cli/rest";
-
-const authorizationInterceptor: RestTransportInterceptor = {
-  onRequest(request) {
-    request.headers.set("Authorization", `Bearer ${localStorage.getItem("accessToken")}`);
-    return request;
-  },
-};
-
-export const AppRestClient = new NativeRestClient({
-  config: { baseURL: "https://api.example.com" },
-  interceptors: [authorizationInterceptor],
-});
-```
-
-Axios remains the default for backward compatibility. The existing Axios interceptor API remains available in Axios
-mode.
-
-Native mode does not run the library `ErrorHandler` or create `ApplicationException` values. It throws `HttpError` for
-non-success HTTP responses and preserves Zod, network, cancellation, and timeout errors so applications can handle them
-directly in query callbacks, error boundaries, or their own normalization layer.
-
 In order to add interceptors to the used REST client, you must create your own instance of a RestClient and pass your implemented interceptors into the constructor. Make sure to set `restClientImportPath` in your openapi generation configuration too.
 
 ```ts

package/dist/acl.d.mts

@@ -1,21 +1,25 @@
-import { a as ErrorHandler } from "./error-handling-CNOHs4Fc.mjs";
+import { a as ErrorHandler } from "./error-handling-D6ZYITQ3.mjs";
+import * as _$react from "react";
 import { PropsWithChildren } from "react";
 import { AbilityTuple, PureAbility, RawRuleOf, Subject } from "@casl/ability";
 import { PackRule } from "@casl/ability/extra";
 import { BoundCanProps } from "@casl/react";
+
 //#region src/lib/acl/appAbility.types.d.ts
 type AppAbilities = AbilityTuple<string, Subject>;
 type AppAbility = PureAbility<AppAbilities>;
 //#endregion
 //#region src/lib/acl/ability.context.d.ts
 declare namespace AbilityContext {
-  export const Consumer: import("react").Consumer<AppAbility>;
+  export const Consumer: _$react.Consumer<AppAbility>;
   interface ProviderProps {
     user?: {
       aclRules?: PackRule<RawRuleOf<AppAbility>>[];
     } | null;
   }
-  export const Provider: ({ children }: PropsWithChildren<ProviderProps>) => import("react").JSX.Element;
+  export const Provider: ({
+    children
+  }: PropsWithChildren<ProviderProps>) => _$react.JSX.Element;
   export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
   export {};
 }
@@ -25,20 +29,29 @@ interface AclGuardProps<TAppAbilities extends AppAbilities = AppAbilities> {
   canUse: TAppAbilities;
   redirectTo?: string;
 }
-declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({ canUse, redirectTo, children }: PropsWithChildren<AclGuardProps<TAppAbilities>>) => import("react").ReactNode;
+declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({
+  canUse,
+  redirectTo,
+  children
+}: PropsWithChildren<AclGuardProps<TAppAbilities>>) => _$react.ReactNode;
 //#endregion
 //#region src/lib/acl/Can.d.ts
 type CanAbility = PureAbility<AbilityTuple<AppAbilities[0], AppAbilities[1]>>;
 type CanProps<TAppAbilities extends AppAbilities = AppAbilities> = {
   use: TAppAbilities;
 } & Omit<BoundCanProps<CanAbility>, "do" | "I" | "on" | "a" | "an" | "this">;
-declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({ use, ...props }: CanProps<TAppAbilities>) => import("react").JSX.Element;
+declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({
+  use,
+  ...props
+}: CanProps<TAppAbilities>) => _$react.JSX.Element;
 //#endregion
 //#region src/lib/acl/useAclCheck.d.ts
 interface UseAclCheckProps {
   errorHandler?: ErrorHandler<never>;
 }
-declare function useAclCheck<TAppAbilities extends AppAbilities = AppAbilities>({ errorHandler }?: UseAclCheckProps): {
+declare function useAclCheck<TAppAbilities extends AppAbilities = AppAbilities>({
+  errorHandler
+}?: UseAclCheckProps): {
   checkAcl: (appAbility: TAppAbilities) => void;
 };
 //#endregion

package/dist/acl.mjs

@@ -1,6 +1,6 @@
-import { i as SharedErrorHandler } from "./error-handling-BMXC5P08.mjs";
-import { n as OpenApiRouter, t as AuthContext } from "./auth.context-YFWzkwoN.mjs";
-import { createContext, useCallback, useMemo } from "react";
+import { i as SharedErrorHandler } from "./error-handling-CsnufAil.mjs";
+import { n as OpenApiRouter, t as AuthContext } from "./auth.context-BAz8frX9.mjs";
+import { createContext, useCallback, useEffect, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 import { AbilityBuilder, createMongoAbility } from "@casl/ability";
 import { unpackRules } from "@casl/ability/extra";
@@ -14,15 +14,16 @@ let AbilityContext;
 	const { Consumer } = Context;
 	_AbilityContext.Consumer = Consumer;
 	_AbilityContext.Provider = ({ children }) => {
+		const [ability, setAbility] = useState(initialAppAbility);
 		const { user } = AuthContext.useAuth();
-		const ability = useMemo(() => {
-			if (!user || !("aclRules" in user)) return initialAppAbility;
+		useEffect(() => {
+			if (!user || !("aclRules" in user)) return;
 			const { can, build } = createAppAbilityBuilder();
 			const packedRules = user.aclRules;
 			unpackRules(packedRules).forEach(({ action, subject, conditions }) => {
 				can(action, subject, conditions);
 			});
-			return build();
+			setAbility(build());
 		}, [user]);
 		return /* @__PURE__ */ jsx(Context.Provider, {
 			value: ability,

package/dist/{auth.context-YFWzkwoN.mjs → auth.context-BAz8frX9.mjs}

@@ -5,9 +5,8 @@ let OpenApiRouter;
 (function(_OpenApiRouter) {
 	const Context = createContext(null);
 	_OpenApiRouter.Provider = ({ children, replace }) => {
-		const value = useMemo(() => ({ replace }), [replace]);
 		return /* @__PURE__ */ jsx(Context, {
-			value,
+			value: useMemo(() => ({ replace }), [replace]),
 			children
 		});
 	};

package/dist/{config-DgrOddSC.d.mts → config-BQqze8rU.d.mts}

@@ -1,4 +1,5 @@
-import { t as GenerateOptions } from "./options-KPf-Fti5.mjs";
+import { t as GenerateOptions } from "./options-DdQJ9BSc.mjs";
+
 //#region src/generators/types/config.d.ts
 type OpenAPICodegenConfig = Partial<GenerateOptions>;
 //#endregion

package/dist/{error-handling-BMXC5P08.mjs → error-handling-CsnufAil.mjs}

@@ -1,4 +1,4 @@
-import { t as HttpError } from "./rest-transport.types-DxitRtsB.mjs";
+import { isAxiosError, isCancel } from "axios";
 import { z } from "zod";
 //#region src/lib/assets/locales/en/translation.json
 var translation_default$1 = { openapi: { "sharedErrors": {
@@ -35,26 +35,14 @@ function resolveT() {
 	return getT();
 }
 //#endregion
-//#region src/lib/rest/http-error.utils.ts
-function isAxiosErrorLike(error) {
-	return typeof error === "object" && error !== null && "isAxiosError" in error;
-}
-function isCanceledRequest(error) {
-	if (error instanceof DOMException && ["AbortError", "TimeoutError"].includes(error.name)) return true;
-	if (isAxiosErrorLike(error)) return error.code === "ERR_CANCELED" || error.code === "ECONNABORTED";
-	return false;
-}
-//#endregion
 //#region src/lib/rest/rest.utils.ts
-function getResponseData(error) {
-	if (error instanceof HttpError) return error.response.data;
-	return isAxiosErrorLike(error) ? error.response?.data : void 0;
-}
 let RestUtils;
 (function(_RestUtils) {
 	_RestUtils.extractServerResponseCode = (e) => {
 		if (e instanceof z.ZodError) return "validation-exception";
-		const data = getResponseData(e);
+		if (!isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
 		if (typeof data?.code === "string") return data.code;
 		if (typeof data?.code === "number") return data.code;
 		return null;
@@ -66,7 +54,9 @@ let RestUtils;
 	};
 	const extractServerErrorMessage = _RestUtils.extractServerErrorMessage = (e) => {
 		if (e instanceof z.ZodError) return e.message;
-		const data = getResponseData(e);
+		if (!isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
 		if (typeof data?.message === "string") return data.message;
 		return null;
 	};
@@ -119,8 +109,7 @@ var ErrorHandler = class ErrorHandler {
 		const internalError = {
 			code: "INTERNAL_ERROR",
 			condition: (e) => {
-				if (isAxiosErrorLike(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
-				if (e instanceof HttpError) return e.response.status >= 500 && e.response.status < 600;
+				if (isAxiosError(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
 				return false;
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.internalError", { ns })
@@ -128,8 +117,7 @@ var ErrorHandler = class ErrorHandler {
 		const networkError = {
 			code: "NETWORK_ERROR",
 			condition: (e) => {
-				if (isAxiosErrorLike(e)) return e.code === "ERR_NETWORK";
-				if (e instanceof TypeError) return true;
+				if (isAxiosError(e)) return e.code === "ERR_NETWORK";
 				return false;
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.networkError", { ns })
@@ -137,7 +125,9 @@ var ErrorHandler = class ErrorHandler {
 		const canceledError = {
 			code: "CANCELED_ERROR",
 			condition: (e) => {
-				return isCanceledRequest(e);
+				if (isCancel(e)) return true;
+				if (isAxiosError(e) && e.code === "ECONNABORTED") return true;
+				return false;
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.canceledError", { ns })
 		};

package/dist/{error-handling-CNOHs4Fc.d.mts → error-handling-D6ZYITQ3.d.mts}

@@ -69,7 +69,10 @@ declare class ErrorHandler<CodeT extends string | number> {
   private readonly userEntries;
   private readonly generalEntries;
   private onRethrowError?;
-  constructor({ entries, onRethrowError }: ErrorHandlerOptions<CodeT>);
+  constructor({
+    entries,
+    onRethrowError
+  }: ErrorHandlerOptions<CodeT>);
   private matchesEntry;
   /** Lazy so resolveT() only runs when getMessage actually uses `t`. */
   private static lazyT;

package/dist/generate.runner-BeCGJ1ar.mjs

@@ -0,0 +1,87 @@
+import { h as deepMerge, i as writeGenerateFileData, p as DEFAULT_GENERATE_OPTIONS, r as removeStaleGeneratedFiles, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-KQT4kYxY.mjs";
+import path from "path";
+import SwaggerParser from "@apidevtools/swagger-parser";
+//#region src/generators/core/resolveConfig.ts
+function resolveConfig({ fileConfig = {}, params: { includeTags, excludeTags, inlineEndpointsExcludeModules, workspaceContext, ...options } }) {
+	const resolvedConfig = deepMerge(DEFAULT_GENERATE_OPTIONS, fileConfig ?? {}, {
+		...options,
+		includeTags: includeTags?.split(","),
+		excludeTags: excludeTags?.split(","),
+		inlineEndpointsExcludeModules: inlineEndpointsExcludeModules?.split(","),
+		workspaceContext: workspaceContext?.split(",")
+	});
+	resolvedConfig.checkAcl = resolvedConfig.acl && resolvedConfig.checkAcl;
+	resolvedConfig.workspaceContext = Array.from(new Set((resolvedConfig.workspaceContext ?? []).map((value) => value.trim()).filter(Boolean)));
+	return resolvedConfig;
+}
+//#endregion
+//#region src/generators/run/generate.runner.ts
+async function runGenerate({ fileConfig, params, formatGeneratedFile, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
+	const config = profiler.runSync("config.resolve", () => resolveConfig({
+		fileConfig,
+		params: params ?? {}
+	}));
+	const openApiDoc = await getOpenApiDoc(config.input, profiler);
+	const filesData = profiler.runSync("generate.total", () => generateCodeFromOpenAPIDoc(openApiDoc, config, profiler));
+	if (config.clearOutput) profiler.runSync("files.removeStaleGenerated", () => {
+		removeStaleGeneratedFiles({
+			output: config.output,
+			filesData,
+			options: config
+		});
+	});
+	await profiler.runAsync("files.write", async () => {
+		await writeGenerateFileData(filesData, { formatGeneratedFile });
+	});
+	return {
+		skipped: false,
+		config,
+		stats: getGenerateStats(filesData, config)
+	};
+}
+async function getOpenApiDoc(input, profiler) {
+	const parsedDoc = await profiler.runAsync("openapi.parse", async () => await SwaggerParser.parse(input));
+	if (!profiler.runSync("openapi.detectExternalRefs", () => hasExternalRef(parsedDoc))) return parsedDoc;
+	return await profiler.runAsync("openapi.bundle", async () => await SwaggerParser.bundle(input));
+}
+function hasExternalRef(value) {
+	const stack = [value];
+	const visited = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || typeof current !== "object") continue;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		if ("$ref" in current && typeof current.$ref === "string" && !current.$ref.startsWith("#/")) return true;
+		for (const nested of Object.values(current)) if (nested && typeof nested === "object") stack.push(nested);
+	}
+	return false;
+}
+function getGenerateStats(filesData, config) {
+	const generatedFilesCount = filesData.length;
+	if (generatedFilesCount === 0) return {
+		generatedFilesCount,
+		generatedModulesCount: 0
+	};
+	if (!config.splitByTags) return {
+		generatedFilesCount,
+		generatedModulesCount: 1
+	};
+	const moduleSuffixes = new Set(Object.values(config.configs).map((generateConfig) => generateConfig.outputFileNameSuffix).filter(Boolean));
+	const modules = /* @__PURE__ */ new Set();
+	for (const file of filesData) {
+		const segments = path.relative(config.output, file.fileName).split(path.sep).filter(Boolean);
+		if (segments.length < 2) continue;
+		const moduleName = segments[0];
+		const fileName = segments[segments.length - 1];
+		if (!fileName.startsWith(`${moduleName}.`)) continue;
+		const suffix = fileName.slice(moduleName.length + 1).replace(/\.tsx?$/, "");
+		if (moduleSuffixes.has(suffix)) modules.add(moduleName);
+	}
+	return {
+		generatedFilesCount,
+		generatedModulesCount: modules.size
+	};
+}
+//#endregion
+export { resolveConfig as n, runGenerate as t };