@qualisero/openapi-endpoint 0.12.1 → 0.13.2

package/dist/index.d.ts

@@ -1,28 +1,21 @@
-import type { MaybeRefOrGetter } from 'vue';
-import { EndpointQueryReturn } from './openapi-query';
-import { EndpointMutationReturn } from './openapi-mutation';
-import { Operations, GetPathParameters, OpenApiConfig, QQueryOptions, QMutationOptions, IsQueryOperation } from './types';
-export type { OpenApiConfig, OpenApiInstance, GetResponseData, QueryClientLike, GetQueryParameters } from './types';
-export { queryClient } from './openapi-helpers';
-/** @internal */
-export { type EndpointQueryReturn, useEndpointQuery } from './openapi-query';
-/** @internal */
-export { type EndpointMutationReturn, useEndpointMutation } from './openapi-mutation';
+import { Operations, OpenApiConfig, OpenApiInstance } from './types';
+export type { OpenApiConfig, OpenApiInstance, ApiResponse, ApiResponseSafe, ApiRequest, ApiPathParams, ApiPathParamsInput, ApiQueryParams, QueryClientLike, QQueryOptions, QMutationOptions, QMutationVars, CacheInvalidationOptions, EndpointQueryReturn, EndpointMutationReturn, RequiresPathParameters, HasExcessPathParams, NoPathParams, WithPathParams, QueryOpsNoPathParams, QueryOpsWithPathParams, MutationOpsNoPathParams, MutationOpsWithPathParams, AxiosRequestConfigExtended, ReactiveOr, ReactiveValue, MutateFn, MutateAsyncFn, MutateAsyncReturn, } from './types';
+export { validateMutationParams } from './types';
 /**
- * Creates a type-safe OpenAPI client for Vue applications.
+ * Create a type-safe OpenAPI client with Vue Query integration.
  *
  * This is the main entry point for the library. It provides reactive composables
  * for API operations with full TypeScript type safety based on your OpenAPI specification.
  *
+ * @group Setup
  * @template Ops - The operations type, typically generated from your OpenAPI spec
  * @param config - Configuration object containing operations metadata and axios instance
- * @returns {OpenApiInstance<Ops>} API instance with useQuery, useMutation, useEndpoint, and debug methods
+ * @returns {OpenApiInstance<Ops>} API instance with useQuery, useMutation, and debug methods
  *
  * @example
  * ```typescript
  * import { useOpenApi } from '@qualisero/openapi-endpoint'
- * // See documentation on how to generate types and operations automatically:
- * import { openApiOperations, type OpenApiOperations } from './generated/api-operations'
+ * import { openApiOperations, type OpenApiOperations, QueryOperationId, MutationOperationId } from './generated/api-operations'
  * import axios from 'axios'
  *
  * const api = useOpenApi<OpenApiOperations>({
@@ -30,183 +23,15 @@ export { type EndpointMutationReturn, useEndpointMutation } from './openapi-muta
  *   axios: axios.create({ baseURL: 'https://api.example.com' })
  * })
  *
- * // Use in components
- * const { data, isLoading } = api.useQuery('listPets', {})
- * const createPet = api.useMutation('createPet', {})
+ * // Queries
+ * const listQuery = api.useQuery(QueryOperationId.listPets, {
+ *   queryParams: { limit: 10 }
+ * })
+ *
+ * // Mutations
+ * const createPet = api.useMutation(MutationOperationId.createPet)
+ * createPet.mutate({ data: { name: 'Fluffy' } })
  * ```
  */
