@povio/openapi-codegen-cli 2.0.8-rc.1 → 2.0.8-rc.10

package/dist/index.mjs

@@ -1,23 +1,366 @@
-import { RestClient } from "./lib/rest/rest-client.mjs";
-import { RestInterceptor } from "./lib/rest/rest-interceptor.mjs";
-import { RestUtils } from "./lib/rest/rest.utils.mjs";
-import { ApplicationException, ErrorHandler, SharedErrorHandler } from "./lib/rest/error-handling.mjs";
-import { OpenApiRouter } from "./lib/config/router.context.mjs";
-import { OpenApiQueryConfig } from "./lib/config/queryConfig.context.mjs";
-import { ns, resources } from "./lib/config/i18n.mjs";
-import { AuthContext } from "./lib/auth/auth.context.mjs";
-import { AuthGuard } from "./lib/auth/AuthGuard.mjs";
-export {
-  ApplicationException,
-  AuthContext,
-  AuthGuard,
-  ErrorHandler,
-  OpenApiQueryConfig,
-  OpenApiRouter,
-  RestClient,
-  RestInterceptor,
-  RestUtils,
-  SharedErrorHandler,
-  ns,
-  resources
+import { n as OpenApiRouter, t as AuthContext } from "./auth.context-DKjzWiaA.mjs";
+import axios, { isAxiosError, isCancel } from "axios";
+import { z } from "zod";
+import i18next from "i18next";
+import { createContext, use, useEffect, useMemo, useState } 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/rest/rest-client.ts
+var RestClient = class {
+	client;
+	errorHandler;
+	constructor({ config, interceptors, errorHandler } = {}) {
+		this.client = axios.create(config);
+		this.errorHandler = errorHandler ?? SharedErrorHandler;
+		this.attachInterceptors(interceptors);
+	}
+	attachInterceptors(interceptors, ...args) {
+		if (interceptors != null) interceptors.forEach((interceptor) => this.attachInterceptor(interceptor, ...args));
+	}
+	attachInterceptor(interceptor, ...args) {
+		interceptor.addInterceptor(this.client, ...args);
+	}
+	ejectInterceptor(interceptor) {
+		interceptor.removeInterceptor(this.client);
+	}
+	async get(requestInfo, url, requestConfig) {
+		return this.makeRequest(requestInfo, {
+			...requestConfig,
+			method: "get",
+			url
+		});
+	}
+	async post(requestInfo, url, data, requestConfig) {
+		return this.makeRequest(requestInfo, {
+			...requestConfig,
+			method: "post",
+			url,
+			data
+		});
+	}
+	async patch(requestInfo, url, data, requestConfig) {
+		return this.makeRequest(requestInfo, {
+			...requestConfig,
+			method: "patch",
+			url,
+			data
+		});
+	}
+	async put(requestInfo, url, data, requestConfig) {
+		return this.makeRequest(requestInfo, {
+			...requestConfig,
+			method: "put",
+			url,
+			data
+		});
+	}
+	async delete(requestInfo, url, data, requestConfig) {
+		return this.makeRequest(requestInfo, {
+			...requestConfig,
+			method: "delete",
+			url,
+			data
+		});
+	}
+	async makeRequest(requestInfo, requestConfig) {
+		const errorStack = (/* @__PURE__ */ new Error()).stack;
+		try {
+			const { rawResponse, ...config } = requestConfig;
+			const res = await this.client(config);
+			const resData = requestInfo.resSchema.parse(res.data);
+			return rawResponse ? {
+				...res,
+				data: resData
+			} : resData;
+		} catch (error) {
+			if (error instanceof z.ZodError) {
+				error.name = "BE Response schema mismatch - ZodError";
+				error.stack = [error.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+			}
+			(requestInfo.errorHandler ?? this.errorHandler).rethrowError(error);
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/rest/rest-interceptor.ts
+var RestInterceptor = class {
+	interceptorIdMap = [];
+	constructor(applyInterceptor) {
+		this.applyInterceptor = applyInterceptor;
+	}
+	addInterceptor(client, ...args) {
+		this.removeInterceptor(client);
+		const interceptorId = this.applyInterceptor(client, ...args);
+		this.interceptorIdMap.push({
+			client,
+			interceptorId
+		});
+	}
+	removeInterceptor(client) {
+		const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
+		if (interceptorId != null) {
+			client.interceptors.request.eject(interceptorId);
+			this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/config/queryConfig.context.tsx
+let OpenApiQueryConfig;
+(function(_OpenApiQueryConfig) {
+	const Context = createContext({});
+	_OpenApiQueryConfig.Provider = ({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, onError, children }) => {
+		const value = useMemo(() => ({
+			preferUpdate,
+			invalidateCurrentModule,
+			invalidationMap,
+			crossTabInvalidation,
+			onError
+		}), [
+			preferUpdate,
+			invalidateCurrentModule,
+			invalidationMap,
+			crossTabInvalidation,
+			onError
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	};
+	_OpenApiQueryConfig.useConfig = () => {
+		return use(Context) ?? {};
+	};
+})(OpenApiQueryConfig || (OpenApiQueryConfig = {}));
+
+//#endregion
+//#region src/lib/config/workspace.context.tsx
+let OpenApiWorkspaceContext;
+(function(_OpenApiWorkspaceContext) {
+	const Context = createContext({});
+	_OpenApiWorkspaceContext.Provider = ({ values, children }) => {
+		const contextValues = useMemo(() => values ?? {}, [values]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value: contextValues,
+			children
+		});
+	};
+	_OpenApiWorkspaceContext.useContext = () => {
+		return use(Context);
+	};
+	_OpenApiWorkspaceContext.resolveParam = (context, name, value) => {
+		if (value != null) return value;
+		const workspaceValue = context[name];
+		if (workspaceValue == null) throw new Error(`Missing workspace context param "${name}"`);
+		return workspaceValue;
+	};
+})(OpenApiWorkspaceContext || (OpenApiWorkspaceContext = {}));
+
+//#endregion
+//#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 { ApplicationException, AuthContext, AuthGuard, ErrorHandler, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources };

package/dist/options-DBz5YE3s.d.mts

@@ -0,0 +1,90 @@
+import { OpenAPIV3 } from "openapi-types";
+
+//#region src/generators/types/generate.d.ts
+declare enum GenerateType {
+  Models = "models",
+  Endpoints = "endpoints",
+  Queries = "queries",
+  Acl = "acl",
+  Configs = "configs"
+}
+interface GenerateFileData {
+  fileName: string;
+  content: string;
+}
+//#endregion
+//#region src/generators/types/options.d.ts
+interface ZodGenerateOptions {
+  schemaSuffix: string;
+  enumSuffix: string;
+  modelsInCommon?: boolean;
+  withImplicitRequiredProps?: boolean;
+  withDefaultValues?: boolean;
+  withDescription?: boolean;
+  allReadonly?: boolean;
+  extractEnums?: boolean;
+  replaceOptionalWithNullish?: boolean;
+}
+interface EndpointsGenerateOptions {
+  restClientImportPath: string;
+  errorHandlingImportPath?: string;
+  withDeprecatedEndpoints?: boolean;
+  removeOperationPrefixEndingWith?: string;
+  parseRequestParams?: boolean;
+  inlineEndpoints?: boolean;
+  inlineEndpointsExcludeModules?: string[];
+}
+interface QueriesGenerateOptions {
+  queryTypesImportPath: string;
+  axiosRequestConfig?: boolean;
+  mutationEffects?: boolean;
+  workspaceContext?: boolean;
+}
+interface InfiniteQueriesGenerateOptions {
+  infiniteQueries?: boolean;
+  infiniteQueryParamNames: {
+    page: string;
+  };
+  infiniteQueryResponseParamNames: {
+    page: string;
+    totalItems: string;
+    limit: string;
+  };
+}
+interface ACLGenerateOptions {
+  acl: boolean;
+  checkAcl?: boolean;
+  abilityContextGenericAppAbilities: boolean;
+  abilityContextImportPath?: string;
+}
+interface BuilderConfigsGenerateOptions {
+  builderConfigs?: boolean;
+  filterParamName: string;
+  dataResponseParamNames: string[];
+  dynamicInputsImportPath: string;
+  dynamicColumnsImportPath: string;
+}
+interface GenerateConfig {
+  outputFileNameSuffix: string;
+  namespaceSuffix: string;
+}
+interface BaseGenerateOptions {
+  input: string;
+  output: string;
+  incremental?: boolean;
+  splitByTags: boolean;
+  defaultTag: string;
+  excludeTags: string[];
+  excludePathRegex: string;
+  excludeRedundantZodSchemas: boolean;
+  tsNamespaces: boolean;
+  tsPath: string;
+  importPath: "ts" | "relative" | "absolute";
+  configs: Record<GenerateType, GenerateConfig>;
+  baseUrl: string;
+  modelsOnly?: boolean;
+  standalone?: boolean;
+}
+interface GenerateOptions extends BaseGenerateOptions, ZodGenerateOptions, EndpointsGenerateOptions, QueriesGenerateOptions, InfiniteQueriesGenerateOptions, ACLGenerateOptions, BuilderConfigsGenerateOptions {}
+//#endregion
+export { GenerateFileData as n, GenerateOptions as t };

package/dist/sh.d.mts

@@ -0,0 +1 @@
+export { };