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

package/README.md

@@ -4,9 +4,11 @@
 
 **NOTE:** Version 1+ requires zod v4 and is not compatible with zod v3.
 
-**NOTE:** Version 2+ includes supporting classes/types/components for the generated code as well as auth, therefore it has peerDependencies for @tanstack/react-query, axios, react and zod. @casl/ability and @casl/react are also required if you are generating ACL checks and/or using imports from "@povio/openapi-codegen-cli/acl"!
+**NOTE:** The package includes supporting classes, types, components, and auth utilities. Zod is a required peer dependency. Axios, @tanstack/react-query, react, i18next, @casl/ability, @casl/react, and Vite are optional peers; install the ones used by your chosen features.
 
-Use this tool to generate code (Zod schemas, TypeScript types, API definitions, and React queries) from an OpenAPI v3 specification. API definitions are generated to use a REST client wrapper that utilizes Axios. React queries are generated in alignment with our code standards, without the need for explicit types.
+Axios is required when using the Axios transport (the default) or the `/axios` entry point. Projects using the native transport can omit Axios: generate with `--restClient native` and import `NativeRestClient` from `@povio/openapi-codegen-cli/native`. The root exports remain available for compatibility and support tree-shaking in consumer bundles. For direct runtime imports without bundling, use `/native` and `/errors` to avoid loading the Axios client. The `/axios` entry point is also available for Axios-specific imports. CLI-only usage and the `/generator`, `/tiny`, `/vite`, and `/metro` entry points do not require Axios.
+
+Use this tool to generate code (Zod schemas, TypeScript types, API definitions, and React queries) from an OpenAPI v3 specification. API definitions use a REST client wrapper with either Axios or the native transport. React queries are generated in alignment with our code standards, without the need for explicit types.
 
 The tool partially leverages code from [openapi-zod-client](https://github.com/astahmer/openapi-zod-client) repository.
 
@@ -22,6 +24,43 @@ bun add @povio/openapi-codegen-cli
 bunx openapi-codegen generate --input http://localhost:3001/docs-json
 ```
 
+## Schema compilation
+
+Generated models use ordinary Zod schemas by default, preserving validation without the startup work of explicit `z.compile(...)` calls. Regenerate existing clients to remove previously emitted compilation calls. A frontend entry-point `import "zod/compile"` used solely for these generated models can then be removed.
+
+Set `compileSchemas: true` in your generator configuration (or pass `--compileSchemas`) to opt into eager compilation for non-recursive schemas. This trades initialization time for potential validation throughput improvements. Recursive schemas remain uncompiled. Both the TypeScript and native generators honor this option.
+
+```typescript
+export default {
+  compileSchemas: false, // Default; normal Zod validation stays enabled.
+};
+```
+
+## Lazy schemas
+
+With `tsNamespaces` enabled, every schema of a models namespace is built the moment the module is imported, even when the importer only needs one of them. Set `lazySchemas: true` (or pass `--lazySchemas`) to build each schema on first access instead:
+
+```typescript
+// Generated with lazySchemas: true
+const once = <T>(create: () => T) => {
+  let value: T | undefined;
+  return () => (value ??= create());
+};
+
+const PetSchema = once(() => z.object({ id: z.int(), category: CategorySchema() }));
+
+export const PetModels = {
+  get PetSchema() {
+    return PetSchema();
+  },
+};
+export declare namespace PetModels {
+  export type Pet = z.infer<typeof PetModels.PetSchema>;
+}
+```
+
+`PetModels.PetSchema` stays a regular Zod schema (`.extend`, `.shape`, `.pick` all work and return the same instance on every access), `PetModels.Pet` keeps resolving as a type, and `modelsInCommon` proxies forward to the shared namespace lazily as well. The option requires `tsNamespaces` and is honored by both the TypeScript and native generators. It helps cold starts of apps that import large model modules but render only a slice of them.
+
 ## Configuration Files
 
 The CLI supports TypeScript configuration files to simplify command execution and provide consistent settings with full type safety. Configuration files are automatically discovered in your project root.
@@ -33,7 +72,7 @@ The CLI supports TypeScript configuration files to simplify command execution an
 Create an `openapi-codegen.config.ts` file:
 
 ```typescript
-import { OpenAPICodegenConfig } from "@povio/openapi-codegen-cli";
+import type { OpenAPICodegenConfig } from "@povio/openapi-codegen-cli";
 
 const config: OpenAPICodegenConfig = {
   input: "http://localhost:4000/docs-json/",
@@ -85,11 +124,14 @@ bunx openapi-codegen generate --config my-config.ts
   --importPath                        Module import style for generated files (default: 'ts'; options: 'ts' | 'relative' | 'absolute')
   --tsPath                            (Requires `--importPath` to be 'ts') Typescript import path (default: '@/data')
   --removeOperationPrefixEndingWith   Remove operation name prefixes that end with the specified string (default: 'Controller_')
+  --compileSchemas                    Eagerly compile non-recursive Zod schemas (default: false)
+  --lazySchemas                       Build namespace model schemas on first access instead of at import; requires `--tsNamespaces` (default: false)
   --extractEnums                      Extract enums into separate Zod schemas (default: true)
   --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)
 
-  --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)
+  --restClient                        REST transport to generate: 'axios' or 'native' (default: 'axios')
+  --axiosRequestConfig                Include transport 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).
@@ -138,7 +180,7 @@ bun install
 # run tests
 bun run test
 
