@qualisero/openapi-endpoint 0.12.3 → 0.14.0

package/dist/openapi-utils.js

@@ -1,27 +1,4 @@
-import { toValue } from 'vue';
-// Known option-like properties to distinguish from path parameters
-const OPTION_PROPERTIES = [
-    'enabled',
-    'onSuccess',
-    'onError',
-    'onSettled',
-    'select',
-    'retry',
-    'staleTime',
-    'cacheTime',
-    'refetchOnWindowFocus',
-    'refetchOnReconnect',
-    'refetchOnMount',
-    'suspense',
-    'useErrorBoundary',
-    'meta',
-    'mutationKey',
-    'mutationFn',
-    'queryKey',
-    'queryFn',
-    'initialData',
-    'context',
-];
+import { computed, toValue } from 'vue';
 // Helper to resolve path parameters in a URL path
 export function resolvePath(path, pathParams) {
     if (pathParams === null || pathParams === undefined)
@@ -31,22 +8,12 @@ export function resolvePath(path, pathParams) {
         return path;
     let resolvedPath = path;
     Object.entries(pathParamsValue).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
+        if (value !== null && value !== undefined) {
             resolvedPath = resolvedPath.replace(`{${key}}`, String(value));
         }
     });
     return resolvedPath;
 }
-function isPathParams(path, pathParams) {
-    if (!pathParams)
-        return false;
-    const paramNames = Object.keys(pathParams);
-    // If any option-like property is present, it's not path params
-    if (paramNames.some((name) => OPTION_PROPERTIES.includes(name))) {
-        return false;
-    }
-    return paramNames.every((paramName) => path.includes(`{${paramName}}`));
-}
 // Helper to check if all required path parameters are provided
 export function isPathResolved(path) {
     return !/{[^}]+}/.test(path);
@@ -55,29 +22,51 @@ export function isPathResolved(path) {
 export function generateQueryKey(resolvedPath) {
     return resolvedPath.split('/').filter((segment) => segment.length > 0);
 }
-export function getParamsOptionsFrom(path, pathParamsOrOptions, optionsOrNull) {
-    let pathParams = undefined;
-    let options = undefined;
-    if (optionsOrNull === undefined) {
-        const pathParamsOrOptionsValue = toValue(pathParamsOrOptions);
-        if ((typeof pathParamsOrOptions === 'object' || typeof pathParamsOrOptions === 'function') &&
-            pathParamsOrOptions !== null &&
-            pathParamsOrOptionsValue &&
-            typeof pathParamsOrOptionsValue === 'object' &&
-            isPathParams(path, pathParamsOrOptionsValue)) {
-            // Called as: useEndpointQuery(operationId, pathParams)
-            pathParams = pathParamsOrOptions;
+/**
+ * Composable for resolving operation paths and parameters.
+ * Consolidates the common pattern of computing resolved paths, query keys, and parameters.
+ *
+ * @param path - The OpenAPI path template (e.g., '/pets/{petId}')
+ * @param pathParams - Reactive path parameters
+ * @param queryParams - Optional reactive query parameters
+ * @param extraPathParams - Optional ref for additional path params (used by mutations)
+ */
+export function useResolvedOperation(path, pathParams, queryParams, extraPathParams) {
+    // Compute all path params (base + extra for mutations)
+    const allPathParams = computed(() => {
+        const base = toValue(pathParams) || {};
+        if (extraPathParams?.value) {
+            return { ...base, ...extraPathParams.value };
         }
-        else {
-            // Called as: useEndpointQuery(operationId, [options])
-            options = pathParamsOrOptions;
+        return base;
+    });
+    // Compute resolved path
+    const resolvedPath = computed(() => resolvePath(path, allPathParams.value));
+    // Compute query params
+    const allQueryParams = computed(() => {
+        const result = toValue(queryParams);
+        return (result || {});
+    });
+    // Generate query key including query params if present
+    const queryKey = computed(() => {
+        const baseKey = generateQueryKey(resolvedPath.value);
+        const qParams = allQueryParams.value;
+        if (qParams && Object.keys(qParams).length > 0) {
+            return [...baseKey, qParams];
         }
-    }
-    else {
-        // Called as: useEndpointQuery(operationId, pathParams, options)
-        pathParams = pathParamsOrOptions;
-        options = optionsOrNull;
-    }
+        return baseKey;
+    });
+    // Check if path is resolved
+    const isResolved = computed(() => isPathResolved(resolvedPath.value));
+    return {
+        pathParams: allPathParams,
+        resolvedPath,
+        queryParams: allQueryParams,
+        queryKey: queryKey,
+        isResolved,
+    };
+}
+export function normalizeParamsOptions(pathParams, options) {
     return {
         pathParams: pathParams ?? {},
         options: options ?? {},