@povio/openapi-codegen-cli 2.0.8-rc.3 → 2.0.8-rc.31

package/dist/index.mjs

@@ -1,25 +1,252 @@
-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 { useMutationEffects } from "./assets/useMutationEffects.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,
-  useMutationEffects
+import { a as ns, i as RestUtils, n as ErrorHandler, o as resources, r as SharedErrorHandler, t as ApplicationException } from "./error-handling-DkPY7Asf.mjs";
+import { n as OpenApiRouter, t as AuthContext } from "./auth.context-Bu5KW2sI.mjs";
+import axios from "axios";
+import { z } from "zod";
+import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { jsx } from "react/jsx-runtime";
+
+//#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({});
+	function 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.Provider = Provider;
+	_OpenApiQueryConfig.useConfig = () => {
+		return use(Context) ?? {};
+	};
+})(OpenApiQueryConfig || (OpenApiQueryConfig = {}));
+
+//#endregion
+//#region src/lib/react-query/cross-tab-invalidation.ts
+const CROSS_TAB_INVALIDATE_KEY = "__rq_invalidate__";
+const broadcastQueryInvalidation = (queryKeys) => {
+	localStorage.setItem(CROSS_TAB_INVALIDATE_KEY, JSON.stringify({
+		keys: queryKeys,
+		timestamp: Date.now()
+	}));
+};
+let isListenerSetUp = false;
+const setupCrossTabListener = (queryClient) => {
+	if (isListenerSetUp) return;
+	isListenerSetUp = true;
+	window.addEventListener("storage", (e) => {
+		if (e.key !== CROSS_TAB_INVALIDATE_KEY || !e.newValue) return;
+		try {
+			const { keys } = JSON.parse(e.newValue);
+			for (const queryKey of keys) queryClient.invalidateQueries({ queryKey });
+		} catch {}
+	});
+};
+
+//#endregion
+//#region src/lib/react-query/useMutationEffects.ts
+function useMutationEffects({ currentModule }) {
+	const queryClient = useQueryClient();
+	const config = OpenApiQueryConfig.useConfig();
+	useEffect(() => {
+		if (!config.crossTabInvalidation) return;
+		setupCrossTabListener(queryClient);
+	}, [queryClient, config.crossTabInvalidation]);
+	return { runMutationEffects: useCallback(async (data, variables, options = {}, updateKeys) => {
+		const { invalidateCurrentModule, invalidationMap, invalidateModules, invalidateKeys, preferUpdate } = options;
+		const shouldUpdate = preferUpdate ?? config.preferUpdate ?? false;
+		const shouldInvalidateCurrentModule = invalidateCurrentModule ?? config.invalidateCurrentModule ?? true;
+		const isQueryKeyEqual = (keyA, keyB) => keyA.length === keyB.length && keyA.every((item, index) => item === keyB[index]);
+		const isQueryKeyPrefix = (queryKey, prefixKey) => prefixKey.length <= queryKey.length && prefixKey.every((item, index) => item === queryKey[index]);
+		const mappedInvalidationKeys = invalidationMap?.[currentModule]?.(data, variables) ?? config.invalidationMap?.[currentModule]?.(data, variables);
+		const shouldInvalidateQuery = (queryKey) => {
+			const isUpdateKey = updateKeys?.some((key) => isQueryKeyEqual(queryKey, key));
+			if (shouldUpdate && isUpdateKey) return false;
+			const isCurrentModule = shouldInvalidateCurrentModule && queryKey[0] === currentModule;
+			const isInvalidateModule = !!invalidateModules && invalidateModules.some((module) => queryKey[0] === module);
+			const isInvalidateKey = !!invalidateKeys && invalidateKeys.some((key) => isQueryKeyPrefix(queryKey, key));
+			const isMappedKey = !!mappedInvalidationKeys && mappedInvalidationKeys.some((key) => isQueryKeyPrefix(queryKey, key));
+			return isCurrentModule || isInvalidateModule || isInvalidateKey || isMappedKey;
+		};
+		const invalidatedQueryKeys = [];
+		const shouldBroadcast = options.crossTabInvalidation ?? config.crossTabInvalidation;
+		queryClient.invalidateQueries({ predicate: ({ queryKey }) => {
+			const shouldInvalidate = shouldInvalidateQuery(queryKey);
+			if (shouldInvalidate && shouldBroadcast) invalidatedQueryKeys.push([...queryKey]);
+			return shouldInvalidate;
+		} });
+		if (shouldBroadcast && invalidatedQueryKeys.length > 0) broadcastQueryInvalidation(invalidatedQueryKeys);
+		if (shouldUpdate && updateKeys) updateKeys.map((queryKey) => queryClient.setQueryData(queryKey, data));
+	}, [
+		queryClient,
+		currentModule,
+		config.preferUpdate,
+		config.invalidateCurrentModule,
+		config.invalidationMap,
+		config.crossTabInvalidation
+	]) };
+}
+
+//#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, useMutationEffects };

package/dist/options-D9TC-n26.d.mts

@@ -0,0 +1,94 @@
+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;
+}
+type GenerateFileFormatter = (file: GenerateFileData) => string | Promise<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;
+  prefetchQueries?: 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;
+  clearOutput?: boolean;
+  incremental?: boolean;
+  splitByTags: boolean;
+  defaultTag: string;
+  includeTags: 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, GenerateFileFormatter as r, GenerateOptions as t };

package/dist/sh.d.mts

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