-export declare function useOpenApi<Ops extends Operations<Ops>>(config: OpenApiConfig<Ops>): {
-    /**
-     * Debug utility to inspect operation metadata.
-     *
-     * @param operationId - The operation ID to debug
-     * @returns Information about whether the operation is a query operation
-     */
-    _debugIsQueryOperation: <Op extends keyof Ops>(operationId: Op) => IsQueryOperation<Ops, Op>;
-    /**
-     * Creates a reactive query for GET operations.
-     *
-     * This composable wraps TanStack Query for read-only operations with automatic
-     * type inference, caching, and reactive updates.
-     *
-     * @template Op - The operation key from your operations type
-     * @param operationId - Operation ID (must be a GET operation)
-     * @param pathParamsOrOptions - Path parameters or query options
-     * @param optionsOrNull - Additional query options when path params are provided
-     * @returns Reactive query result with data, loading state, error handling, etc.
-     *
-     * @example
-     * ```typescript
-     * // Query without path parameters
-     * const { data: pets, isLoading } = api.useQuery(OperationId.listPets, {
-     *   enabled: true,
-     *   onLoad: (data) => console.log('Loaded:', data)
-     * })
-     *
-     * // Query with path parameters
-     * const { data: pet } = api.useQuery(OperationId.getPet, { petId: '123' }, {
-     *   enabled: computed(() => Boolean(petId.value))
-     * })
-     * ```
-     */
-    useQuery: <Op extends keyof Ops>(operationId: IsQueryOperation<Ops, Op> extends true ? Op : never, pathParamsOrOptions?: GetPathParameters<Ops, Op> extends Record<string, never> ? QQueryOptions<Ops, Op> : MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | QQueryOptions<Ops, Op>, optionsOrNull?: QQueryOptions<Ops, Op>) => EndpointQueryReturn<Ops, Op>;
-    /**
-     * Creates a reactive mutation for POST/PUT/PATCH/DELETE operations.
-     *
-     * This composable wraps TanStack Query's useMutation for data-modifying operations
-     * with automatic cache invalidation and optimistic updates.
-     *
-     * @template Op - The operation key from your operations type
-     * @param operationId - Operation ID (must be a mutation operation)
-     * @param pathParamsOrOptions - Path parameters or mutation options
-     * @param optionsOrNull - Additional mutation options when path params are provided
-     * @returns Reactive mutation result with mutate, mutateAsync, status, etc.
-     *
-     * @example
-     * ```typescript
-     * // Mutation without path parameters
-     * const createPet = api.useMutation(OperationId.createPet, {
-     *   onSuccess: (data) => console.log('Created:', data),
-     *   onError: (error) => console.error('Failed:', error)
-     * })
-     *
-     * // Mutation with path parameters
-     * const updatePet = api.useMutation(OperationId.updatePet, { petId: '123' }, {
-     *   onSuccess: async () => {
-     *     // Automatically invalidates related queries
-     *   }
-     * })
-     *
-     * // Execute the mutation
-     * await createPet.mutateAsync({ data: { name: 'Fluffy' } })
-     * ```
-     */
-    useMutation: <Op extends keyof Ops>(operationId: IsQueryOperation<Ops, Op> extends false ? Op : never, pathParamsOrOptions?: GetPathParameters<Ops, Op> extends Record<string, never> ? QMutationOptions<Ops, Op> : MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | QMutationOptions<Ops, Op>, optionsOrNull?: QMutationOptions<Ops, Op>) => {
-        data: import("vue").ComputedRef<import("axios").AxiosResponse<import("./types").GetResponseData<Ops, Op>, any, {}> | undefined>;
-        isEnabled: import("vue").ComputedRef<boolean>;
-        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
-        pathParams: import("vue").ComputedRef<GetPathParameters<Ops, Op>>;
-        context: import("vue").Ref<unknown, unknown>;
-        error: import("vue").Ref<null, null>;
-        isError: import("vue").Ref<false, false>;
-        isPending: import("vue").Ref<false, false>;
-        isSuccess: import("vue").Ref<false, false>;
-        status: import("vue").Ref<"idle", "idle">;
-        failureCount: import("vue").Ref<number, number>;
-        failureReason: import("vue").Ref<Error | null, Error | null>;
-        isPaused: import("vue").Ref<boolean, boolean>;
-        variables: import("vue").Ref<undefined, undefined>;
-        isIdle: import("vue").Ref<true, true>;
-        submittedAt: import("vue").Ref<number, number>;
-        mutate: (variables: import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown> | undefined) => void;
-        mutateAsync: import("@tanstack/query-core").MutateFunction<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown>;
-        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
-    } | {
-        data: import("vue").ComputedRef<import("axios").AxiosResponse<import("./types").GetResponseData<Ops, Op>, any, {}> | undefined>;
-        isEnabled: import("vue").ComputedRef<boolean>;
-        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
-        pathParams: import("vue").ComputedRef<GetPathParameters<Ops, Op>>;
-        context: import("vue").Ref<unknown, unknown>;
-        error: import("vue").Ref<null, null>;
-        isError: import("vue").Ref<false, false>;
-        isPending: import("vue").Ref<true, true>;
-        isSuccess: import("vue").Ref<false, false>;
-        status: import("vue").Ref<"pending", "pending">;
-        failureCount: import("vue").Ref<number, number>;
-        failureReason: import("vue").Ref<Error | null, Error | null>;
-        isPaused: import("vue").Ref<boolean, boolean>;
-        variables: import("@vue/shared").IfAny<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>, [import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>] extends [import("vue").Ref<any, any>] ? import("vue").Ref<any, any> & (import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>) : import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>>;
-        isIdle: import("vue").Ref<false, false>;
-        submittedAt: import("vue").Ref<number, number>;
-        mutate: (variables: import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown> | undefined) => void;
-        mutateAsync: import("@tanstack/query-core").MutateFunction<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown>;
-        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
-    } | {
-        data: import("vue").ComputedRef<import("axios").AxiosResponse<import("./types").GetResponseData<Ops, Op>, any, {}> | undefined>;
-        isEnabled: import("vue").ComputedRef<boolean>;
-        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
-        pathParams: import("vue").ComputedRef<GetPathParameters<Ops, Op>>;
-        context: import("vue").Ref<unknown, unknown>;
-        error: import("vue").Ref<Error, Error>;
-        isError: import("vue").Ref<true, true>;
-        isPending: import("vue").Ref<false, false>;
-        isSuccess: import("vue").Ref<false, false>;
-        status: import("vue").Ref<"error", "error">;
-        failureCount: import("vue").Ref<number, number>;
-        failureReason: import("vue").Ref<Error | null, Error | null>;
-        isPaused: import("vue").Ref<boolean, boolean>;
-        variables: import("@vue/shared").IfAny<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>, [import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>] extends [import("vue").Ref<any, any>] ? import("vue").Ref<any, any> & (import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>) : import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>>;
-        isIdle: import("vue").Ref<false, false>;
-        submittedAt: import("vue").Ref<number, number>;
-        mutate: (variables: import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown> | undefined) => void;
-        mutateAsync: import("@tanstack/query-core").MutateFunction<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown>;
-        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
-    } | {
-        data: import("vue").ComputedRef<import("axios").AxiosResponse<import("./types").GetResponseData<Ops, Op>, any, {}> | undefined>;
-        isEnabled: import("vue").ComputedRef<boolean>;
-        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
-        pathParams: import("vue").ComputedRef<GetPathParameters<Ops, Op>>;
-        context: import("vue").Ref<unknown, unknown>;
-        error: import("vue").Ref<null, null>;
-        isError: import("vue").Ref<false, false>;
-        isPending: import("vue").Ref<false, false>;
-        isSuccess: import("vue").Ref<true, true>;
-        status: import("vue").Ref<"success", "success">;
-        failureCount: import("vue").Ref<number, number>;
-        failureReason: import("vue").Ref<Error | null, Error | null>;
-        isPaused: import("vue").Ref<boolean, boolean>;
-        variables: import("@vue/shared").IfAny<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>, [import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>] extends [import("vue").Ref<any, any>] ? import("vue").Ref<any, any> & (import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>) : import("vue").Ref<import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>>>;
-        isIdle: import("vue").Ref<false, false>;
-        submittedAt: import("vue").Ref<number, number>;
-        mutate: (variables: import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown> | undefined) => void;
-        mutateAsync: import("@tanstack/query-core").MutateFunction<import("axios").AxiosResponse<any, any, {}>, Error, import("./types").GetRequestBody<Ops, Op> extends never ? void | import("./types").QMutationVars<Ops, Op> : import("./types").QMutationVars<Ops, Op>, unknown>;
-        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
-    };
-    /**
-     * Generic endpoint composable that automatically detects operation type.
-     *
-     * This is a universal composable that returns either a query or mutation based
-     * on the operation's HTTP method. Use this when you want unified handling.
-     *
-     * @template Op - The operation key from your operations type
-     * @param operationId - Any operation ID
-     * @param pathParamsOrOptions - Path parameters or operation options
-     * @param optionsOrNull - Additional options when path params are provided
-     * @returns Query result for GET operations, mutation result for others
-     *
-     * @example
-     * ```typescript
-     * // Automatically becomes a query for GET operations
-     * const listEndpoint = api.useEndpoint(OperationId.listPets)
-     *
-     * // Automatically becomes a mutation for POST operations
-     * const createEndpoint = api.useEndpoint(OperationId.createPet)
-     *
-     * // TypeScript knows the correct return type based on the operation
-     * const data = listEndpoint.data // Query data
-     * await createEndpoint.mutateAsync({ data: petData }) // Mutation execution
-     * ```
-     */
-    useEndpoint: <Op extends keyof Ops>(operationId: Op, pathParamsOrOptions?: GetPathParameters<Ops, Op> extends Record<string, never> ? IsQueryOperation<Ops, Op> extends true ? QQueryOptions<Ops, Op> : QMutationOptions<Ops, Op> : MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | (IsQueryOperation<Ops, Op> extends true ? QQueryOptions<Ops, Op> : QMutationOptions<Ops, Op>), optionsOrNull?: IsQueryOperation<Ops, Op> extends true ? QQueryOptions<Ops, Op> : QMutationOptions<Ops, Op>) => IsQueryOperation<Ops, Op> extends true ? EndpointQueryReturn<Ops, Op> : EndpointMutationReturn<Ops, Op>;
-};
+export declare function useOpenApi<Ops extends Operations<Ops>>(config: OpenApiConfig<Ops>): OpenApiInstance<Ops>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,UAAU,EAGV,aAAa,EACb,eAAe,EAShB,MAAM,SAAS,CAAA;AAIhB,YAAY,EACV,aAAa,EACb,eAAe,EACf,WAAW,EACX,eAAe,EACf,UAAU,EACV,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,yBAAyB,EACzB,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,QAAQ,EACR,aAAa,EACb,iBAAiB,GAClB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,GAAG,CAAC,CA2JxG"}