-# run sources with tsx
+# run TypeScript sources directly with Bun
 bun run start --help
 bun run start generate --input ./test/petstore.yaml --verbose
 
@@ -150,14 +192,66 @@ 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`.
+
+Run `bun run test:parity` after building the addon to compare every generated file across 64 layout combinations and representative values for every other renderer option. The matrix uses both `test/petstore.yaml` and `test/configuration.yaml`, exercises complete native and hybrid native generation, and loads generated models to check runtime references. The contradictory combination `modelsInCommon: true` with `modelsInModules: true` is rejected explicitly. Arbitrary strings and lists are covered by representative cases, not every possible value.
+
+The separate Renderer parity workflow generates this matrix with JavaScript and native on Linux and macOS, then compares exact file lists and SHA-256 hashes. Artifacts include route reports identifying complete versus hybrid native generation. Runner integration tests cover input/output, stale-file cleanup, and unchanged files; `incremental` is currently retained as a compatibility option and does not change the writer's unchanged-file optimization.
+
 ## 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
-import { RestInterceptor } from "@povio/openapi-codegen-cli";
+import { RestInterceptor } from "@povio/openapi-codegen-cli/axios";
 
 import { ACCESS_TOKEN_KEY } from "@/config/jwt.config";
 
@@ -174,7 +268,7 @@ export const AuthorizationHeaderInterceptor = new RestInterceptor((client) => {
 ```
 
 ```ts
-import { RestClient } from "@povio/openapi-codegen-cli";
+import { RestClient } from "@povio/openapi-codegen-cli/axios";
 
 import { AuthorizationHeaderInterceptor } from "@/clients/rest/interceptors/authorization-header.interceptor";
 import { AppConfig } from "@/config/app.config";
@@ -203,7 +297,8 @@ export default config;
 Set `mutationDefaultOnError: true` in codegen config (or pass `--mutationDefaultOnError`) to let generated mutation hooks fall back to `OpenApiQueryConfig.Provider` when a mutation call does not define its own `onError`.
 
 ```tsx
