@povio/openapi-codegen-cli 2.0.8-rc.16 → 2.0.8-rc.18

package/dist/acl.d.mts

@@ -1,3 +1,4 @@
+import { r as ErrorHandler } from "./error-handling-p69GkKGP.mjs";
 import * as react from "react";
 import { PropsWithChildren } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
@@ -45,4 +46,14 @@ declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({
   ...props
 }: CanProps<TAppAbilities>) => react_jsx_runtime0.JSX.Element;
 //#endregion
-export { AbilityContext, type AppAbilities, type AppAbility, Can, createAclGuard };
+//#region src/lib/acl/useAclCheck.d.ts
+interface UseAclCheckProps {
+  errorHandler?: ErrorHandler<never>;
+}
+declare function useAclCheck<TAppAbilities extends AppAbilities = AppAbilities>({
+  errorHandler
+}?: UseAclCheckProps): {
+  checkAcl: (appAbility: TAppAbilities) => void;
+};
+//#endregion
+export { AbilityContext, type AppAbilities, type AppAbility, Can, createAclGuard, useAclCheck };

package/dist/acl.mjs

@@ -1,5 +1,5 @@
-import { n as OpenApiRouter, t as AuthContext } from "./auth.context-DKjzWiaA.mjs";
-import { createContext, useEffect, useState } from "react";
+import { a as SharedErrorHandler, n as OpenApiRouter, t as AuthContext } from "./auth.context-HV1I5QMx.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";
@@ -60,4 +60,14 @@ const Can = ({ use, ...props }) => {
 };
 
 //#endregion
-export { AbilityContext, Can, createAclGuard };
+//#region src/lib/acl/useAclCheck.ts
+function useAclCheck({ errorHandler } = {}) {
+	const ability = AbilityContext.useAbility();
+	return { checkAcl: useCallback((appAbility) => {
+		const can = ability.can;
+		if (!can(...appAbility)) (errorHandler ?? SharedErrorHandler).rethrowError(/* @__PURE__ */ new Error("ACL check failed"));
+	}, [ability, errorHandler]) };
+}
+
+//#endregion
+export { AbilityContext, Can, createAclGuard, useAclCheck };

package/dist/auth.context-HV1I5QMx.mjs

