@qualisero/openapi-endpoint 0.13.2 → 0.15.0

package/dist/openapi-mutation.js

@@ -1,64 +1,43 @@
 import { computed, ref } from 'vue';
 import { useMutation } from '@tanstack/vue-query';
-import { HttpMethod, } from './types.js';
+import { HttpMethod, isMutationMethod, } from './types.js';
 import { isPathResolved, normalizeParamsOptions, useResolvedOperation, resolvePath, generateQueryKey, } from './openapi-utils.js';
 /**
- * Execute a type-safe mutation (POST/PUT/PATCH/DELETE) with automatic cache updates.
+ * Execute a type-safe mutation (POST/PUT/PATCH/DELETE) with automatic cache management.
  *
- * Ensures the operation is a mutation at runtime and returns a reactive mutation object
- * with helpers for path resolution and cache invalidation.
+ * This is a low-level primitive — in normal usage it is called by the generated
+ * per-operation `useMutation` wrappers in `api-client.ts`, not directly.
  *
- * NOTE: By default, the mutation updates cache for PUT/PATCH and invalidates matching
- * GET queries for the same path.
+ * @template TResponse    The response data type
+ * @template TPathParams  The path parameters type (concrete, required values)
+ * @template TRequest     The request body type (`never` if no body)
+ * @template TQueryParams The query parameters type
  *
- * @template Ops - The operations type from your OpenAPI specification
- * @template Op - The operation key from your operations type
- * @param operationId - The OpenAPI operation ID to mutate
- * @param h - OpenAPI helpers (internal), provided by useOpenApi
- * @param pathParams - Path parameters (can be reactive). Omit for operations without path params.
- * @param options - Mutation options (dontInvalidate, refetchEndpoints, etc.)
- *   - `dontUpdateCache`: Skip cache update for PUT/PATCH responses
- *   - `dontInvalidate`: Skip invalidating matching queries
- *   - `invalidateOperations`: Additional operation IDs to invalidate (array or map of params)
- *   - `refetchEndpoints`: Additional query results to refetch
- *   - `queryParams`: Query string parameters (operation-specific)
- *   - `axiosOptions`: Custom axios request options (headers, params, etc.)
- *   - Plus all {@link UseMutationOptions} from @tanstack/vue-query
- * @throws Error if the operation is not a mutation operation
- * @returns Mutation object with
- *   - `mutate(vars)` / `mutateAsync(vars)` to trigger the mutation
- *   - `data`: ComputedRef of Axios response data
- *   - `isEnabled`: ComputedRef indicating if mutation can execute (path resolved)
- *   - `extraPathParams`: Ref to set additional path params at call time
- *   - `pathParams`: Resolved path params as a computed ref
+ * @param config      Endpoint config: axios instance, queryClient, path, method, listPath, operationsRegistry
+ * @param pathParams  Path parameters (reactive). Pass `undefined` for operations without path params.
+ * @param options     Mutation options (dontInvalidate, refetchEndpoints, etc.)
  */
