@povio/openapi-codegen-cli 3.2.0-rc.9 → 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-LPEPQV1V.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,7 +1,6 @@
-import { i as SharedErrorHandler } from "./error-handling-BeydPL7s.mjs";
-import { t as OpenApiRouter } from "./router.context-EPlMBk3G.mjs";
-import { t as AuthContext } from "./auth.context-COWO6ssl.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";
@@ -15,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-COWO6ssl.mjs → auth.context-BAz8frX9.mjs}

@@ -1,5 +1,22 @@
 import { createContext, use, useMemo } from "react";
 import { jsx } from "react/jsx-runtime";
+//#region src/lib/config/router.context.tsx
+let OpenApiRouter;
+(function(_OpenApiRouter) {
+	const Context = createContext(null);
+	_OpenApiRouter.Provider = ({ children, replace }) => {
+		return /* @__PURE__ */ jsx(Context, {
+			value: useMemo(() => ({ replace }), [replace]),
+			children
+		});
+	};
+	_OpenApiRouter.useRouter = () => {
+		const context = use(Context);
+		if (!context) throw new Error("useRouter must be used within an OpenApiRouter.Provider");
+		return context;
+	};
+})(OpenApiRouter || (OpenApiRouter = {}));
+//#endregion
 //#region src/lib/auth/auth.context.tsx
 let AuthContext;
 (function(_AuthContext) {
@@ -36,4 +53,4 @@ let AuthContext;
 	};
 })(AuthContext || (AuthContext = {}));
 //#endregion
-export { AuthContext as t };
+export { OpenApiRouter as n, AuthContext as t };

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-BeydPL7s.mjs → error-handling-CsnufAil.mjs}

@@ -1,26 +1,48 @@
-import { n as ns, r as resolveT } from "./i18n-D-FesqFb.mjs";
-import { t as HttpError } from "./rest-transport.types-DxitRtsB.mjs";
+import { isAxiosError, isCancel } from "axios";
 import { z } from "zod";
-//#region src/lib/rest/http-error.utils.ts
-function isAxiosErrorLike(error) {
-	return typeof error === "object" && error !== null && "isAxiosError" in error;
+//#region src/lib/assets/locales/en/translation.json
+var translation_default$1 = { openapi: { "sharedErrors": {
+	"dataValidation": "An error occurred while validating the data",
+	"internalError": "An internal error occurred. This is most likely a bug on our end. Please try again later.",
+	"networkError": "A network error occurred. Are you connected to the internet?",
+	"canceledError": "The request was canceled.",
+	"unknownError": "An unknown error occurred. Please try again later.",
+	"unknownErrorWithCode": "An unknown error occurred. Error code: \"{{code}}\""
+} } };
+//#endregion
+//#region src/lib/assets/locales/sl/translation.json
+var translation_default = { openapi: { "sharedErrors": {
+	"dataValidation": "Pri preverjanju podatkov je prišlo do napake",
+	"internalError": "Prišlo je do notranje napake.",
+	"networkError": "Prišlo je do napake v omrežju.",
+	"canceledError": "Zahteva je bila preklicana.",
+	"unknownError": "Prišlo je do neznane napake.",
+	"unknownErrorWithCode": "Prišlo je do neznane napake. Koda napake: \"{{code}}\""
+} } };
+//#endregion
+//#region src/lib/config/i18n.ts
+const ns = "openapi";
+const resources = {
+	en: { [ns]: translation_default$1 },
+	sl: { [ns]: translation_default }
+};
+let getT = null;
+function configureTranslations(getter) {
+	getT = () => getter();
 }
-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;
+function resolveT() {
+	if (!getT) throw new Error("Translations not configured. Call configureTranslations() at app startup.");
+	return getT();
 }
 //#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;
@@ -32,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;
 	};
@@ -85,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 })
@@ -94,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 })
@@ -103,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 })
 		};
@@ -181,4 +205,4 @@ var ErrorHandler = class ErrorHandler {
 };
 const SharedErrorHandler = new ErrorHandler({ entries: [] });
 //#endregion
-export { RestUtils as a, SharedErrorHandler as i, DomainErrorRegistry as n, ErrorHandler as r, ApplicationException as t };
+export { RestUtils as a, resources as c, SharedErrorHandler as i, DomainErrorRegistry as n, configureTranslations as o, ErrorHandler as r, ns as s, ApplicationException as t };

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

@@ -1,4 +1,40 @@
-import { t as TranslateFunction } from "./i18n-B_brQh4X.mjs";
+//#region src/lib/config/i18n.d.ts
+declare const ns = "openapi";
+declare const resources: {
+  readonly en: {
+    readonly openapi: {
+      openapi: {
+        sharedErrors: {
+          dataValidation: string;
+          internalError: string;
+          networkError: string;
+          canceledError: string;
+          unknownError: string;
+          unknownErrorWithCode: string;
+        };
+      };
+    };
+  };
+  readonly sl: {
+    readonly openapi: {
+      openapi: {
+        sharedErrors: {
+          dataValidation: string;
+          internalError: string;
+          networkError: string;
+          canceledError: string;
+          unknownError: string;
+          unknownErrorWithCode: string;
+        };
+      };
+    };
+  };
+};
+type TranslateFunction = (key: string, options?: {
+  ns?: string;
+}) => string;
+declare function configureTranslations<T>(getter: () => T): void;
+//#endregion
 //#region src/lib/rest/error-handling.d.ts
 type GeneralErrorCodes = "DATA_VALIDATION_ERROR" | "NETWORK_ERROR" | "CANCELED_ERROR" | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
 declare class ApplicationException<CodeT> extends Error {
@@ -33,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;
@@ -44,4 +83,4 @@ declare class ErrorHandler<CodeT extends string | number> {
 }
 declare const SharedErrorHandler: ErrorHandler<never>;
 //#endregion
-export { ErrorHandler as a, SharedErrorHandler as c, ErrorEntry as i, DomainErrorEntry as n, ErrorHandlerOptions as o, DomainErrorRegistry as r, GeneralErrorCodes as s, ApplicationException as t };
+export { ErrorHandler as a, SharedErrorHandler as c, ns as d, resources as f, ErrorEntry as i, TranslateFunction as l, DomainErrorEntry as n, ErrorHandlerOptions as o, DomainErrorRegistry as r, GeneralErrorCodes as s, ApplicationException as t, configureTranslations as u };

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 };