@povio/openapi-codegen-cli 2.0.8-rc.37 → 2.0.8-rc.39

package/src/generators/templates/partials/query-keys.hbs

@@ -0,0 +1,11 @@
+export const keys = {
+    all: [{{queriesModuleName}}] as const,
+    {{#each queryEndpoints as | endpoint |}}
+    {{endpointName endpoint}}: ({{{genEndpointParams endpoint pathParamsRequiredOnly=true}}}) => [...keys.all, "{{endpoint.path}}", {{{endpointArgs endpoint}}}] as const,
+    {{#if ../generateInfiniteQueries}}
+    {{#if (isInfiniteQuery endpoint)}}
+    {{endpointName endpoint}}Infinite: ({{{genEndpointParams endpoint excludePageParam=true pathParamsRequiredOnly=true}}}) => [...keys.all, "{{endpoint.path}}", "infinite", {{{endpointArgs endpoint excludePageParam=true}}}] as const,
+    {{/if}}
+    {{/if}}
+    {{/each}}
+};

package/src/generators/templates/partials/query-use-infinite-query.hbs

@@ -0,0 +1,22 @@
+{{! Js docs }}
+{{{genQueryJsDocs endpoint infiniteQuery=true}}}
+{{! Infinite query definition}}
+export const {{infiniteQueryName endpoint}} = <TData>({{#if (endpointParams endpoint)}}{{#if (endpointParamsAllOptional endpoint excludePageParam=true)}}params: { {{{genEndpointParams endpoint excludePageParam=true}}} } = {}{{else}}{ {{{endpointArgs endpoint excludePageParam=true}}} }: { {{{genEndpointParams endpoint excludePageParam=true}}} }{{/if}}, {{/if}}options?: AppInfiniteQueryOptions<typeof {{importedEndpointName endpoint}}, TData>{{#if hasAxiosRequestConfig}}, {{axiosRequestConfigName}}?: {{axiosRequestConfigType}}{{/if}}) => {
+  {{! Use acl check }}
+  {{#if hasAclCheck}}const { checkAcl } = {{aclCheckHook}}();{{/if}}
+  {{#if (endpointParams endpoint)}}{{#if (endpointParamsAllOptional endpoint excludePageParam=true)}}const { {{{endpointArgs endpoint excludePageParam=true}}} } = params;{{/if}}{{/if}}
+
+  return {{infiniteQueryHook}}({
+    queryKey: keys.{{endpointName endpoint}}Infinite({{#if (endpointParams endpoint)}}{{{endpointArgs endpoint excludePageParam=true}}}{{/if}}),
+    queryFn: ({ pageParam }) => {{#if hasQueryFnBody}}{ {{/if}} 
+    {{#if hasAclCheck}}{{{genAclCheckCall endpoint}}}{{/if}}
+    {{#if hasQueryFnBody}}return {{/if}}{{importedEndpointName endpoint}}({{{endpointArgs endpoint replacePageParam=true}}}{{#if hasAxiosRequestConfig}}, {{axiosRequestConfigName}}{{/if}})
+    {{#if hasQueryFnBody}} }{{/if}},
+    initialPageParam: 1,
+    getNextPageParam: ({ {{pageParamName}}, {{totalItemsName}}, {{limitParamName}}: limitParam }) => {
+      const pageParam = {{pageParamName}} ?? 1;
+      return pageParam * limitParam < {{totalItemsName}} ? pageParam + 1 : null;
+    },
+    ...options,
+  });
+};

package/src/generators/templates/partials/query-use-mutation.hbs

@@ -0,0 +1,54 @@
+{{! Js docs }}
+{{{genQueryJsDocs endpoint mutation=true}}}
+{{! Mutation definition}}
+export const {{queryName endpoint mutation=true}} = (options?: AppMutationOptions<typeof {{importedEndpointName endpoint}}, { {{{genEndpointParams endpoint includeFileParam=true}}}{{#if endpoint.mediaUpload}} abortController?: AbortController, onUploadProgress?: (progress: { loaded: number; total: number }) => void{{/if}} }>{{#if hasMutationEffects}} & {{mutationEffectsType}}{{/if}}{{#if hasAxiosRequestConfig}}, {{axiosRequestConfigName}}?: {{axiosRequestConfigType}}{{/if}}) => {
+  {{! Use acl check }}
+  {{#if hasAclCheck}}const { checkAcl } = {{aclCheckHook}}();{{/if}}
+  {{! Use mutation effects }}
+  {{#if hasMutationEffects}}const { runMutationEffects } = useMutationEffects({ currentModule: {{queriesModuleName}} });{{/if}}
+
+  return {{queryHook}}({
+    mutationFn: {{#if endpoint.mediaUpload}}async {{/if}}({{#if (endpointParams endpoint includeFileParam=true)}} { {{{endpointArgs endpoint includeFileParam=true}}}{{#if endpoint.mediaUpload}}, abortController, onUploadProgress{{/if}} } {{/if}}) => {{#if hasMutationFnBody}} { {{/if}}
+      {{#if hasAclCheck}}{{{genAclCheckCall endpoint}}}{{/if}}
+      {{#if endpoint.mediaUpload}}const uploadInstructions = await {{importedEndpointName endpoint}}({{{endpointArgs endpoint}}}{{#if hasAxiosRequestConfig}}{{#if (endpointArgs endpoint)}}, {{/if}}{{axiosRequestConfigName}}{{/if}});
+
+      if (file && uploadInstructions.url) {
+        const method = (data?.method?.toLowerCase() ?? "put") as 'put' | 'post';
+        let dataToSend: File | FormData = file;
+        if (method === "post") {
+          dataToSend = new FormData();
+          if (uploadInstructions.fields) {
+            for (const [key, value] of uploadInstructions.fields) {
+              dataToSend.append(key, value);
+            }
+          }
+          dataToSend.append('file', file);
+        }
+        await axios[method](uploadInstructions.url, dataToSend, {
+          headers: {
+            "Content-Type": file.type,
+          },
+          signal: abortController?.signal,
+          onUploadProgress: onUploadProgress
+          ? (progressEvent) => onUploadProgress({ loaded: progressEvent.loaded, total: progressEvent.total ?? 0 })
+          : undefined,
+        });
+      }
+
+      return uploadInstructions;
+      {{else}}
+      {{#if hasMutationFnBody}}return {{/if}}{{importedEndpointName endpoint}}({{{endpointArgs endpoint}}}{{#if hasAxiosRequestConfig}}{{#if (endpointArgs endpoint)}}, {{/if}}{{axiosRequestConfigName}}{{/if}})
+      {{/if}}
+    {{#if hasMutationFnBody}} }{{/if}},
+    ...options, {{#if hasMutationEffects}}
+    onSuccess: async (resData, variables, onMutateResult, context) => {
+      {{! Mutation effects }}
+      {{#if updateQueryEndpoints}}
+      {{#if destructuredVariables}}const { {{commaSeparated destructuredVariables }} } = variables;{{/if}}
+      const updateKeys = [{{#each updateQueryEndpoints as | endpoint |}}keys.{{endpointName endpoint}}({{{endpointArgs endpoint includeOnlyRequiredParams=true}}}), {{/each}}];
+      {{/if}}
+      await runMutationEffects(resData, variables, options{{#if updateQueryEndpoints}}, updateKeys{{/if}});
+      options?.onSuccess?.(resData, variables, onMutateResult, context);
+    },{{/if}}
+  });
+};

package/src/generators/templates/partials/query-use-query.hbs

@@ -0,0 +1,17 @@
+{{! Js docs }}
+{{{genQueryJsDocs endpoint query=true}}}
+{{! Query definition}}
+export const {{queryName endpoint}} = <TData>({{#if (endpointParams endpoint)}}{{#if (endpointParamsAllOptional endpoint)}}params: { {{{genEndpointParams endpoint}}} } = {}{{else}}{ {{{endpointArgs endpoint}}} }: { {{{genEndpointParams endpoint}}} }{{/if}}, {{/if}}options?: AppQueryOptions<typeof {{importedEndpointName endpoint}}, TData>{{#if hasAxiosRequestConfig}}, {{axiosRequestConfigName}}?: {{axiosRequestConfigType}}{{/if}}) => {
+  {{! Use acl check }}
+  {{#if hasAclCheck}}const { checkAcl } = {{aclCheckHook}}();{{/if}}
+  {{#if (endpointParams endpoint)}}{{#if (endpointParamsAllOptional endpoint)}}const { {{{endpointArgs endpoint}}} } = params;{{/if}}{{/if}}
+
+  return {{queryHook}}({
+    queryKey: keys.{{endpointName endpoint}}({{#if (endpointParams endpoint)}}{{{endpointArgs endpoint}}}{{/if}}),
+    queryFn: {{#if hasQueryFn}}() => {{#if hasQueryFnBody}}{ {{/if}} 
+    {{#if hasAclCheck}}{{{genAclCheckCall endpoint}}}{{/if}}
+    {{#if hasQueryFnBody}}return {{/if}}{{importedEndpointName endpoint}}({{{endpointArgs endpoint}}}{{#if hasAxiosRequestConfig}}{{#if (endpointArgs endpoint)}}, {{/if}}{{axiosRequestConfigName}}{{/if}}){{else}}{{importedEndpointName endpoint}}{{/if}}
+    {{#if hasQueryFnBody}} }{{/if}},
+    ...options,
+  });
+};

package/src/generators/templates/queries.hbs

@@ -0,0 +1,54 @@
+{{! Axios import }}
+{{#if hasAxiosImport}}
+{{{genImport axiosImport}}}
+{{/if}}
+{{! React query import }}
+{{{genImport queryImport}}}
+{{! Query modules import }}
+{{#if hasMutationEffects}}
+{{{genImport queryModulesImport}}}
+{{/if}}
+{{! Mutation effects import }}
+{{#if hasMutationEffectsImport}}
+{{{genImport mutationEffectsImport}}}
+{{/if}}
+{{! Acl check import }}
+{{#if hasAclCheck}}
+{{{genImport aclCheckImport}}}
+{{#each aclImports as | aclImport |}}
+{{{genImport aclImport}}}
+{{/each}}
+{{/if}}
+{{! React query types import }}
+{{{genImport queryTypesImport}}}
+{{! Models import }}
+{{#each modelsImports as | modelsImport |}}
+{{{genImport modelsImport}}}
+{{/each}}
+{{! Endpoints import }}
+{{#each endpointsImports as | endpointsImport |}}
+{{{genImport endpointsImport}}}
+{{/each}}
+
+{{#if includeNamespace}}
+export namespace {{namespace}} {
+{{/if}}
+
+export const {{queriesModuleName}} = {{#if hasMutationEffects}}{{queryModuleEnum}}.{{tag}}{{else}}"{{namespace}}"{{/if}};
+
+{{! Query keys export}}
+{{{genQueryKeys queryEndpoints}}}
+
+{{! Query export }}
+{{#each endpoints as | endpoint |}}
+{{{genQuery endpoint}}}
+
+{{{genMutation endpoint ../queryEndpoints}}}
+
+{{{genInfiniteQuery endpoint}}}
+
+{{/each}}
+
+{{#if includeNamespace}}
+}
+{{/if}}

package/src/generators/templates/query-modules.hbs

@@ -0,0 +1,5 @@
+export const enum QueryModule {
+   {{#each modules as | module |}}
+   {{module.tag}} = "{{module.namespace}}",
+   {{/each}}
+}

package/src/generators/templates/zod-extended.hbs

@@ -0,0 +1,49 @@
+{{! Zod import }}
+{{{genImport zodImport}}}
+{{! Error handling import }}
+{{{genImport errorHandlingImport}}}
+
+export namespace ZodExtended {
+  interface ParseOptions {
+    type: "body" | "query";
+    name?: string;
+    errorHandler?: ErrorHandler<never>;
+  }
+
+  export function {{parse}}<ZOutput, ZInput>(
+    schema: z.ZodType<ZOutput, ZInput>,
+    data: unknown,
+    { type, name, errorHandler }: ParseOptions = { type: "body" },
+  ) {
+    try {
+      return schema.parse(data);
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        e.name = `FE Request ${type === "body" ? "body" : "query param"}${name ? ` ("${name}")` : ""} schema mismatch - ZodError`;
+      }
+      (errorHandler ?? {{sharedErrorHandler}}).rethrowError(e);
+      throw e;
+    }
+  }
+
+  function is{{capitalize sortExp}}Valid(enumSchema: z.ZodEnum, data?: string) {
+    if (data === undefined || data === "" || enumSchema.options.length === 0) {
+      return true;
+    }
+
+    const prefixedEnumOptions = `([+-]?(${enumSchema.options.join("|")}))`;
+    const commaSeparatedOptions = `(${prefixedEnumOptions})(\s*,\s*${prefixedEnumOptions})*`;
+    return new RegExp(`^${commaSeparatedOptions}$`).test(data);
+  }
+
+  export const {{sortExp}} = (enumSchema: z.ZodEnum) =>
+    z.string().superRefine((arg, ctx) => {
+      if (!is{{capitalize sortExp}}Valid(enumSchema, arg)) {
+        ctx.addIssue({
+          code: "invalid_value",
+          message: "Invalid sorting string.",
+          values: [],
+        });
+      }
+    });
+}

package/dist/acl.d.mts

@@ -1,59 +0,0 @@
-import { r as ErrorHandler } from "./error-handling-CXeVTk1T.mjs";
-import * as react from "react";
-import { PropsWithChildren } from "react";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
-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>;
-  interface ProviderProps {
-    user?: {
-      aclRules?: PackRule<RawRuleOf<AppAbility>>[];
-    } | null;
-  }
-  export const Provider: ({
-    children
-  }: PropsWithChildren<ProviderProps>) => react_jsx_runtime0.JSX.Element;
-  export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
-  export {};
-}
-//#endregion
-//#region src/lib/acl/AclGuard.d.ts
-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;
-//#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_runtime0.JSX.Element;
-//#endregion
-//#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/auth.context-Bu5KW2sI.mjs

@@ -1,59 +0,0 @@
-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) {
-	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 { OpenApiRouter as n, AuthContext as t };

package/dist/config-DTx4Ck6g.d.mts

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

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

@@ -1,38 +0,0 @@
-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/error-handling-DkPY7Asf.mjs

@@ -1,187 +0,0 @@
-import { isAxiosError, isCancel } from "axios";
-import { z } from "zod";
-import i18next from "i18next";
-
-//#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
-export { ns as a, RestUtils as i, ErrorHandler as n, resources as o, SharedErrorHandler as r, ApplicationException as t };

package/dist/generate.runner-DLLGYMVB.mjs

@@ -1,90 +0,0 @@
-import { S as Profiler, i as writeGenerateFileData, m as DEFAULT_GENERATE_OPTIONS, o as deepMerge, r as removeStaleGeneratedFiles, t as generateCodeFromOpenAPIDoc } from "./generateCodeFromOpenAPIDoc-CFbiHxB7.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 };