@povio/openapi-codegen-cli 3.3.0-rc.2 → 4.0.0-rc.2

package/dist/metro.d.mts

@@ -1,8 +1,7 @@
-import { r as GenerateFileFormatter } from "./options-DdQJ9BSc.mjs";
-import { t as OpenAPICodegenConfig } from "./config-BQqze8rU.mjs";
-import { d as GenerateOpenApiFile, m as GenerateOpenApiSpec, n as TinyOpenApiSpecModuleConfig } from "./openapi-source.runner-B6KKrXw7.mjs";
+import { r as GenerateFileFormatter } from "./options-X0zju7gw.mjs";
+import { t as OpenAPICodegenConfig } from "./config-CiLFKLAY.mjs";
+import { d as GenerateOpenApiFile, m as GenerateOpenApiSpec, n as TinyOpenApiSpecModuleConfig } from "./openapi-source.runner-DIOvAX_R.mjs";
 import { IncomingMessage, ServerResponse } from "http";
-
 //#region src/metro/openapi-codegen.plugin.d.ts
 type OpenApiCodegenMetroConfig = OpenAPICodegenConfig & {
   formatGeneratedFile?: GenerateFileFormatter;

package/dist/metro.mjs

@@ -1,5 +1,5 @@
-import { t as createOpenApiCodegenRunner } from "./openapi-codegen.runner-CCXQsUum.mjs";
-import { i as normalizeWatchFolders, r as isTinyOpenApiFakeMode, t as createTinyOpenApiSourceRunner } from "./openapi-source.runner-8kCe-g9S.mjs";
+import { t as createOpenApiCodegenRunner } from "./openapi-codegen.runner-G25v_q9z.mjs";
+import { i as normalizeWatchFolders, r as isTinyOpenApiFakeMode, t as createTinyOpenApiSourceRunner } from "./openapi-source.runner-DPUNTduQ.mjs";
 import fs from "fs";
 import path from "path";
 //#region src/metro/openapi-codegen.plugin.ts
@@ -83,7 +83,7 @@ function reportWatcherError$1(error) {
 }
 //#endregion
 //#region src/metro/tiny-openapi-codegen.plugin.ts
-const watchedEvents = new Set(["change", "rename"]);
+const watchedEvents = /* @__PURE__ */ new Set(["change", "rename"]);
 function tinyOpenApiCodegenMetro(metroConfig, codegenConfig, options) {
 	if (isPromiseLike(metroConfig)) return metroConfig.then((resolvedConfig) => withResolvedTinyOpenApiCodegen(resolvedConfig, codegenConfig, options));
 	return withResolvedTinyOpenApiCodegen(metroConfig, codegenConfig, options);

package/dist/native-rest-interceptor-DZxdDcpz.d.mts

@@ -0,0 +1,49 @@
+import { s as ErrorRethrower } from "./error-handling-BpAQHWrU.mjs";
+import { a as RestTransport, c as TransportFetch, d as TransportResponse, l as TransportRequest, o as RestTransportInterceptor, r as RestRequestInfo, s as TransportErrorContext, t as GeneralTransportErrorCode, u as TransportRequestConfig } from "./rest-transport.types-DM5-qyOJ.mjs";
+//#region src/lib/rest/native-rest-client.d.ts
+type NativeResult<T, IsRawRes extends boolean> = IsRawRes extends true ? TransportResponse<T> : T;
+declare class NativeRestClient implements RestTransport {
+  private readonly interceptors;
+  private readonly errorHandler?;
+  constructor({ config, interceptors, errorHandler }?: {
+    config?: {
+      baseURL?: string;
+      headers?: HeadersInit;
+      credentials?: RequestCredentials;
+      fetch?: TransportFetch;
+    };
+    interceptors?: RestTransportInterceptor[];
+    errorHandler?: ErrorRethrower;
+  });
+  private readonly baseURL;
+  private readonly headers?;
+  private readonly credentials?;
+  private readonly fetch;
+  attachInterceptor(interceptor: RestTransportInterceptor): void;
+  ejectInterceptor(interceptor: RestTransportInterceptor): void;
+  get<T, E extends string = GeneralTransportErrorCode, R extends boolean = false>(info: RestRequestInfo<T, E>, url: string, config?: TransportRequestConfig<R>): Promise<NativeResult<T, R>>;
+  post<T, E extends string = GeneralTransportErrorCode, R extends boolean = false>(info: RestRequestInfo<T, E>, url: string, data?: unknown, config?: TransportRequestConfig<R>): Promise<NativeResult<T, R>>;
+  patch<T, E extends string = GeneralTransportErrorCode, R extends boolean = false>(info: RestRequestInfo<T, E>, url: string, data?: unknown, config?: TransportRequestConfig<R>): Promise<NativeResult<T, R>>;
+  put<T, E extends string = GeneralTransportErrorCode, R extends boolean = false>(info: RestRequestInfo<T, E>, url: string, data?: unknown, config?: TransportRequestConfig<R>): Promise<NativeResult<T, R>>;
+  delete<T, E extends string = GeneralTransportErrorCode, R extends boolean = false>(info: RestRequestInfo<T, E>, url: string, data?: unknown, config?: TransportRequestConfig<R>): Promise<NativeResult<T, R>>;
+  upload(url: string, data: BodyInit, config?: TransportRequestConfig, method?: "put" | "post"): Promise<void>;
+  private request;
+  private execute;
+  private readResponse;
+  private resolveUrl;
+  private runErrorInterceptors;
+  private isTransportResponse;
+  private uploadWithXhr;
+}
+//#endregion
+//#region src/lib/rest/native-rest-interceptor.d.ts
+type NativeInterceptor = RestTransportInterceptor;
+declare class NativeRestInterceptor implements RestTransportInterceptor {
+  private readonly interceptor;
+  constructor(interceptor: RestTransportInterceptor);
+  onRequest(request: TransportRequest): Promise<TransportRequest> | TransportRequest;
+  onResponse<T>(response: TransportResponse<T>): Promise<TransportResponse<T>> | TransportResponse<T>;
+  onError(error: unknown, context: TransportErrorContext): unknown;
+}
+//#endregion
+export { NativeRestInterceptor as n, NativeRestClient as r, NativeInterceptor as t };

package/dist/native-rest-interceptor-Np4Ov54n.mjs

@@ -0,0 +1,215 @@
+import { t as HttpError } from "./rest-transport.types-DxitRtsB.mjs";
+import { z } from "zod";
+//#region src/lib/rest/native-rest-client.ts
+var NativeRestClient = class {
+	interceptors;
+	errorHandler;
+	constructor({ config, interceptors = [], errorHandler } = {}) {
+		this.baseURL = config?.baseURL ?? "";
+		this.headers = config?.headers;
+		this.credentials = config?.credentials;
+		this.fetch = config?.fetch ?? globalThis.fetch.bind(globalThis);
+		this.interceptors = [...interceptors];
+		this.errorHandler = errorHandler;
+	}
+	baseURL;
+	headers;
+	credentials;
+	fetch;
+	attachInterceptor(interceptor) {
+		this.interceptors.push(interceptor);
+	}
+	ejectInterceptor(interceptor) {
+		const index = this.interceptors.indexOf(interceptor);
+		if (index >= 0) this.interceptors.splice(index, 1);
+	}
+	get(info, url, config) {
+		return this.request(info, "GET", url, void 0, config);
+	}
+	post(info, url, data, config) {
+		return this.request(info, "POST", url, data, config);
+	}
+	patch(info, url, data, config) {
+		return this.request(info, "PATCH", url, data, config);
+	}
+	put(info, url, data, config) {
+		return this.request(info, "PUT", url, data, config);
+	}
+	delete(info, url, data, config) {
+		return this.request(info, "DELETE", url, data, config);
+	}
+	async upload(url, data, config = {}, method = "put") {
+		if (config.onUploadProgress && typeof XMLHttpRequest !== "undefined") {
+			await this.uploadWithXhr(url, data, config, method);
+			return;
+		}
+		await this.execute({
+			url,
+			method: method.toUpperCase(),
+			body: data,
+			headers: new Headers(config.headers),
+			signal: config.signal
+		}, config, false);
+	}
+	async request(info, method, path, data, config = {}) {
+		const errorStack = (/* @__PURE__ */ new Error()).stack;
+		try {
+			const headers = new Headers(this.headers);
+			new Headers(config.headers).forEach((value, key) => headers.set(key, value));
+			let body;
+			if (data != null) {
+				if (data instanceof FormData || data instanceof Blob || typeof data === "string") body = data;
+				else {
+					body = JSON.stringify(data);
+					if (!headers.has("content-type")) headers.set("content-type", "application/json");
+				}
+			}
+			const request = {
+				url: this.resolveUrl(path, config.params),
+				method,
+				headers,
+				body,
+				signal: config.signal,
+				credentials: config.credentials ?? this.credentials
+			};
+			const response = await this.execute(request, config);
+			const parseResult = info.resSchema.safeParse(response.data);
+			let dataResult;
+			if (parseResult.success) dataResult = parseResult.data;
+			else if (config.allowInvalidResponseData && method === "GET") {
+				parseResult.error.name = "BE Response schema mismatch - ZodError";
+				parseResult.error.stack = [parseResult.error.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+				console.error(parseResult.error);
+				dataResult = response.data;
+			} else throw parseResult.error;
+			return config.rawResponse ? {
+				...response,
+				data: dataResult
+			} : dataResult;
+		} catch (error) {
+			if (error instanceof z.ZodError) error.name = "BE Response schema mismatch - ZodError";
+			const transformed = await this.runErrorInterceptors(error);
+			throw this.errorHandler ? this.errorHandler.rethrowError(transformed) : transformed;
+		}
+	}
+	async execute(request, config = {}, applyInterceptors = true) {
+		let next = request;
+		if (applyInterceptors) for (const interceptor of this.interceptors) next = await interceptor.onRequest?.(next) ?? next;
+		const timeoutController = config.timeout ? new AbortController() : void 0;
+		const timer = timeoutController ? setTimeout(() => timeoutController.abort(), config.timeout) : void 0;
+		if (timeoutController && next.signal) {
+			if (next.signal.aborted) timeoutController.abort(next.signal.reason);
+			else next.signal.addEventListener("abort", () => timeoutController.abort(next.signal?.reason), { once: true });
+		}
+		const signal = timeoutController?.signal ?? next.signal;
+		try {
+			const res = await this.fetch(next.url, {
+				method: next.method,
+				headers: next.headers,
+				body: next.body,
+				signal,
+				credentials: next.credentials
+			});
+			let response = {
+				data: await this.readResponse(res, config.responseType),
+				status: res.status,
+				statusText: res.statusText,
+				headers: res.headers,
+				url: res.url
+			};
+			if (!res.ok) throw new HttpError(`Request failed with status ${res.status}`, response);
+			if (applyInterceptors) for (const interceptor of this.interceptors) response = await interceptor.onResponse?.(response) ?? response;
+			return response;
+		} catch (error) {
+			if (!applyInterceptors) throw error;
+			const context = {
+				request: next,
+				response: error instanceof HttpError ? error.response : void 0,
+				retry: (request = next) => this.execute({
+					...request,
+					retryCount: (next.retryCount ?? 0) + 1
+				}, config, true)
+			};
+			const transformed = await this.runErrorInterceptors(error, context);
+			if (this.isTransportResponse(transformed)) return transformed;
+			throw transformed;
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	async readResponse(response, type) {
+		if (response.status === 204) return void 0;
+		if (type === "blob") return response.blob();
+		if (type === "arrayBuffer") return response.arrayBuffer();
+		if (type === "text") return response.text();
+		const text = await response.text();
+		if (text === "") return void 0;
+		if (!response.headers.get("content-type")?.includes("json")) try {
+			return JSON.parse(text);
+		} catch {
+			return text;
+		}
+		return JSON.parse(text);
+	}
+	resolveUrl(path, params) {
+		const baseURL = this.baseURL && !this.baseURL.endsWith("/") ? `${this.baseURL}/` : this.baseURL;
+		const url = /^https?:\/\//.test(path) ? new URL(path) : new URL(path.replace(/^\//, ""), baseURL || globalThis.location?.origin);
+		for (const [key, value] of Object.entries(params ?? {})) {
+			if (value == null) continue;
+			if (Array.isArray(value)) value.forEach((item) => url.searchParams.append(key, String(item)));
+			else url.searchParams.append(key, String(value));
+		}
+		return url.toString();
+	}
+	async runErrorInterceptors(error, context) {
+		let next = error;
+		if (!context) return next;
+		for (const interceptor of [...this.interceptors].reverse()) if (interceptor.onError) try {
+			next = await interceptor.onError(next, context);
+		} catch (transformed) {
+			next = transformed;
+		}
+		return next;
+	}
+	isTransportResponse(value) {
+		return !!value && typeof value === "object" && "status" in value && "headers" in value && "data" in value;
+	}
+	uploadWithXhr(url, data, config, method) {
+		return new Promise((resolve, reject) => {
+			const xhr = new XMLHttpRequest();
+			xhr.open(method.toUpperCase(), url);
+			new Headers(config.headers).forEach((value, key) => xhr.setRequestHeader(key, value));
+			if (config.timeout) xhr.timeout = config.timeout;
+			xhr.upload.onprogress = ({ loaded, total }) => config.onUploadProgress?.({
+				loaded,
+				total
+			});
+			xhr.onload = () => xhr.status >= 200 && xhr.status < 300 ? resolve() : reject(/* @__PURE__ */ new Error(`Upload failed with status ${xhr.status}`));
+			xhr.onerror = () => reject(/* @__PURE__ */ new TypeError("Network request failed"));
+			xhr.ontimeout = () => reject(new DOMException("Request timed out", "TimeoutError"));
+			config.signal?.addEventListener("abort", () => xhr.abort(), { once: true });
+			xhr.onabort = () => reject(config.signal?.reason ?? new DOMException("Request aborted", "AbortError"));
+			xhr.send(data);
+		});
+	}
+};
+//#endregion
+//#region src/lib/rest/native-rest-interceptor.ts
+var NativeRestInterceptor = class {
+	interceptor;
+	constructor(interceptor) {
+		this.interceptor = interceptor;
+	}
+	onRequest(request) {
+		return this.interceptor.onRequest?.(request) ?? request;
+	}
+	onResponse(response) {
+		return this.interceptor.onResponse?.(response) ?? response;
+	}
+	onError(error, context) {
+		if (!this.interceptor.onError) throw error;
+		return this.interceptor.onError(error, context);
+	}
+};
+//#endregion
+export { NativeRestClient as n, NativeRestInterceptor as t };

package/dist/native.d.mts

@@ -0,0 +1,3 @@
+import { a as RestTransport, d as TransportResponse, f as TransportResult, i as RestResponseType, l as TransportRequest, n as HttpError, o as RestTransportInterceptor, p as UploadProgress, r as RestRequestInfo, t as GeneralTransportErrorCode, u as TransportRequestConfig } from "./rest-transport.types-DM5-qyOJ.mjs";
+import { n as NativeRestInterceptor, r as NativeRestClient, t as NativeInterceptor } from "./native-rest-interceptor-DZxdDcpz.mjs";
+export { type GeneralTransportErrorCode, HttpError, HttpError as NativeHttpError, type NativeInterceptor, type TransportRequest as NativeRequest, type TransportRequest, type TransportRequestConfig as NativeRequestConfig, type TransportRequestConfig, type TransportResponse as NativeResponse, type TransportResponse, NativeRestClient, NativeRestInterceptor, type UploadProgress as NativeUploadProgress, type UploadProgress, type RestRequestInfo, type RestResponseType, type RestTransport, type RestTransportInterceptor, type TransportResult };

package/dist/native.mjs

@@ -0,0 +1,3 @@
+import { t as HttpError } from "./rest-transport.types-DxitRtsB.mjs";
+import { n as NativeRestClient, t as NativeRestInterceptor } from "./native-rest-interceptor-Np4Ov54n.mjs";
+export { HttpError, HttpError as NativeHttpError, NativeRestClient, NativeRestInterceptor };

package/dist/{openapi-codegen.runner-CCXQsUum.mjs → openapi-codegen.runner-G25v_q9z.mjs}

@@ -1,5 +1,4 @@
-import { x as Profiler } from "./generateCodeFromOpenAPIDoc-SYuVswEJ.mjs";
-import { t as runGenerate } from "./generate.runner-B0Zm3pIl.mjs";
+import { Wn as Profiler, n as runGenerate } from "./generate.runner-BuSwqeff.mjs";
 import path from "path";
 //#region src/plugins/openapi-codegen.runner.ts
 function createOpenApiCodegenRunner(config, options = {}) {
@@ -13,6 +12,7 @@ function createOpenApiCodegenRunner(config, options = {}) {
 				formatGeneratedFile,
 				profiler
 			});
+			for (const line of profiler.formatLines()) console.info(`[openapi-codegen] ${line}`);
 			options.onGenerated?.();
 		});
 		queue = run.then(() => void 0, () => void 0);

package/dist/{openapi-source.runner-B6KKrXw7.d.mts → openapi-source.runner-DIOvAX_R.d.mts}

@@ -1,5 +1,4 @@
-import { t as OpenAPICodegenConfig } from "./config-BQqze8rU.mjs";
-
+import { t as OpenAPICodegenConfig } from "./config-CiLFKLAY.mjs";
 //#region src/tiny/openapi.d.ts
 interface GenerateOpenApiFileOptions {
   argv?: readonly string[];
@@ -79,12 +78,7 @@ interface OrpcContractProcedureData {
     successStatus?: number;
   };
 }
-declare function resolveOpenApiOutputPath({
-  argv,
-  cwd,
-  defaultOutput,
-  env
-}: GenerateOpenApiFileOptions): string;
+declare function resolveOpenApiOutputPath({ argv, cwd, defaultOutput, env }: GenerateOpenApiFileOptions): string;
 declare function generateOpenApiFile(options: GenerateTinyOpenApiFileOptions): Promise<GenerateOpenApiFileResult>;
 declare function defineOpenApiSchemas<const TSchemas extends OpenApiSchemaRegistry>(schemas: TSchemas): TSchemas;
 declare function collectExtraSchemas<TModules extends Record<string, {

package/dist/{openapi-source.runner-8kCe-g9S.mjs → openapi-source.runner-DPUNTduQ.mjs}

@@ -19,7 +19,7 @@ const PAGINATION_PROPERTY_NAMES = [
 	"limit",
 	"totalItems"
 ];
-const OPENAPI_31_ONLY_KEYS = new Set([
+const OPENAPI_31_ONLY_KEYS = /* @__PURE__ */ new Set([
 	"$schema",
 	"$id",
 	"$vocabulary",
@@ -314,11 +314,13 @@ function collectContractSchemas(router, routerPath = [], schemas = {}, getSchema
 	if (procedure) {
 		const procedureName = routerPath.map(toPascalCase).join("");
 		const { inputSchema, outputSchema, route } = procedure;
-		if (inputSchema) if (route.inputStructure === "detailed") {
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "params"), procedureSchemaName(procedureName, "Params"), getSchemaName);
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "query"), procedureSchemaName(procedureName, "Query"), getSchemaName);
-			addContractSchema(schemas, getObjectPropertySchema(inputSchema, "body") ?? inputSchema, procedureSchemaName(procedureName, "Request"), getSchemaName);
-		} else addContractSchema(schemas, inputSchema, procedureSchemaName(procedureName, getProcedureInputSchemaRole(route)), getSchemaName);
+		if (inputSchema) {
+			if (route.inputStructure === "detailed") {
+				addContractSchema(schemas, getObjectPropertySchema(inputSchema, "params"), procedureSchemaName(procedureName, "Params"), getSchemaName);
+				addContractSchema(schemas, getObjectPropertySchema(inputSchema, "query"), procedureSchemaName(procedureName, "Query"), getSchemaName);
+				addContractSchema(schemas, getObjectPropertySchema(inputSchema, "body") ?? inputSchema, procedureSchemaName(procedureName, "Request"), getSchemaName);
+			} else addContractSchema(schemas, inputSchema, procedureSchemaName(procedureName, getProcedureInputSchemaRole(route)), getSchemaName);
+		}
 		if (outputSchema && route.successStatus !== 204) addContractSchema(schemas, outputSchema, procedureSchemaName(procedureName, "Response"), getSchemaName, "output");
 		return schemas;
 	}
@@ -585,13 +587,18 @@ function toOpenAPI30Document(spec) {
 	return converted;
 }
 async function generateORPCOpenAPISpec(options) {
-	const [{ OpenAPIGenerator }, { ZodToJsonSchemaConverter }] = await Promise.all([importRuntimeModule("@orpc/openapi"), importRuntimeModule("@orpc/zod/zod4")]);
-	const generator = new OpenAPIGenerator({ schemaConverters: [new ZodToJsonSchemaConverter()] });
-	const explicitSchemaName = options.getOpenApiSchemaName ?? getOpenApiSchemaName;
-	const modelSchemas = await collectModelSchemaExports({
+	const profile = process.env.TINY_OPENAPI_PROFILE === "1";
+	const started = performance.now();
+	const runtimePromise = Promise.all([importRuntimeModule("@orpc/openapi"), importRuntimeModule("@orpc/zod/zod4")]);
+	const modelSchemasPromise = collectModelSchemaExports({
 		apiRoot: options.apiRoot,
 		dbTablesRoot: options.dbTablesRoot
 	});
+	const [[{ OpenAPIGenerator }, { ZodToJsonSchemaConverter }], modelSchemas] = await Promise.all([runtimePromise, modelSchemasPromise]);
+	const generator = new OpenAPIGenerator({ schemaConverters: [new ZodToJsonSchemaConverter()] });
+	const afterRuntime = performance.now();
+	const explicitSchemaName = options.getOpenApiSchemaName ?? getOpenApiSchemaName;
+	const afterModels = performance.now();
 	const getSchemaName = createModelSchemaNameGetter(modelSchemas, explicitSchemaName);
 	const operationMeta = collectOperationMeta(options.contract);
 	const extraSchemas = collectExtraSchemas(options.apiModules);
@@ -607,6 +614,7 @@ async function generateORPCOpenAPISpec(options) {
 		...extraSchemas,
 		...reachableModelSchemas
 	};
+	const afterCollection = performance.now();
 	const spec = await generator.generate(options.contract, {
 		info: options.info ?? {
 			title: "Tiny Template Fake API",
@@ -620,6 +628,7 @@ async function generateORPCOpenAPISpec(options) {
 		...Object.keys(commonSchemas).length > 0 ? { commonSchemas } : {}
 	});
 	const jsonSpec = spec;
+	const afterGeneration = performance.now();
 	const sortableSchemaNames = options.realBackendSortableSchemaNames instanceof Map ? options.realBackendSortableSchemaNames : new Map(Object.entries(options.realBackendSortableSchemaNames ?? {}));
 	applyOperationMeta(jsonSpec, operationMeta, options.apiModules);
 	applyEnumExtensions(spec);
@@ -642,7 +651,12 @@ async function generateORPCOpenAPISpec(options) {
 	}
 	applyRobodevModuleExtensions(jsonSpec, robodevModuleExtensions, options.apiModules);
 	applyRobodevUserRolesExtension(jsonSpec, userRoles);
-	return toOpenAPI30Document(jsonSpec);
+	const output = toOpenAPI30Document(jsonSpec);
+	if (profile) {
+		const finished = performance.now();
+		console.error(`tiny openapi profile runtime=${(afterRuntime - started).toFixed(1)}ms models=${(afterModels - afterRuntime).toFixed(1)}ms collection=${(afterCollection - afterModels).toFixed(1)}ms orpc=${(afterGeneration - afterCollection).toFixed(1)}ms post=${(finished - afterGeneration).toFixed(1)}ms total=${(finished - started).toFixed(1)}ms`);
+	}
+	return output;
 }
 //#endregion
 //#region src/tiny/openapi-source.runner.ts

package/dist/{options-DdQJ9BSc.d.mts → options-X0zju7gw.d.mts}

@@ -1,5 +1,4 @@
 import { OpenAPIV3 } from "openapi-types";
-
 //#region src/generators/types/generate.d.ts
 declare enum GenerateType {
   Models = "models",
@@ -16,9 +15,12 @@ type GenerateFileFormatter = (file: GenerateFileData) => string | Promise<string
 //#endregion
 //#region src/generators/types/options.d.ts
 interface ZodGenerateOptions {
+  /** Eagerly compile non-recursive schemas. Defaults to false to avoid startup work. */
+  compileSchemas?: boolean;
   schemaSuffix: string;
   enumSuffix: string;
   modelsInCommon?: boolean;
+  modelsInModules?: boolean;
   withImplicitRequiredProps?: boolean;
   withDefaultValues?: boolean;
   withDescription?: boolean;
@@ -27,7 +29,9 @@ interface ZodGenerateOptions {
   replaceOptionalWithNullish?: boolean;
 }
 interface EndpointsGenerateOptions {
+  restClient: "axios" | "native";
   restClientImportPath: string;
+  zodImportPath: string;
   errorHandlingImportPath?: string;
   withDeprecatedEndpoints?: boolean;
   removeOperationPrefixEndingWith?: string;
@@ -37,6 +41,7 @@ interface EndpointsGenerateOptions {
 }
 interface QueriesGenerateOptions {
   queryTypesImportPath: string;
+  mutationEffectsImportPath: string;
   axiosRequestConfig?: boolean;
   mutationEffects?: boolean;
   mutationDefaultOnError?: boolean;
@@ -64,6 +69,7 @@ interface ACLGenerateOptions {
   checkAcl?: boolean;
   abilityContextGenericAppAbilities: boolean;
   abilityContextImportPath?: string;
+  aclCheckImportPath: string;
 }
 interface BuilderConfigsGenerateOptions {
   builderConfigs?: boolean;
@@ -88,6 +94,7 @@ interface BaseGenerateOptions {
   excludePathRegex: string;
   excludeRedundantZodSchemas: boolean;
   tsNamespaces: boolean;
+  treeShakeableNamespaces?: boolean;
   tsPath: string;
   importPath: "ts" | "relative" | "absolute";
   configs: Record<GenerateType, GenerateConfig>;

package/dist/query.d.mts

@@ -0,0 +1,3 @@
+import { a as MutationEffectsTypes, i as MutationEffectsOf, n as InvalidationMapFunc, o as OpenApiQueryConfig, r as MergedMutationVariables, s as QueryModule, t as InvalidationMap } from "./queryConfig.context-yl7x_NdW.mjs";
+import { a as AppQueryOptions, i as AppMutationOptions, n as useMutationEffects, r as AppInfiniteQueryOptions, t as MutationEffectsOptions } from "./useMutationEffects-CjGlHDg_.mjs";
+export { type AppInfiniteQueryOptions, type AppMutationOptions, type AppQueryOptions, type InvalidationMap, type InvalidationMapFunc, type MergedMutationVariables, type MutationEffectsOf, type MutationEffectsOptions, type MutationEffectsTypes, OpenApiQueryConfig, type QueryModule, useMutationEffects };

package/dist/query.mjs

@@ -0,0 +1,3 @@
+import { t as OpenApiQueryConfig } from "./queryConfig.context-CldQ5YL9.mjs";
+import { t as useMutationEffects } from "./useMutationEffects-PB1fvKWM.mjs";
+export { OpenApiQueryConfig, useMutationEffects };

package/dist/queryConfig.context-CldQ5YL9.mjs

@@ -0,0 +1,34 @@
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/lib/config/queryConfig.context.tsx
+let OpenApiQueryConfig;
+(function(_OpenApiQueryConfig) {
+	const Context = createContext({});
+	function Provider({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, allowInvalidResponseData, onError, children }) {
+		const value = useMemo(() => ({
+			preferUpdate,
+			invalidateCurrentModule,
+			invalidationMap,
+			crossTabInvalidation,
+			allowInvalidResponseData,
+			onError
+		}), [
+			preferUpdate,
+			invalidateCurrentModule,
+			invalidationMap,
+			crossTabInvalidation,
+			allowInvalidResponseData,
+			onError
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	}
+	_OpenApiQueryConfig.Provider = Provider;
+	_OpenApiQueryConfig.useConfig = () => {
+		return use(Context) ?? {};
+	};
+})(OpenApiQueryConfig || (OpenApiQueryConfig = {}));
+//#endregion
+export { OpenApiQueryConfig as t };

package/dist/queryConfig.context-yl7x_NdW.d.mts

@@ -0,0 +1,48 @@
+import { PropsWithChildren } from "react";
+import { QueryKey, UseMutationResult } from "@tanstack/react-query";
+//#region src/lib/config/queryConfig.context.d.ts
+type QueryModule = string | number | symbol;
+type InvalidationMapFunc<TData = unknown, TVariables = unknown> = {
+  invalidate(data: TData, variables: TVariables): QueryKey[];
+}["invalidate"];
+/** The `data` and `variables` one mutation passes to its module's invalidation callback. */
+interface MutationEffectsTypes {
+  data: unknown;
+  variables: unknown;
+}
+/** `data` and `variables` of mutation hooks, e.g. `MutationEffectsOf<typeof useCreate | typeof useUpdate>`. */
+type MutationEffectsOf<THook> = THook extends ((...args: never) => UseMutationResult<infer TData, infer _TError, infer TVariables, infer _TOnMutateResult>) ? {
+  data: TData;
+  variables: TVariables;
+} : never;
+type ObjectMembers<T> = T extends object ? T : never;
+type KeysOfUnion<T> = T extends unknown ? keyof T : never;
+type ValueOfUnion<T, K extends PropertyKey> = T extends unknown ? (K extends keyof T ? T[K] : undefined) : never;
+type MergedObjects<T> = { [K in keyof T]: ValueOfUnion<T, K>; } & { [K in Exclude<KeysOfUnion<T>, keyof T>]?: ValueOfUnion<T, K>; };
+/**
+ * The variables of a module's mutations as one object: keys some mutations lack become optional.
+ * Mutations without variables (`void`) stay in the union, as their callbacks receive `undefined`.
+ */
+type MergedMutationVariables<T> = [ObjectMembers<T>] extends [never] ? T : MergedObjects<ObjectMembers<T>> | Exclude<T, object>;
+type InvalidationMapFuncFor<T> = InvalidationMapFunc<T extends MutationEffectsTypes ? T["data"] : never, MergedMutationVariables<T extends MutationEffectsTypes ? T["variables"] : never>>;
+/**
+ * Query keys to invalidate after a module's mutations. Pass the generated `QueryModuleMutations` as
+ * `TMutations` to type each module's callback with its mutations' `data` and `variables`.
+ */
+type InvalidationMap<TQueryModule extends QueryModule = QueryModule, TMutations extends { [K in TQueryModule]?: MutationEffectsTypes; } = {}> = { [K in TQueryModule]?: K extends keyof TMutations ? InvalidationMapFuncFor<TMutations[K]> : InvalidationMapFunc; };
+declare namespace OpenApiQueryConfig {
+  export interface Type<TQueryModule extends QueryModule = QueryModule> {
+    preferUpdate?: boolean;
+    invalidateCurrentModule?: boolean;
+    invalidationMap?: InvalidationMap<TQueryModule>;
+    crossTabInvalidation?: boolean;
+    allowInvalidResponseData?: boolean;
+    onError?: (error: unknown) => void;
+  }
+  type ProviderProps<TQueryModule extends QueryModule = QueryModule> = Type<TQueryModule>;
+  export function Provider<TQueryModule extends QueryModule = QueryModule>({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, allowInvalidResponseData, onError, children }: PropsWithChildren<ProviderProps<TQueryModule>>): import("react").JSX.Element;
+  export const useConfig: <TQueryModule extends QueryModule = QueryModule>() => Type<TQueryModule>;
+  export {};
+}
+//#endregion
+export { MutationEffectsTypes as a, MutationEffectsOf as i, InvalidationMapFunc as n, OpenApiQueryConfig as o, MergedMutationVariables as r, QueryModule as s, InvalidationMap as t };

package/dist/rest-client-CbS77dei.d.mts

@@ -0,0 +1,55 @@
+import { a as ErrorHandler, c as GeneralErrorCodes$1, s as ErrorRethrower } from "./error-handling-BpAQHWrU.mjs";
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, CreateAxiosDefaults } from "axios";
+import { z } from "zod";
+//#region src/lib/rest/rest-interceptor.d.ts
+declare class RestInterceptor<T extends unknown[]> {
+  private applyInterceptor;
+  private interceptorIdMap;
+  constructor(applyInterceptor: (client: AxiosInstance, ...args: T) => number);
+  addInterceptor(client: AxiosInstance, ...args: T): void;
+  removeInterceptor(client: AxiosInstance): void;
+}
+//#endregion
+//#region src/lib/rest/rest-client.types.d.ts
+type GeneralErrorCodes = string;
+interface RequestInfo<ZOutput, ECodes extends string> {
+  resSchema: z.ZodType<ZOutput>;
+  errorHandler?: ErrorHandler<ECodes>;
+}
+interface RequestConfig<IsRawRes extends boolean = false> {
+  rawResponse?: IsRawRes;
+  allowInvalidResponseData?: boolean;
+}
+type Response<ZOutput, IsRawRes extends boolean = false> = IsRawRes extends true ? AxiosResponse<ZOutput> : ZOutput;
+interface RestClient$1 {
+  attachInterceptors<T extends unknown[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+  attachInterceptor<T extends unknown[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+  ejectInterceptor<T extends unknown[]>(interceptor: RestInterceptor<T>): void;
+  get<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  post<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  patch<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  put<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  delete<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+}
+//#endregion
+//#region src/lib/rest/rest-client.d.ts
+declare class RestClient implements RestClient$1 {
+  private readonly client;
+  private readonly errorHandler;
+  constructor({ config, interceptors, errorHandler }?: {
+    config?: CreateAxiosDefaults;
+    interceptors?: RestInterceptor<[]>[];
+    errorHandler?: ErrorRethrower;
+  });
+  attachInterceptors<T extends unknown[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+  attachInterceptor<T extends unknown[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+  ejectInterceptor<T extends unknown[]>(interceptor: RestInterceptor<T>): void;
+  get<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  post<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  patch<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  put<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  delete<ZOutput, ECodes extends string = GeneralErrorCodes$1, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: unknown, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+  private makeRequest;
+}
+//#endregion
+export { RestClient$1 as a, Response as i, RequestConfig as n, RestInterceptor as o, RequestInfo as r, RestClient as t };