-export function useEndpointMutation(operationId, h, // helpers
-pathParams, options) {
-    // Runtime check to ensure this is actually a mutation operation
-    if (!h.isMutationOperation(operationId)) {
-        const { method } = h.getOperationInfo(operationId);
-        throw new Error(`Operation '${String(operationId)}' uses method ${method} and cannot be used with useMutation(). ` +
+export function useEndpointMutation(config, pathParams, options) {
+    if (!isMutationMethod(config.method)) {
+        throw new Error(`Operation at '${config.path}' uses method ${config.method} and cannot be used with useMutation(). ` +
             `Use useQuery() for GET/HEAD/OPTIONS operations.`);
     }
-    const { path, method } = h.getOperationInfo(operationId);
     const { pathParams: resolvedPathParamsInput, options: resolvedOptions } = normalizeParamsOptions(pathParams, options);
     const { axiosOptions, dontInvalidate, dontUpdateCache, invalidateOperations, refetchEndpoints, queryParams, ...useMutationOptions } = resolvedOptions;
     const extraPathParams = ref({});
-    // Use the consolidated operation resolver with extraPathParams support
-    const { resolvedPath, queryKey, queryParams: resolvedQueryParams, pathParams: allPathParams, } = useResolvedOperation(path, resolvedPathParamsInput, queryParams, extraPathParams);
+    const { resolvedPath, queryKey, queryParams: resolvedQueryParams, pathParams: allPathParams, } = useResolvedOperation(config.path, resolvedPathParamsInput, queryParams, extraPathParams);
     const mutation = useMutation({
         mutationFn: async (vars) => {
-            const { data, pathParams: pathParamsFromMutate, axiosOptions: axiosOptionsFromMutate, queryParams: queryParamsFromMutate, } = vars;
-            extraPathParams.value = pathParamsFromMutate || {};
-            // TODO: use typing to ensure all required path params are provided
+            const { pathParams: pathParamsFromMutate, axiosOptions: axiosOptionsFromMutate, queryParams: queryParamsFromMutate, } = (vars || {});
+            const data = vars?.data;
+            extraPathParams.value = (pathParamsFromMutate || {});
             if (!isPathResolved(resolvedPath.value)) {
-                return Promise.reject(new Error(`Cannot execute mutation '${String(operationId)}': path parameters not resolved. ` +
+                return Promise.reject(new Error(`Cannot execute mutation at '${config.path}': path parameters not resolved. ` +
                     `Path: '${resolvedPath.value}', provided params: ${JSON.stringify(allPathParams.value)}`));
             }
-            // Cancel any ongoing queries for this path (prevent race conditions with refresh)
-            await h.queryClient.cancelQueries({ queryKey: queryKey.value, exact: false });
-            return h.axios({
-                method: method.toLowerCase(),
+            await config.queryClient.cancelQueries({ queryKey: queryKey.value, exact: false });
+            return config.axios({
+                method: config.method.toLowerCase(),
                 url: resolvedPath.value,
                 ...(data !== undefined && { data }),
                 ...axiosOptions,
@@ -70,43 +49,34 @@ pathParams, options) {
                 },
             });
         },
-        onSuccess: async (response, vars, _context) => {
+        onSuccess: async (response, vars) => {
             const data = response.data;
-            const { dontInvalidate: dontInvalidateMutate, dontUpdateCache: dontUpdateCacheMutate, invalidateOperations: invalidateOperationsMutate, refetchEndpoints: refetchEndpointsMutate, } = vars || {};
-            // update cache with returned data for PUT/PATCH requests
-            if (
-            // dontUpdateCacheMutate supersedes dontUpdateCache from options
-            (dontUpdateCacheMutate !== undefined ? !dontUpdateCacheMutate : !dontUpdateCache) &&
+            const { dontInvalidate: dontInvalidateMutate, dontUpdateCache: dontUpdateCacheMutate, invalidateOperations: invalidateOperationsMutate, refetchEndpoints: refetchEndpointsMutate, } = (vars || {});
+            // Update cache for PUT/PATCH
+            if ((dontUpdateCacheMutate !== undefined ? !dontUpdateCacheMutate : !dontUpdateCache) &&
                 data &&
-                [HttpMethod.PUT, HttpMethod.PATCH].includes(method)) {
-                await h.queryClient.setQueryData(queryKey.value, data);
+                [HttpMethod.PUT, HttpMethod.PATCH].includes(config.method)) {
+                await config.queryClient.setQueryData(queryKey.value, data);
             }
-            // Invalidate queries for this path, and any additional specified operations
+            // Invalidate queries for this path
             if (dontInvalidateMutate !== undefined ? !dontInvalidateMutate : !dontInvalidate) {
-                // Invalidate all queries for this path (exact for POST, prefix for others):
-                await h.queryClient.invalidateQueries({ queryKey: queryKey.value, exact: method !== HttpMethod.POST });
-                const listPath = h.getListOperationPath(operationId);
-                if (listPath) {
-                    const listResolvedPath = resolvePath(listPath, resolvedPathParamsInput);
+                await config.queryClient.invalidateQueries({
+                    queryKey: queryKey.value,
+                    exact: config.method !== HttpMethod.POST,
+                });
+                // Invalidate associated list path
+                if (config.listPath) {
+                    const listResolvedPath = resolvePath(config.listPath, resolvedPathParamsInput);
                     if (isPathResolved(listResolvedPath)) {
                         const listQueryKey = generateQueryKey(listResolvedPath);
-                        // Invalidate list queries by comparing normalized query keys.
-                        // For queries with query parameters (objects), strip the last element before comparing.
-                        // This matches:
-                        //   - List queries without params: ["api", "user"]
-                        //   - List queries with params: ["api", "user", {filter}] → normalized to ["api", "user"]
-                        // But NOT single-item queries where last element is a primitive:
-                        //   - Single-item: ["api", "user", "uuid"] → kept as ["api", "user", "uuid"]
-                        await h.queryClient.invalidateQueries({
+                        await config.queryClient.invalidateQueries({
                             predicate: (query) => {
                                 const qKey = query.queryKey;
                                 if (!qKey || qKey.length === 0)
                                     return false;
-                                // Normalize query key: strip last element if it's an object (query params)
                                 const normalizedKey = typeof qKey[qKey.length - 1] === 'object' && qKey[qKey.length - 1] !== null
                                     ? qKey.slice(0, -1)
                                     : qKey;
-                                // Compare with listQueryKey
                                 if (normalizedKey.length !== listQueryKey.length)
                                     return false;
                                 for (let i = 0; i < listQueryKey.length; i++) {
@@ -119,47 +89,61 @@ pathParams, options) {
                     }
                 }
             }
+            // Resolve invalidateOperations entries using the registry
+            const registry = config.operationsRegistry || {};
+            const allInvalidateOps = [invalidateOperations, invalidateOperationsMutate].filter(Boolean);
             const operationsWithPathParams = [];
-            Array.from([invalidateOperations, invalidateOperationsMutate]).forEach((ops) => {
-                operationsWithPathParams.push(...(typeof ops === 'object' && !Array.isArray(ops)
-                    ? Object.entries(ops)
-                    : ops?.map((opId) => [opId, {}]) || []));
-            });
+            for (const ops of allInvalidateOps) {
+                if (!ops)
+                    continue;
+                if (Array.isArray(ops)) {
+                    operationsWithPathParams.push(...ops.map((id) => [id, {}]));
+                }
+                else {
+                    operationsWithPathParams.push(...Object.entries(ops).map(([id, params]) => [id, params]));
+                }
+            }
             if (operationsWithPathParams.length > 0) {
                 const promises = operationsWithPathParams.map(([opId, opParams]) => {
-                    const opInfo = h.getOperationInfo(opId);
+                    const opInfo = registry[opId];
+                    if (!opInfo) {
+                        console.warn(`Cannot invalidate operation '${opId}': not found in operations registry`);
+                        return Promise.resolve();
+                    }
                     const opPath = resolvePath(opInfo.path, {
                         ...allPathParams.value,
                         ...opParams,
                     });
                     if (isPathResolved(opPath)) {
                         const opQueryKey = generateQueryKey(opPath);
-                        return h.queryClient.invalidateQueries({ queryKey: opQueryKey, exact: true });
+                        return config.queryClient.invalidateQueries({ queryKey: opQueryKey, exact: true });
                     }
                     else {
-                        console.warn(`Cannot invalidate operation '${String(opId)}', path not resolved: ${opPath} (params: ${JSON.stringify({ ...allPathParams.value, ...opParams })})`);
-                        return Promise.reject();
+                        console.warn(`Cannot invalidate operation '${opId}', path not resolved: ${opPath}`);
+                        return Promise.resolve();
                     }
                 });
                 await Promise.all(promises);
             }
-            if (refetchEndpoints && refetchEndpoints.length > 0) {
-                await Promise.all(refetchEndpoints.map((endpoint) => endpoint.refetch()));
-            }
-            if (refetchEndpointsMutate && refetchEndpointsMutate.length > 0) {
-                await Promise.all(refetchEndpointsMutate.map((endpoint) => endpoint.refetch()));
+            const allRefetch = [
+                ...(refetchEndpoints || []),
+                ...(vars?.refetchEndpoints || []),
+                ...(refetchEndpointsMutate || []),
+            ];
+            if (allRefetch.length > 0) {
+                await Promise.all(allRefetch.map((ep) => ep.refetch()));
             }
         },
         onSettled: () => {
             extraPathParams.value = {};
         },
         ...useMutationOptions,
-    }, h.queryClient);
+    }, config.queryClient);
     return {
         ...mutation,
         data: mutation.data,
         isEnabled: computed(() => isPathResolved(resolvedPath.value)),
-        extraPathParams,
+        extraPathParams: extraPathParams,
         pathParams: allPathParams,
     };
 }

package/dist/openapi-query.d.ts

@@ -1,40 +1,22 @@
-import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
-import { Operations, type ApiPathParams, type ApiPathParamsInput, type ApiResponse, type QQueryOptions } from './types';
-import { type OpenApiHelpers } from './openapi-helpers';
+import { type ComputedRef, type Ref } from 'vue';
+import type { MaybeRefOrGetter } from '@vue/reactivity';
+import { type EndpointConfig, type QueryOptions } from './types';
 /**
- * Return type of `useQuery` (created via `useOpenApi`).
+ * Return type of `useEndpointQuery` (the `useQuery` composable on a generated namespace).
  *
- * Reactive query result with automatic caching, error handling, and helpers.
- *
- * All properties are reactive (ComputedRef) and auto-unwrap in Vue templates.
- *
- * @template Ops - The operations type from your OpenAPI specification
- * @template Op - The operation key from your operations type
- *
- * @example
- * ```typescript
- * const query = api.useQuery('listPets', { queryParams: { limit: 10 } })
- *
- * // Reactive properties
- * if (query.isPending.value) console.log('Loading...')
- * if (query.isError.value) console.log('Error:', query.error.value)
- * if (query.isSuccess.value) console.log('Data:', query.data.value)
- *
- * // Helpers
- * query.refetch()  // Manual refetch
- * query.onLoad((data) => console.log('First load:', data))
- * ```
+ * @template TResponse   Response data type
+ * @template TPathParams Path parameters type (concrete, no undefined)
  *
  * @group Types
  */
-export interface EndpointQueryReturn<Ops extends Operations<Ops>, Op extends keyof Ops> {
+export interface QueryReturn<TResponse, TPathParams extends Record<string, unknown> = Record<string, never>> {
     /** The response data (undefined until loaded). */
-    data: ComputedRef<ApiResponse<Ops, Op> | undefined>;
+    data: ComputedRef<TResponse | undefined>;
     /** The error if the query failed. */
     error: Ref<Error | null>;
     /** True while the query is loading. */
     isPending: Ref<boolean>;
-    /** True while loading (same as isPending, for compatibility). */
+    /** True while loading (alias for isPending). */
     isLoading: Ref<boolean>;
     /** True when the query succeeded. */
     isSuccess: Ref<boolean>;
@@ -44,36 +26,26 @@ export interface EndpointQueryReturn<Ops extends Operations<Ops>, Op extends key
     refetch: () => Promise<void>;
     /** Whether the query is currently enabled. */
     isEnabled: ComputedRef<boolean>;
-    /** The resolved query key for manual cache access. */
+    /** The resolved query key. */
     queryKey: ComputedRef<string[] | (string | unknown)[]>;
     /** The resolved path parameters. */
-    pathParams: ComputedRef<ApiPathParams<Ops, Op>>;
+    pathParams: ComputedRef<TPathParams>;
     /** Register a callback for when data loads successfully for the first time. */
-    onLoad: (callback: (data: ApiResponse<Ops, Op>) => void) => void;
+    onLoad: (callback: (data: TResponse) => void) => void;
 }
 /**
  * Execute a type-safe query (GET/HEAD/OPTIONS) with automatic caching.
  *
- * Ensures the operation is a query at runtime and returns a reactive query object,
- * including helpers for query key, enabled state, and an `onLoad` callback.
+ * This is a low-level primitive — in normal usage it is called by the generated
+ * per-operation `useQuery` wrappers in `api-client.ts`, not directly.
+ *
+ * @template TResponse    The response data type
+ * @template TPathParams  The path parameters type (concrete, required values)
+ * @template TQueryParams The query parameters type
  *
- * @template Ops - The operations type from your OpenAPI specification
- * @template Op - The operation key from your operations type
- * @param operationId - The OpenAPI operation ID to query
- * @param h - OpenAPI helpers (internal), provided by useOpenApi
- * @param pathParams - Path parameters (can be reactive). Omit for operations without path params.
- * @param options - Query options (enabled, staleTime, queryParams, etc.)
- *   - `enabled`: Whether the query should auto-run (boolean or reactive)
- *   - `queryParams`: Query string parameters (operation-specific)
- *   - `onLoad`: Callback invoked once when data is loaded
- *   - `axiosOptions`: Custom axios request options (headers, params, etc.)
- *   - Plus all {@link UseQueryOptions} from @tanstack/vue-query
- * @throws Error if the operation is not a query operation
- * @returns Query object with strict typing and helpers:
- *   - `data`: ComputedRef of response data
- *   - `isEnabled`: ComputedRef indicating if query is enabled
- *   - `queryKey`: ComputedRef of the query key
- *   - `onLoad(callback)`: Register a callback for when data is loaded
+ * @param config      Endpoint config: axios instance, queryClient, path, method, listPath
+ * @param pathParams  Path parameters (reactive). Pass `undefined` for operations without path params.
+ * @param options     Query options (enabled, staleTime, queryParams, onLoad, etc.)
  */
-export declare function useEndpointQuery<Ops extends Operations<Ops>, Op extends keyof Ops>(operationId: Op, h: OpenApiHelpers<Ops, Op>, pathParams?: MaybeRefOrGetter<ApiPathParamsInput<Ops, Op> | null | undefined>, options?: QQueryOptions<Ops, Op>): EndpointQueryReturn<Ops, Op>;
+export declare function useEndpointQuery<TResponse, TPathParams extends Record<string, unknown> = Record<string, never>, TQueryParams extends Record<string, unknown> = Record<string, never>>(config: EndpointConfig, pathParams?: MaybeRefOrGetter<Record<string, string | number | undefined> | null | undefined>, options?: QueryOptions<TResponse, TQueryParams>): QueryReturn<TResponse, TPathParams>;
 //# sourceMappingURL=openapi-query.d.ts.map

package/dist/openapi-query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi-query.d.ts","sourceRoot":"","sources":["../src/openapi-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAEjG,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvH,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,mBAAmB,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG;IACpF,kDAAkD;IAClD,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,CAAA;IAEnD,qCAAqC;IACrC,KAAK,EAAE,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;IAExB,uCAAuC;IACvC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAEvB,iEAAiE;IACjE,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAEvB,qCAAqC;IACrC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAEvB,kCAAkC;IAClC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAErB,kCAAkC;IAClC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5B,8CAA8C;IAC9C,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAE/B,sDAAsD;IACtD,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAAA;IAEtD,oCAAoC;IACpC,UAAU,EAAE,WAAW,CAAC,aAAa,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAA;IAE/C,+EAA+E;IAC/E,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,CAAA;CACjE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,EAChF,WAAW,EAAE,EAAE,EACf,CAAC,EAAE,cAAc,CAAC,GAAG,EAAE,EAAE,CAAC,EAC1B,UAAU,CAAC,EAAE,gBAAgB,CAAC,kBAAkB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAC7E,OAAO,CAAC,EAAE,aAAa,CAAC,GAAG,EAAE,EAAE,CAAC,GA+HhB,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,CAC7C"}
+{"version":3,"file":"openapi-query.d.ts","sourceRoot":"","sources":["../src/openapi-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAIvD,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAiB,MAAM,SAAS,CAAA;AAG/E;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW,CAAC,SAAS,EAAE,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IACzG,kDAAkD;IAClD,IAAI,EAAE,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;IACxC,qCAAqC;IACrC,KAAK,EAAE,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;IACxB,uCAAuC;IACvC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACvB,gDAAgD;IAChD,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACvB,qCAAqC;IACrC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACvB,kCAAkC;IAClC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACrB,kCAAkC;IAClC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5B,8CAA8C;IAC9C,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC/B,8BAA8B;IAC9B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAAA;IACtD,oCAAoC;IACpC,UAAU,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;IACpC,+EAA+E;IAC/E,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,KAAK,IAAI,CAAA;CACtD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EACT,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACnE,YAAY,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEpE,MAAM,EAAE,cAAc,EACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAC7F,OAAO,CAAC,EAAE,YAAY,CAAC,SAAS,EAAE,YAAY,CAAC,GAC9C,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,CAuGrC"}

package/dist/openapi-query.js

@@ -1,44 +1,30 @@
 import { computed, watch, toValue } from 'vue';
 import { useQuery } from '@tanstack/vue-query';
-import { normalizeParamsOptions, useResolvedOperation } from './openapi-utils.js';
 import { isAxiosError } from 'axios';
+import { isQueryMethod } from './types.js';
+import { normalizeParamsOptions, useResolvedOperation } from './openapi-utils.js';
 /**
  * Execute a type-safe query (GET/HEAD/OPTIONS) with automatic caching.
  *
- * Ensures the operation is a query at runtime and returns a reactive query object,
- * including helpers for query key, enabled state, and an `onLoad` callback.
+ * This is a low-level primitive — in normal usage it is called by the generated
+ * per-operation `useQuery` wrappers in `api-client.ts`, not directly.
+ *
+ * @template TResponse    The response data type
+ * @template TPathParams  The path parameters type (concrete, required values)
+ * @template TQueryParams The query parameters type
  *
- * @template Ops - The operations type from your OpenAPI specification
- * @template Op - The operation key from your operations type
- * @param operationId - The OpenAPI operation ID to query
- * @param h - OpenAPI helpers (internal), provided by useOpenApi
- * @param pathParams - Path parameters (can be reactive). Omit for operations without path params.
- * @param options - Query options (enabled, staleTime, queryParams, etc.)
- *   - `enabled`: Whether the query should auto-run (boolean or reactive)
- *   - `queryParams`: Query string parameters (operation-specific)
- *   - `onLoad`: Callback invoked once when data is loaded
- *   - `axiosOptions`: Custom axios request options (headers, params, etc.)
- *   - Plus all {@link UseQueryOptions} from @tanstack/vue-query
- * @throws Error if the operation is not a query operation
- * @returns Query object with strict typing and helpers:
- *   - `data`: ComputedRef of response data
- *   - `isEnabled`: ComputedRef indicating if query is enabled
- *   - `queryKey`: ComputedRef of the query key
- *   - `onLoad(callback)`: Register a callback for when data is loaded
+ * @param config      Endpoint config: axios instance, queryClient, path, method, listPath
+ * @param pathParams  Path parameters (reactive). Pass `undefined` for operations without path params.
+ * @param options     Query options (enabled, staleTime, queryParams, onLoad, etc.)
  */
-export function useEndpointQuery(operationId, h, pathParams, options) {
-    // Runtime check to ensure this is actually a query operation
-    if (!h.isQueryOperation(operationId)) {
-        const { method } = h.getOperationInfo(operationId);
-        throw new Error(`Operation '${String(operationId)}' uses method ${method} and cannot be used with useQuery(). ` +
+export function useEndpointQuery(config, pathParams, options) {
+    if (!isQueryMethod(config.method)) {
+        throw new Error(`Operation at '${config.path}' uses method ${config.method} and cannot be used with useQuery(). ` +
             `Use useMutation() for POST/PUT/PATCH/DELETE operations.`);
     }
-    const { path, method } = h.getOperationInfo(operationId);
     const { pathParams: resolvedPathParamsInput, options: resolvedOptions } = normalizeParamsOptions(pathParams, options);
     const { enabled: enabledInit, onLoad: onLoadInit, axiosOptions, errorHandler, queryParams, ...useQueryOptions } = resolvedOptions;
-    // Use the consolidated operation resolver
-    const { resolvedPath, queryKey, isResolved, queryParams: resolvedQueryParams, pathParams: resolvedPathParams, } = useResolvedOperation(path, resolvedPathParamsInput, queryParams);
-    // Check if path is fully resolved for enabling the query
+    const { resolvedPath, queryKey, isResolved, queryParams: resolvedQueryParams, pathParams: resolvedPathParams, } = useResolvedOperation(config.path, resolvedPathParamsInput, queryParams);
     const isEnabled = computed(() => {
         const baseEnabled = enabledInit !== undefined ? toValue(enabledInit) : true;
         return baseEnabled && isResolved.value;
@@ -47,8 +33,8 @@ export function useEndpointQuery(operationId, h, pathParams, options) {
         queryKey: queryKey,
         queryFn: async () => {
             try {
-                const response = await h.axios({
-                    method: method.toLowerCase(),
+                const response = await config.axios({
+                    method: config.method.toLowerCase(),
                     url: resolvedPath.value,
                     ...axiosOptions,
                     params: {
@@ -61,67 +47,48 @@ export function useEndpointQuery(operationId, h, pathParams, options) {
             catch (error) {
                 if (errorHandler && isAxiosError(error)) {
                     const result = await errorHandler(error);
-                    if (result !== undefined) {
+                    if (result !== undefined)
                         return result;
-                    }
-                    // If errorHandler returns undefined and doesn't throw,
-                    // we consider this a "recovered" state and return undefined
-                    // TanStack Query will handle this as a successful query with no data
                     return undefined;
                 }
-                else {
-                    throw error;
-                }
+                throw error;
             }
         },
         enabled: isEnabled,
         staleTime: 1000 * 60,
         retry: (_failureCount, error) => {
-            // Don't retry 4xx errors if error is AxiosError
             if (isAxiosError(error) && error.response && error.response.status >= 400 && error.response.status < 500) {
                 return false;
             }
-            // Retry up to 3 times for other errors
             return _failureCount < 3;
         },
         ...useQueryOptions,
     };
-    const query = useQuery(queryOptions, h.queryClient);
-    // onLoad callback management using a Set for efficient tracking
+    const query = useQuery(queryOptions, config.queryClient);
     const onLoadCallbacks = new Set();
-    // Add initial callback from options if provided
-    if (onLoadInit) {
+    if (onLoadInit)
         onLoadCallbacks.add(onLoadInit);
-    }
-    // Single watch instance to handle all callbacks - stop after first successful data
     if (query.data.value !== undefined) {
-        // Data already available - call all callbacks immediately
         onLoadCallbacks.forEach((cb) => cb(query.data.value));
         onLoadCallbacks.clear();
     }
     else {
-        // Watch for data to become available - stop after first successful load
         const stopWatch = watch(query.data, (newData) => {
             if (newData !== undefined && onLoadCallbacks.size > 0) {
-                // Call all pending callbacks
                 onLoadCallbacks.forEach((cb) => cb(newData));
                 onLoadCallbacks.clear();
-                stopWatch(); // Stop watching after first successful load
+                stopWatch();
             }
         });
     }
-    // Public onLoad method to register additional callbacks
     const onLoad = (callback) => {
         if (query.data.value !== undefined) {
-            // Data already available - call immediately
             callback(query.data.value);
         }
         else {
-            // Add to pending callbacks
             onLoadCallbacks.add(callback);
         }
     };
-    // Return object spread with data wrapped as ComputedRef for Vue template unwrapping
     return {
         ...query,
         data: computed(() => query.data.value),

package/dist/openapi-utils.d.ts

@@ -1,4 +1,5 @@
-import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import { type ComputedRef } from 'vue';
+import type { MaybeRefOrGetter } from '@vue/reactivity';
 export declare function resolvePath(path: string, pathParams?: MaybeRefOrGetter<Record<string, string | number | undefined> | null | undefined>): string;
 export declare function isPathResolved(path: string): boolean;
 export declare function generateQueryKey(resolvedPath: string): string[];

package/dist/openapi-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi-utils.d.ts","sourceRoot":"","sources":["../src/openapi-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAGhF,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAC5F,MAAM,CAaR;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAGD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAE/D;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,UAAU,EAAE,WAAW;IACxD,+DAA+D;IAC/D,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,CAAA;IACnC,yDAAyD;IACzD,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACjC,gEAAgE;IAChE,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;IACrC,4CAA4C;IAC5C,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IAC1D,+DAA+D;IAC/D,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACtF,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEnE,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAC3D,WAAW,CAAC,EAAE,gBAAgB,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAC9D,eAAe,CAAC,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;CAAE,GAC/C,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC,CAuC5C;AAED,wBAAgB,sBAAsB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EACxF,UAAU,CAAC,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAC5D,OAAO,CAAC,EAAE,OAAO,GAChB;IACD,UAAU,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;IAC3D,OAAO,EAAE,OAAO,CAAA;CACjB,CAKA"}
+{"version":3,"file":"openapi-utils.d.ts","sourceRoot":"","sources":["../src/openapi-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,KAAK,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAGvD,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAC5F,MAAM,CAaR;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAGD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAE/D;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,UAAU,EAAE,WAAW;IACxD,+DAA+D;IAC/D,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,CAAA;IACnC,yDAAyD;IACzD,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACjC,gEAAgE;IAChE,WAAW,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;IACrC,4CAA4C;IAC5C,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IAC1D,+DAA+D;IAC/D,UAAU,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACtF,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAEnE,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAC3D,WAAW,CAAC,EAAE,gBAAgB,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAC9D,eAAe,CAAC,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;CAAE,GAC/C,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC,CAuC5C;AAED,wBAAgB,sBAAsB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EACxF,UAAU,CAAC,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,EAC5D,OAAO,CAAC,EAAE,OAAO,GAChB;IACD,UAAU,EAAE,gBAAgB,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;IAC3D,OAAO,EAAE,OAAO,CAAA;CACjB,CAKA"}