package/dist/index.js

@@ -1,27 +1,23 @@
-import { useEndpoint } from './openapi-endpoint';
-import { useEndpointQuery } from './openapi-query';
-import { useEndpointMutation } from './openapi-mutation';
-import { getHelpers } from './openapi-helpers';
-export { queryClient } from './openapi-helpers';
-/** @internal */
-export { useEndpointQuery } from './openapi-query';
-/** @internal */
-export { useEndpointMutation } from './openapi-mutation';
+import { useEndpointQuery } from './openapi-query.js';
+import { useEndpointMutation } from './openapi-mutation.js';
+import { getHelpers } from './openapi-helpers.js';
+// Public function exports
+export { validateMutationParams } from './types.js';
 /**
- * Creates a type-safe OpenAPI client for Vue applications.
+ * Create a type-safe OpenAPI client with Vue Query integration.
  *
  * This is the main entry point for the library. It provides reactive composables
  * for API operations with full TypeScript type safety based on your OpenAPI specification.
  *
+ * @group Setup
  * @template Ops - The operations type, typically generated from your OpenAPI spec
  * @param config - Configuration object containing operations metadata and axios instance
- * @returns {OpenApiInstance<Ops>} API instance with useQuery, useMutation, useEndpoint, and debug methods
+ * @returns {OpenApiInstance<Ops>} API instance with useQuery, useMutation, and debug methods
  *
  * @example
  * ```typescript
  * import { useOpenApi } from '@qualisero/openapi-endpoint'
- * // See documentation on how to generate types and operations automatically:
- * import { openApiOperations, type OpenApiOperations } from './generated/api-operations'
+ * import { openApiOperations, type OpenApiOperations, QueryOperationId, MutationOperationId } from './generated/api-operations'
  * import axios from 'axios'
  *
  * const api = useOpenApi<OpenApiOperations>({
@@ -29,118 +25,34 @@ export { useEndpointMutation } from './openapi-mutation';
  *   axios: axios.create({ baseURL: 'https://api.example.com' })
  * })
  *
- * // Use in components
- * const { data, isLoading } = api.useQuery('listPets', {})
- * const createPet = api.useMutation('createPet', {})
+ * // Queries
+ * const listQuery = api.useQuery(QueryOperationId.listPets, {
+ *   queryParams: { limit: 10 }
+ * })
+ *
+ * // Mutations
+ * const createPet = api.useMutation(MutationOperationId.createPet)
+ * createPet.mutate({ data: { name: 'Fluffy' } })
  * ```
  */
 export function useOpenApi(config) {
-    return {
-        /**
-         * Debug utility to inspect operation metadata.
-         *
-         * @param operationId - The operation ID to debug
-         * @returns Information about whether the operation is a query operation
-         */
-        _debugIsQueryOperation: function (operationId) {
-            const helpers = getHelpers(config);
-            const info = helpers.getOperationInfo(operationId);
-            console.log('Operation Info:', info);
-            return {};
-        },
-        /**
-         * Creates a reactive query for GET operations.
-         *
-         * This composable wraps TanStack Query for read-only operations with automatic
-         * type inference, caching, and reactive updates.
-         *
-         * @template Op - The operation key from your operations type
-         * @param operationId - Operation ID (must be a GET operation)
-         * @param pathParamsOrOptions - Path parameters or query options
-         * @param optionsOrNull - Additional query options when path params are provided
-         * @returns Reactive query result with data, loading state, error handling, etc.
-         *
-         * @example
-         * ```typescript
-         * // Query without path parameters
-         * const { data: pets, isLoading } = api.useQuery(OperationId.listPets, {
-         *   enabled: true,
-         *   onLoad: (data) => console.log('Loaded:', data)
-         * })
-         *
-         * // Query with path parameters
-         * const { data: pet } = api.useQuery(OperationId.getPet, { petId: '123' }, {
-         *   enabled: computed(() => Boolean(petId.value))
-         * })
-         * ```
-         */
-        useQuery: function (operationId, pathParamsOrOptions, optionsOrNull) {
-            const helpers = getHelpers(config);
+    function useQuery(operationId, pathParamsOrOptions, optionsOrNull) {
+        const helpers = getHelpers(config);
+        const { path } = helpers.getOperationInfo(operationId);
+        const hasPathParams = path.includes('{');
+        if (hasPathParams) {
             return useEndpointQuery(operationId, helpers, pathParamsOrOptions, optionsOrNull);
-        },
-        /**
-         * Creates a reactive mutation for POST/PUT/PATCH/DELETE operations.
-         *
-         * This composable wraps TanStack Query's useMutation for data-modifying operations
-         * with automatic cache invalidation and optimistic updates.
-         *
-         * @template Op - The operation key from your operations type
-         * @param operationId - Operation ID (must be a mutation operation)
-         * @param pathParamsOrOptions - Path parameters or mutation options
-         * @param optionsOrNull - Additional mutation options when path params are provided
-         * @returns Reactive mutation result with mutate, mutateAsync, status, etc.
-         *
-         * @example
-         * ```typescript
-         * // Mutation without path parameters
-         * const createPet = api.useMutation(OperationId.createPet, {
-         *   onSuccess: (data) => console.log('Created:', data),
-         *   onError: (error) => console.error('Failed:', error)
-         * })
-         *
-         * // Mutation with path parameters
-         * const updatePet = api.useMutation(OperationId.updatePet, { petId: '123' }, {
-         *   onSuccess: async () => {
-         *     // Automatically invalidates related queries
-         *   }
-         * })
-         *
-         * // Execute the mutation
-         * await createPet.mutateAsync({ data: { name: 'Fluffy' } })
-         * ```
-         */
-        useMutation: function (operationId, pathParamsOrOptions, optionsOrNull) {
-            const helpers = getHelpers(config);
+        }
+        return useEndpointQuery(operationId, helpers, undefined, pathParamsOrOptions);
+    }
+    function useMutation(operationId, pathParamsOrOptions, optionsOrNull) {
+        const helpers = getHelpers(config);
+        const { path } = helpers.getOperationInfo(operationId);
+        const hasPathParams = path.includes('{');
+        if (hasPathParams) {
             return useEndpointMutation(operationId, helpers, pathParamsOrOptions, optionsOrNull);
-        },
-        /**
-         * Generic endpoint composable that automatically detects operation type.
-         *
-         * This is a universal composable that returns either a query or mutation based
-         * on the operation's HTTP method. Use this when you want unified handling.
-         *
-         * @template Op - The operation key from your operations type
-         * @param operationId - Any operation ID
-         * @param pathParamsOrOptions - Path parameters or operation options
-         * @param optionsOrNull - Additional options when path params are provided
-         * @returns Query result for GET operations, mutation result for others
-         *
-         * @example
-         * ```typescript
-         * // Automatically becomes a query for GET operations
-         * const listEndpoint = api.useEndpoint(OperationId.listPets)
-         *
-         * // Automatically becomes a mutation for POST operations
-         * const createEndpoint = api.useEndpoint(OperationId.createPet)
-         *
-         * // TypeScript knows the correct return type based on the operation
-         * const data = listEndpoint.data // Query data
-         * await createEndpoint.mutateAsync({ data: petData }) // Mutation execution
-         * ```
-         */
-        useEndpoint: function (operationId, pathParamsOrOptions, optionsOrNull) {
-            const helpers = getHelpers(config);
-            return useEndpoint(operationId, helpers, pathParamsOrOptions, optionsOrNull);
-        },
-    };
+        }
+        return useEndpointMutation(operationId, helpers, undefined, pathParamsOrOptions);
+    }
+    return { useQuery, useMutation };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"openapi-helpers.d.ts","sourceRoot":"","sources":["../src/openapi-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGpG;;;;;GAKG;AACH,QAAA,MAAM,kBAAkB,EAAE,eAIxB,CAAA;AAiBF,wBAAgB,UAAU,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC;oCAE/D,EAAE,KAAG,aAAa;wCAMd,EAAE,KAAG,MAAM,GAAG,IAAI;yCAiCjB,EAAE,KAAG,MAAM,GAAG,IAAI;oCAevB,EAAE,KAAG,OAAO;uCAMT,EAAE,KAAG,OAAO;;;EAcvD;AAED,MAAM,MAAM,cAAc,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,IAAI,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAA;AAEtH,OAAO,EAAE,kBAAkB,IAAI,WAAW,EAAE,CAAA"}
+{"version":3,"file":"openapi-helpers.d.ts","sourceRoot":"","sources":["../src/openapi-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EAGhB,MAAM,SAAS,CAAA;AAGhB;;;;;GAKG;AACH,QAAA,MAAM,kBAAkB,EAAE,eAIxB,CAAA;AAiEF,wBAAgB,UAAU,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC;oCAE/D,EAAE,KAAG,aAAa;wCAMd,EAAE,KAAG,MAAM,GAAG,IAAI;yCA6BjB,EAAE,KAAG,MAAM,GAAG,IAAI;oCAWvB,EAAE,KAAG,OAAO;uCAMT,EAAE,KAAG,OAAO;;;EAcvD;AAED,MAAM,MAAM,cAAc,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,IAAI,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAA;AAEtH,OAAO,EAAE,kBAAkB,IAAI,WAAW,EAAE,CAAA"}

package/dist/openapi-helpers.js

@@ -1,4 +1,4 @@
-import { HttpMethod } from './types';
+import { HttpMethod, isQueryMethod, isMutationMethod, } from './types.js';
 import { QueryClient } from '@tanstack/vue-query';
 /**
  * Default QueryClient instance with pre-configured options.
@@ -11,19 +11,63 @@ const defaultQueryClient = new QueryClient({
         queries: { staleTime: 1000 * 60 * 5 },
     },
 });
-// Helper returning the operationId prefix given an http method
-function getMethodPrefix(method) {
-    const METHOD_PREFIXES = {
-        [HttpMethod.GET]: 'get', // or 'list' depending on the operationId
-        [HttpMethod.POST]: 'create',
-        [HttpMethod.PUT]: 'update',
-        [HttpMethod.PATCH]: 'update',
-        [HttpMethod.DELETE]: 'delete',
-        [HttpMethod.HEAD]: null,
-        [HttpMethod.OPTIONS]: null,
-        [HttpMethod.TRACE]: null,
-    };
-    return METHOD_PREFIXES[method];
+/**
+ * Suffixes that require adding 'es' for pluralization (e.g., 'box' -> 'boxes').
+ */
+const PLURAL_ES_SUFFIXES = ['s', 'x', 'z', 'ch', 'sh', 'o'];
+/**
+ * Mapping of HTTP methods to their CRUD operation name prefixes.
+ * Used to infer resource names from operation IDs.
+ */
+const CRUD_PREFIXES = {
+    [HttpMethod.GET]: { singular: 'get', plural: 'list' },
+    [HttpMethod.POST]: { singular: 'create', plural: 'create' },
+    [HttpMethod.PUT]: { singular: 'update', plural: 'update' },
+    [HttpMethod.PATCH]: { singular: 'update', plural: 'update' },
+    [HttpMethod.DELETE]: { singular: 'delete', plural: 'delete' },
+    [HttpMethod.HEAD]: null,
+    [HttpMethod.OPTIONS]: null,
+    [HttpMethod.TRACE]: null,
+};
+/**
+ * Extracts the resource name from an operation ID based on its HTTP method.
+ * @param operationId - The operation ID (e.g., 'createPet', 'updatePet')
+ * @param method - The HTTP method
+ * @returns The resource name (e.g., 'Pet') or null if not extractable
+ */
+function getResourceName(operationId, method) {
+    const prefixes = CRUD_PREFIXES[method];
+    if (!prefixes)
+        return null;
+    // Try singular prefix first (get, create, update, delete)
+    if (operationId.startsWith(prefixes.singular)) {
+        const remaining = operationId.slice(prefixes.singular.length);
+        if (remaining.length > 0 && /^[A-Z]/.test(remaining)) {
+            return remaining;
+        }
+    }
+    // Try plural prefix (list)
+    if (operationId.startsWith(prefixes.plural)) {
+        const remaining = operationId.slice(prefixes.plural.length);
+        if (remaining.length > 0 && /^[A-Z]/.test(remaining)) {
+            return remaining;
+        }
+    }
+    return null;
+}
+/**
+ * Pluralizes a resource name using common English rules.
+ * @param name - The singular resource name
+ * @returns The pluralized name
+ */
+function pluralizeResource(name) {
+    if (name.endsWith('y')) {
+        return name.slice(0, -1) + 'ies';
+    }
+    else if (PLURAL_ES_SUFFIXES.some((suffix) => name.endsWith(suffix))) {
+        return name + 'es';
+    }
+    return name + 's';
 }
 export function getHelpers(config) {
     // Helper function to get operation info by ID
@@ -31,32 +75,23 @@ export function getHelpers(config) {
         return config.operations[operationId];
     }
     // Helper to return a url path for matching list endpoint (e.g. /items/123 -> /items/)
-    // Based on operationId prefix: createItem, updateItem -> listItems
+    // Based on operationId prefix: createItem, updateItem -> listItem
     function getListOperationPath(operationId) {
         const opInfo = getOperationInfo(operationId);
         const operationIdStr = operationId;
-        const operationPrefix = opInfo ? getMethodPrefix(opInfo.method) : null;
-        // Make sure operationId matches `<operationPrefix><upercase resourceName>` pattern
-        if (!operationPrefix || !/^[A-Z]/.test(operationIdStr.charAt(operationPrefix.length)))
-            // If not, fallback to CRUD heuristic
+        // Try to extract resource name from operation ID
+        const resourceName = getResourceName(operationIdStr, opInfo.method);
+        if (!resourceName) {
+            // Fallback to CRUD heuristic based on path structure
             return getCrudListPathPrefix(operationId);
-        const resourceName = operationIdStr.substring(operationPrefix.length);
+        }
+        // Try to find list operation with same resource name
         const listOperationId = `list${resourceName}`;
         let listOperationInfo = getOperationInfo(listOperationId);
+        // If not found, try pluralized version
         if (!listOperationInfo) {
-            // Try pluralizing the resource name (simple heuristic)
-            let pluralResourceName = resourceName;
-            const addEsSuffixes = ['s', 'x', 'z', 'ch', 'sh', 'o'];
-            if (resourceName.endsWith('y')) {
-                pluralResourceName = resourceName.slice(0, -1) + 'ies';
-            }
-            else if (addEsSuffixes.some((suffix) => resourceName.endsWith(suffix))) {
-                pluralResourceName = resourceName + 'es';
-            }
-            else {
-                pluralResourceName = resourceName + 's';
-            }
-            listOperationInfo = getOperationInfo(`list${pluralResourceName}`);
+            const pluralName = pluralizeResource(resourceName);
+            listOperationInfo = getOperationInfo(`list${pluralName}`);
         }
         if (listOperationInfo && listOperationInfo.method === HttpMethod.GET) {
             return listOperationInfo.path;
@@ -74,18 +109,15 @@ export function getHelpers(config) {
         }
         return null;
     }
-    // Constants for HTTP method categorization
-    const QUERY_METHODS = [HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS];
-    const MUTATION_METHODS = [HttpMethod.POST, HttpMethod.PUT, HttpMethod.PATCH, HttpMethod.DELETE];
     // Helper to check if an operation is a query method at runtime
     function isQueryOperation(operationId) {
         const { method } = getOperationInfo(operationId);
-        return QUERY_METHODS.includes(method);
+        return isQueryMethod(method);
     }
     // Helper to check if an operation is a mutation method at runtime
     function isMutationOperation(operationId) {
         const { method } = getOperationInfo(operationId);
-        return MUTATION_METHODS.includes(method);
+        return isMutationMethod(method);
     }
     return {
         getOperationInfo,