-import { ErrorHandler, OpenApiQueryConfig } from "@povio/openapi-codegen-cli";
+import { ErrorHandler } from "@povio/openapi-codegen-cli/errors";
+import { OpenApiQueryConfig } from "@povio/openapi-codegen-cli/query";
 
 <OpenApiQueryConfig.Provider
   onError={(error) => {
@@ -229,7 +324,7 @@ Use `OpenApiQueryConfig.Provider` to allow generated GET query hooks to return i
 Set `workspaceContext` to a list of param names in codegen config (or pass `--workspaceContext officeId,projectId`) and wrap your app subtree with `OpenApiWorkspaceContext.Provider` if generated hooks frequently repeat workspace-scoped params.
 
 ```tsx
-import { OpenApiWorkspaceContext } from "@povio/openapi-codegen-cli";
+import { OpenApiWorkspaceContext } from "@povio/openapi-codegen-cli/config";
 // openapi-codegen.config.ts -> { workspaceContext: ["officeId", "projectId"] }
 
 <OpenApiWorkspaceContext.Provider values={{ officeId: "office_123" }}>
@@ -256,6 +351,8 @@ const config: OpenAPICodegenConfig = {
   // modelsOnly: true,
   // 4) Keep all model declarations in common.models and generate per-module model proxies
   // modelsInCommon: true,
+  // 5) Build each namespace schema on first access instead of at import (requires tsNamespaces)
+  // lazySchemas: true,
 };
 ```
 
@@ -501,3 +598,22 @@ export class JSONDto {
   nested: NestedDto;
 }
 ```
+
+### Runtime import paths
+
+Use package subpaths for runtime imports. Pure `import type` imports may use the package root.
+
+| Runtime exports                                                                              | Subpath   |
+| -------------------------------------------------------------------------------------------- | --------- |
+| `AuthContext`, `AuthGuard`                                                                   | `/auth`   |
+| `AbilityContext`, `useAclCheck`, `Can`, `createAclGuard`                                     | `/acl`    |
+| `ErrorHandler`, `SharedErrorHandler`, `ApplicationException`, `DomainErrorRegistry`          | `/errors` |
+| `useMutationEffects`, `OpenApiQueryConfig`                                                   | `/query`  |
+| `OpenApiRouter`, `OpenApiWorkspaceContext`, `useWorkspaceContext`, translation configuration | `/config` |
+| `ZodExtended`                                                                                | `/zod`    |
+| `HttpError`, transport types                                                                 | `/rest`   |
+| `NativeRestClient`                                                                           | `/native` |
+| `RestClient`, `RestInterceptor` (Axios transport)                                            | `/axios`  |
+
+For example: `import { AuthContext, AuthGuard } from "@povio/openapi-codegen-cli/auth"`.
+Custom application helpers should import error helpers from `/errors`, `AbilityContext` from `/acl`, and mutation effects from `/query`.

package/dist/AuthGuard-GbtTDXs0.d.mts

@@ -0,0 +1,32 @@
+import { PropsWithChildren, ReactNode } from "react";
+//#region src/lib/auth/auth.context.d.ts
+declare namespace AuthContext {
+  export interface Routes {
+    authenticated?: string;
+    unauthenticated?: string;
+  }
+  interface Type<TUser = unknown> {
+    isAuthenticated: boolean;
+    isInitializing: boolean;
+    logout: () => void;
+    updateTokens?: (accessToken: string | null, refreshToken?: string | null) => void;
+    accessToken?: string | null;
+    user?: TUser | null;
+    userPromise?: () => Promise<TUser | null>;
+    routes?: Routes;
+    loadingState?: ReactNode;
+  }
+  type ProviderProps<TUser = unknown> = Type<TUser>;
+  export const Provider: <TUser>({ isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState, children }: PropsWithChildren<ProviderProps<TUser>>) => import("react").JSX.Element;
+  export const useAuth: <TUser>() => Type<TUser>;
+  export {};
+}
+//#endregion
+//#region src/lib/auth/AuthGuard.d.ts
+interface AuthGuardProps {
+  type: "public-only" | "private";
+  redirectTo?: string;
+}
+declare const AuthGuard: ({ type, redirectTo, children }: PropsWithChildren<AuthGuardProps>) => import("react").ReactNode;
+//#endregion
+export { AuthGuardProps as n, AuthContext as r, AuthGuard as t };

package/dist/AuthGuard-qpAtHaBz.mjs

@@ -0,0 +1,24 @@
+import { t as OpenApiRouter } from "./router.context-EPlMBk3G.mjs";
+import { t as AuthContext } from "./auth.context-COWO6ssl.mjs";
+import { useEffect, useState } from "react";
+//#region src/lib/auth/AuthGuard.tsx
+const AuthGuard = ({ type, redirectTo, children }) => {
+	const { isAuthenticated, routes, loadingState } = AuthContext.useAuth();
+	const { replace } = OpenApiRouter.useRouter();
+	const [hasMounted, setHasMounted] = useState(false);
+	useEffect(() => {
+		setHasMounted(true);
+	}, []);
+	if (!hasMounted) return loadingState;
+	if (type === "private" && !isAuthenticated) {
+		replace(redirectTo || routes?.unauthenticated || "/");
+		return null;
+	}
+	if (type === "public-only" && isAuthenticated) {
+		replace(redirectTo || routes?.authenticated || "/");
+		return null;
+	}
+	return children;
+};
+//#endregion
+export { AuthGuard as t };

package/dist/acl.d.mts

@@ -1,25 +1,21 @@
-import { a as ErrorHandler } from "./error-handling-D6ZYITQ3.mjs";
-import * as _$react from "react";
+import { a as ErrorHandler } from "./error-handling-LPEPQV1V.mjs";
 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: _$react.Consumer<AppAbility>;
+  export const Consumer: import("react").Consumer<AppAbility>;
   interface ProviderProps {
     user?: {
       aclRules?: PackRule<RawRuleOf<AppAbility>>[];
     } | null;
   }
-  export const Provider: ({
-    children
-  }: PropsWithChildren<ProviderProps>) => _$react.JSX.Element;
+  export const Provider: ({ children }: PropsWithChildren<ProviderProps>) => import("react").JSX.Element;
   export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
   export {};
 }
@@ -29,29 +25,20 @@ interface AclGuardProps<TAppAbilities extends AppAbilities = AppAbilities> {
   canUse: TAppAbilities;
   redirectTo?: string;
 }
-declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({
-  canUse,
-  redirectTo,
-  children
-}: PropsWithChildren<AclGuardProps<TAppAbilities>>) => _$react.ReactNode;
+declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({ canUse, redirectTo, children }: PropsWithChildren<AclGuardProps<TAppAbilities>>) => import("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>) => _$react.JSX.Element;
+declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({ use, ...props }: CanProps<TAppAbilities>) => import("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,7 @@
-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 { i as SharedErrorHandler } from "./error-handling-uS0DgYUR.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 { jsx } from "react/jsx-runtime";
 import { AbilityBuilder, createMongoAbility } from "@casl/ability";
 import { unpackRules } from "@casl/ability/extra";
@@ -14,16 +15,15 @@ let AbilityContext;
 	const { Consumer } = Context;
 	_AbilityContext.Consumer = Consumer;
 	_AbilityContext.Provider = ({ children }) => {
-		const [ability, setAbility] = useState(initialAppAbility);
 		const { user } = AuthContext.useAuth();
-		useEffect(() => {
-			if (!user || !("aclRules" in user)) return;
+		const ability = useMemo(() => {
+			if (!user || !("aclRules" in user)) return initialAppAbility;
 			const { can, build } = createAppAbilityBuilder();
 			const packedRules = user.aclRules;
 			unpackRules(packedRules).forEach(({ action, subject, conditions }) => {
 				can(action, subject, conditions);
 			});
-			setAbility(build());
+			return build();
 		}, [user]);
 		return /* @__PURE__ */ jsx(Context.Provider, {
 			value: ability,

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

@@ -1,22 +1,5 @@
 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) {
@@ -53,4 +36,4 @@ let AuthContext;
 	};
 })(AuthContext || (AuthContext = {}));
 //#endregion
-export { OpenApiRouter as n, AuthContext as t };
+export { AuthContext as t };

package/dist/auth.d.mts

@@ -0,0 +1,2 @@
+import { n as AuthGuardProps, r as AuthContext, t as AuthGuard } from "./AuthGuard-GbtTDXs0.mjs";
+export { AuthContext, AuthGuard, type AuthGuardProps };

package/dist/auth.mjs

@@ -0,0 +1,3 @@
+import { t as AuthContext } from "./auth.context-COWO6ssl.mjs";
+import { t as AuthGuard } from "./AuthGuard-qpAtHaBz.mjs";
+export { AuthContext, AuthGuard };

package/dist/axios.d.mts

@@ -0,0 +1,2 @@
+import { a as RestClient, i as Response, n as RequestConfig, o as RestInterceptor, r as RequestInfo, t as RestClient$1 } from "./rest-client-CQyFvqYC.mjs";
+export { type RestClient as IRestClient, type RequestConfig, type RequestInfo, type Response, RestClient$1 as RestClient, RestInterceptor };

package/dist/axios.mjs

@@ -0,0 +1,2 @@
+import { n as RestClient, t as RestInterceptor } from "./rest-interceptor-Dm9DFErh.mjs";
+export { RestClient, RestInterceptor };

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

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

package/dist/config.d.mts

@@ -0,0 +1,4 @@
+import { i as resources, n as configureTranslations, r as ns, t as TranslateFunction } from "./i18n-B_brQh4X.mjs";
+import { n as useWorkspaceContext, r as OpenApiRouter, t as OpenApiWorkspaceContext } from "./workspace.context-isVY9ves.mjs";
+import { i as QueryModule, n as InvalidationMapFunc, r as OpenApiQueryConfig, t as InvalidationMap } from "./queryConfig.context-CRJOgf19.mjs";
+export { type InvalidationMap, type InvalidationMapFunc, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, type QueryModule, type TranslateFunction, configureTranslations, ns, resources, useWorkspaceContext };

package/dist/config.mjs

@@ -0,0 +1,5 @@
+import { i as resources, n as ns, t as configureTranslations } from "./i18n-D-FesqFb.mjs";
+import { t as OpenApiQueryConfig } from "./queryConfig.context-CldQ5YL9.mjs";
+import { t as OpenApiRouter } from "./router.context-EPlMBk3G.mjs";
+import { n as useWorkspaceContext, t as OpenApiWorkspaceContext } from "./workspace.context-XWvQ_7Hg.mjs";
+export { OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, configureTranslations, ns, resources, useWorkspaceContext };

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

@@ -1,40 +1,4 @@
-//#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
+import { t as TranslateFunction } from "./i18n-B_brQh4X.mjs";
 //#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 {
@@ -69,10 +33,7 @@ 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;
@@ -83,4 +44,4 @@ declare class ErrorHandler<CodeT extends string | number> {
 }
 declare const SharedErrorHandler: ErrorHandler<never>;
 //#endregion
-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 };
+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 };

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

@@ -1,48 +1,26 @@
-import { isAxiosError, isCancel } from "axios";
+import { n as ns, r as resolveT } from "./i18n-D-FesqFb.mjs";
+import { t as HttpError } from "./rest-transport.types-DxitRtsB.mjs";
 import { z } from "zod";
-//#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();
+//#region src/lib/rest/http-error.utils.ts
+function isAxiosErrorLike(error) {
+	return typeof error === "object" && error !== null && "isAxiosError" in error;
 }
-function resolveT() {
-	if (!getT) throw new Error("Translations not configured. Call configureTranslations() at app startup.");
-	return getT();
+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";
-		if (!isAxiosError(e)) return null;
-		if (!e.response) return null;
-		const data = e.response.data;
+		const data = getResponseData(e);
 		if (typeof data?.code === "string") return data.code;
 		if (typeof data?.code === "number") return data.code;
 		return null;
@@ -54,15 +32,13 @@ let RestUtils;
 	};
 	const extractServerErrorMessage = _RestUtils.extractServerErrorMessage = (e) => {
 		if (e instanceof z.ZodError) return e.message;
-		if (!isAxiosError(e)) return null;
-		if (!e.response) return null;
-		const data = e.response.data;
+		const data = getResponseData(e);
 		if (typeof data?.message === "string") return data.message;
 		return null;
 	};
 	_RestUtils.extractContentDispositionFilename = (headers) => {
-		const contentDisposition = headers["content-disposition"];
-		return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+		const contentDisposition = headers instanceof Headers ? headers.get("content-disposition") : headers["content-disposition"];
+		return typeof contentDisposition === "string" ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
 	};
 })(RestUtils || (RestUtils = {}));
 //#endregion
@@ -109,7 +85,8 @@ var ErrorHandler = class ErrorHandler {
 		const internalError = {
 			code: "INTERNAL_ERROR",
 			condition: (e) => {
-				if (isAxiosError(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+				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;
 				return false;
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.internalError", { ns })
@@ -117,7 +94,8 @@ var ErrorHandler = class ErrorHandler {
 		const networkError = {
 			code: "NETWORK_ERROR",
 			condition: (e) => {
-				if (isAxiosError(e)) return e.code === "ERR_NETWORK";
+				if (isAxiosErrorLike(e)) return e.code === "ERR_NETWORK";
+				if (e instanceof TypeError) return true;
 				return false;
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.networkError", { ns })
@@ -125,9 +103,7 @@ var ErrorHandler = class ErrorHandler {
 		const canceledError = {
 			code: "CANCELED_ERROR",
 			condition: (e) => {
-				if (isCancel(e)) return true;
-				if (isAxiosError(e) && e.code === "ECONNABORTED") return true;
-				return false;
+				return isCanceledRequest(e);
 			},
 			getMessage: () => resolveT()("openapi.sharedErrors.canceledError", { ns })
 		};
@@ -205,4 +181,4 @@ var ErrorHandler = class ErrorHandler {
 };
 const SharedErrorHandler = new ErrorHandler({ entries: [] });
 //#endregion
-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 };
+export { RestUtils as a, SharedErrorHandler as i, DomainErrorRegistry as n, ErrorHandler as r, ApplicationException as t };

package/dist/errors.d.mts

@@ -0,0 +1,3 @@
+import { a as ErrorHandler, c as SharedErrorHandler, i as ErrorEntry, n as DomainErrorEntry, o as ErrorHandlerOptions, r as DomainErrorRegistry, s as GeneralErrorCodes, t as ApplicationException } from "./error-handling-LPEPQV1V.mjs";
+import { t as RestUtils } from "./rest.utils-DpiFIdhF.mjs";
+export { ApplicationException, type DomainErrorEntry, DomainErrorRegistry, type ErrorEntry, ErrorHandler, type ErrorHandlerOptions, type GeneralErrorCodes, RestUtils, SharedErrorHandler };

package/dist/errors.mjs

@@ -0,0 +1,2 @@
+import { a as RestUtils, i as SharedErrorHandler, n as DomainErrorRegistry, r as ErrorHandler, t as ApplicationException } from "./error-handling-uS0DgYUR.mjs";
+export { ApplicationException, DomainErrorRegistry, ErrorHandler, RestUtils, SharedErrorHandler };