@@ -0,0 +1,244 @@
+import { isAxiosError, isCancel } from "axios";
+import { z } from "zod";
+import i18next from "i18next";
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#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 }
+};
+const defaultLanguage = "en";
+const i18n = i18next.createInstance();
+i18n.init({
+	compatibilityJSON: "v4",
+	lng: defaultLanguage,
+	fallbackLng: defaultLanguage,
+	resources,
+	ns: Object.keys(resources.en),
+	defaultNS: ns,
+	interpolation: { escapeValue: false }
+});
+const defaultT = i18n.t.bind(i18n);
+
+//#endregion
+//#region src/lib/rest/rest.utils.ts
+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;
+		if (typeof data?.code === "string") return data.code;
+		return null;
+	};
+	_RestUtils.doesServerErrorMessageContain = (e, text) => {
+		const message = extractServerErrorMessage(e);
+		if (message === null || message === void 0) return false;
+		return message.toLowerCase().includes(text.toLowerCase());
+	};
+	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;
+		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;
+	};
+})(RestUtils || (RestUtils = {}));
+
+//#endregion
+//#region src/lib/rest/error-handling.ts
+var ApplicationException = class extends Error {
+	code;
+	serverMessage = null;
+	constructor(message, code, serverMessage) {
+		super(message);
+		this.code = code;
+		this.serverMessage = serverMessage;
+	}
+};
+var ErrorHandler = class {
+	entries = [];
+	t;
+	onRethrowError;
+	constructor({ entries, t = defaultT, onRethrowError }) {
+		this.t = t;
+		this.onRethrowError = onRethrowError;
+		const dataValidationError = {
+			code: "DATA_VALIDATION_ERROR",
+			condition: (e) => {
+				return e instanceof z.ZodError;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.dataValidation")
+		};
+		const internalError = {
+			code: "INTERNAL_ERROR",
+			condition: (e) => {
+				if (isAxiosError(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.internalError")
+		};
+		const networkError = {
+			code: "NETWORK_ERROR",
+			condition: (e) => {
+				if (isAxiosError(e)) return e.code === "ERR_NETWORK";
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.networkError")
+		};
+		const canceledError = {
+			code: "CANCELED_ERROR",
+			condition: (e) => {
+				if (isCancel(e)) return true;
+				if (isAxiosError(e) && e.code === "ECONNABORTED") return true;
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.canceledError")
+		};
+		const unknownError = {
+			code: "UNKNOWN_ERROR",
+			condition: () => true,
+			getMessage: (_, e) => {
+				const code = RestUtils.extractServerResponseCode(e);
+				const serverMessage = RestUtils.extractServerErrorMessage(e);
+				if (code) {
+					let message = `Unknown error, message from server: ${code}`;
+					if (serverMessage) message += ` ${serverMessage}`;
+					return message;
+				}
+				return this.t("openapi.sharedErrors.unknownError");
+			}
+		};
+		this.entries = [
+			...entries,
+			dataValidationError,
+			internalError,
+			networkError,
+			canceledError,
+			unknownError
+		];
+	}
+	matchesEntry(error, entry, code) {
+		if (entry.condition) return entry.condition(error);
+		return code === entry.code;
+	}
+	setTranslateFunction(t) {
+		this.t = t;
+	}
+	rethrowError(error) {
+		const code = RestUtils.extractServerResponseCode(error);
+		const errorEntry = this.entries.find((entry) => this.matchesEntry(error, entry, code));
+		const serverMessage = RestUtils.extractServerErrorMessage(error);
+		const exception = new ApplicationException(errorEntry.getMessage(this.t, error), errorEntry.code, serverMessage);
+		this.onRethrowError?.(error, exception);
+		throw exception;
+	}
+	getError(error) {
+		if (error instanceof ApplicationException) return error;
+		return null;
+	}
+	getErrorCode(error) {
+		if (error instanceof ApplicationException) return error.code;
+		return null;
+	}
+	static getErrorMessage(error, fallbackToUnknown = true) {
+		if (typeof error === "string") return error;
+		if (error instanceof Error) return error.message;
+		if (error instanceof ApplicationException) {
+			if (error.serverMessage != null) return error.serverMessage;
+			return error.message;
+		}
+		if (fallbackToUnknown) return defaultT("openapi.sharedErrors.unknownError");
+		return null;
+	}
+};
+const SharedErrorHandler = new ErrorHandler({ entries: [] });
+
+//#endregion
+//#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) {
+	const Context = createContext({});
+	_AuthContext.Provider = ({ isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState, children }) => {
+		const value = useMemo(() => ({
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		}), [
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	};
+	_AuthContext.useAuth = () => {
+		return use(Context);
+	};
+})(AuthContext || (AuthContext = {}));
+
+//#endregion
+export { SharedErrorHandler as a, resources as c, ErrorHandler as i, OpenApiRouter as n, RestUtils as o, ApplicationException as r, ns as s, AuthContext as t };

package/dist/{config-Cu_GYfai.d.mts → config-B4HK4BLi.d.mts}

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

package/dist/error-handling-p69GkKGP.d.mts

@@ -0,0 +1,38 @@
+import { TFunction } from "i18next";
+
+//#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 {
+  code: CodeT;
+  serverMessage: string | null;
+  constructor(message: string, code: CodeT, serverMessage: string | null);
+}
+interface ErrorEntry<CodeT> {
+  code: CodeT;
+  condition?: (error: unknown) => boolean;
+  getMessage: (t: TFunction, error: unknown) => string;
+}
+interface ErrorHandlerOptions<CodeT extends string> {
+  entries: ErrorEntry<CodeT>[];
+  t?: TFunction;
+  onRethrowError?: (error: unknown, exception: ApplicationException<CodeT | GeneralErrorCodes>) => void;
+}
+declare class ErrorHandler<CodeT extends string> {
+  entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+  private t;
+  private onRethrowError?;
+  constructor({
+    entries,
+    t,
+    onRethrowError
+  }: ErrorHandlerOptions<CodeT>);
+  private matchesEntry;
+  setTranslateFunction(t: TFunction): void;
+  rethrowError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes>;
+  getError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> | null;
+  getErrorCode(error: unknown): CodeT | GeneralErrorCodes | null;
+  static getErrorMessage(error: unknown, fallbackToUnknown?: boolean): string | null;
+}
+declare const SharedErrorHandler: ErrorHandler<never>;
+//#endregion
+export { GeneralErrorCodes as a, ErrorHandlerOptions as i, ErrorEntry as n, SharedErrorHandler as o, ErrorHandler as r, ApplicationException as t };

package/dist/{generate.runner-DF2eZ4P-.mjs → generate.runner-C93djZ78.mjs}

@@ -1,4 +1,4 @@
-import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-ao1R1u57.mjs";
+import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-BP7F6YJP.mjs";
 import fs from "fs";
 import path from "path";
 import SwaggerParser from "@apidevtools/swagger-parser";