@qualisero/openapi-endpoint 0.2.3

package/README.md

@@ -0,0 +1,62 @@
+# Vue OpenAPI Query
+
+[![npm version](https://badge.fury.io/js/@qualisero%2Fopenapi-endpoint.svg)](https://badge.fury.io/js/@qualisero%2Fopenapi-endpoint)
+[![CI](https://github.com/qualisero/openapi-endpoint/workflows/CI/badge.svg)](https://github.com/qualisero/openapi-endpoint/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/qualisero/openapi-endpoint/branch/main/graph/badge.svg)](https://codecov.io/gh/qualisero/openapi-endpoint)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm bundle size](https://img.shields.io/bundlephobia/minzip/@qualisero/openapi-endpoint)](https://bundlephobia.com/package/@qualisero/openapi-endpoint)
+
+Type-safe OpenAPI integration for Vue Query (TanStack Query).
+
+## Installation
+
+```bash
+npm install @qualisero/openapi-endpoint
+```
+
+## Code Generation
+
+This package includes a command-line tool to generate TypeScript types and operation definitions from your OpenAPI specification:
+
+```bash
+# Generate from local file
+npx @qualisero/openapi-endpoint ./api/openapi.json ./src/generated
+
+# Generate from remote URL
+npx @qualisero/openapi-endpoint https://api.example.com/openapi.json ./src/api
+```
+
+This will generate two files in your specified output directory:
+
+- `openapi-types.ts` - TypeScript type definitions for your API
+- `api-operations.ts` - Operation IDs and metadata for use with this library
+
+## Usage
+
+### 1. Initialize the package
+
+```typescript
+// api/init.ts
+import { useOpenApi } from '@qualisero/openapi-endpoint'
+import { QueryClient } from '@tanstack/vue-query'
+import axios from 'axios'
+
+// Import your generated OpenAPI types and operations
+import type { operations } from './generated/openapi-types'
+import { OperationId, OPERATION_INFO } from './generated/api-operations'
+
+// Create axios instance
+const axiosInstance = axios.create({
+  baseURL: 'https://api.example.com',
+})
+
+// Properly type the operations for the library
+const operationInfoDict = OPERATION_INFO
+type OperationsWithInfo = operations & typeof operationInfoDict
+
+// Initialize the package
+const api = useOpenApi({
+  operations: operationInfoDict as OperationsWithInfo,
+  axios: axiosInstance,
+})
+```

package/bin/openapi-codegen.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import { spawn } from 'child_process'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+// Execute the TypeScript CLI script
+const scriptPath = join(__dirname, '..', 'dist', 'cli.js')
+
+const child = spawn('node', [scriptPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  shell: false,
+})
+
+child.on('exit', (code) => {
+  process.exit(code || 0)
+})
+
+child.on('error', (error) => {
+  console.error('Error executing CLI:', error)
+  process.exit(1)
+})

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,176 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+async function fetchOpenAPISpec(input) {
+    // Check if input is a URL
+    if (input.startsWith('http://') || input.startsWith('https://')) {
+        console.log(`📡 Fetching OpenAPI spec from URL: ${input}`);
+        // Use node's built-in fetch (available in Node 18+)
+        try {
+            const response = await fetch(input);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const content = await response.text();
+            return content;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch OpenAPI spec from URL: ${error}`);
+        }
+    }
+    else {
+        // Local file
+        console.log(`📂 Reading OpenAPI spec from file: ${input}`);
+        if (!fs.existsSync(input)) {
+            throw new Error(`File not found: ${input}`);
+        }
+        return fs.readFileSync(input, 'utf8');
+    }
+}
+async function generateTypes(openapiContent, outputDir) {
+    console.log('🔨 Generating TypeScript types using openapi-typescript...');
+    // Write the OpenAPI spec to a temporary file
+    const tempSpecPath = path.join(outputDir, 'temp-openapi.json');
+    fs.writeFileSync(tempSpecPath, openapiContent);
+    try {
+        // Run openapi-typescript
+        const typesOutputPath = path.join(outputDir, 'openapi-types.ts');
+        const command = `npx openapi-typescript "${tempSpecPath}" --output "${typesOutputPath}"`;
+        await execAsync(command);
+        console.log(`✅ Generated types file: ${typesOutputPath}`);
+    }
+    finally {
+        // Clean up temp file
+        if (fs.existsSync(tempSpecPath)) {
+            fs.unlinkSync(tempSpecPath);
+        }
+    }
+}
+function parseOperationsFromSpec(openapiContent) {
+    const openApiSpec = JSON.parse(openapiContent);
+    if (!openApiSpec.paths) {
+        throw new Error('Invalid OpenAPI spec: missing paths');
+    }
+    const operationIds = [];
+    const operationInfoMap = {};
+    // Iterate through all paths and methods to extract operationIds
+    Object.entries(openApiSpec.paths).forEach(([pathUrl, pathItem]) => {
+        Object.entries(pathItem).forEach(([method, operation]) => {
+            // Skip non-HTTP methods (like parameters)
+            const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'trace'];
+            if (!httpMethods.includes(method.toLowerCase())) {
+                return;
+            }
+            const op = operation;
+            if (op.operationId) {
+                operationIds.push(op.operationId);
+                operationInfoMap[op.operationId] = {
+                    path: pathUrl,
+                    method: method.toUpperCase(),
+                };
+            }
+        });
+    });
+    // Sort operationIds for consistent output
+    operationIds.sort();
+    return { operationIds, operationInfoMap };
+}
+function generateApiOperationsContent(operationIds, operationInfoMap) {
+    // Generate enum-like object
+    const enumContent = operationIds.map((id) => `  ${id}: '${id}',`).join('\n');
+    // Generate dictionary
+    const dictionaryContent = operationIds
+        .map((id) => {
+        const info = operationInfoMap[id];
+        return `  ${id}: {\n    path: '${info.path}',\n    method: HttpMethod.${info.method},\n  },`;
+    })
+        .join('\n');
+    return `// Auto-generated from OpenAPI specification
+// Do not edit this file manually
+
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+  HEAD = 'HEAD',
+  OPTIONS = 'OPTIONS',
+  TRACE = 'TRACE',
+}
+
+export const OperationId = {
+${enumContent}
+} as const
+
+export type OperationId = (typeof OperationId)[keyof typeof OperationId]
+
+export const OPERATION_INFO = {
+${dictionaryContent}
+} as const
+`;
+}
+async function generateApiOperations(openapiContent, outputDir) {
+    console.log('🔨 Generating api-operations.ts file...');
+    const { operationIds, operationInfoMap } = parseOperationsFromSpec(openapiContent);
+    // Generate TypeScript content
+    const tsContent = generateApiOperationsContent(operationIds, operationInfoMap);
+    // Write to output file
+    const outputPath = path.join(outputDir, 'api-operations.ts');
+    fs.writeFileSync(outputPath, tsContent);
+    console.log(`✅ Generated api-operations file: ${outputPath}`);
+    console.log(`📊 Found ${operationIds.length} operations`);
+}
+function printUsage() {
+    console.log(`
+Usage: npx @qualisero/openapi-endpoint <openapi-input> <output-directory>
+
+Arguments:
+  openapi-input      Path to OpenAPI JSON file or URL to fetch it from
+  output-directory   Directory where generated files will be saved
+
+Examples:
+  npx @qualisero/openapi-endpoint ./api/openapi.json ./src/generated
+  npx @qualisero/openapi-endpoint https://api.example.com/openapi.json ./src/api
+
+This command will generate:
+  - openapi-types.ts    (TypeScript types from OpenAPI spec)
+  - api-operations.ts   (Operation IDs and info for use with this library)
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        printUsage();
+        process.exit(0);
+    }
+    if (args.length !== 2) {
+        console.error('❌ Error: Exactly 2 arguments are required');
+        printUsage();
+        process.exit(1);
+    }
+    const [openapiInput, outputDir] = args;
+    try {
+        // Ensure output directory exists
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+            console.log(`📁 Created output directory: ${outputDir}`);
+        }
+        // Fetch OpenAPI spec content
+        const openapiContent = await fetchOpenAPISpec(openapiInput);
+        // Generate both files
+        await Promise.all([generateTypes(openapiContent, outputDir), generateApiOperations(openapiContent, outputDir)]);
+        console.log('🎉 Code generation completed successfully!');
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+// Auto-execute main function
+main().catch((error) => {
+    console.error('❌ Unexpected error:', error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import type { MaybeRefOrGetter } from 'vue';
+import { QueryClient } from '@tanstack/vue-query';
+import { EndpointQueryReturn } from './openapi-query';
+import { Operations, GetPathParameters, OpenApiConfig, QueryOptions, MutationOptions, IsQueryOperation } from './types';
+export type { OperationInfo, QueryOptions } from './types';
+export { type EndpointQueryReturn, useEndpointQuery } from './openapi-query';
+export { type EndpointMutationReturn, useEndpointMutation } from './openapi-mutation';
+export declare const queryClient: QueryClient;
+export declare function useOpenApi<Ops extends Operations<Ops>>(config: OpenApiConfig<Ops>): {
+    useQuery: <Op extends keyof Ops>(operationId: IsQueryOperation<Ops, Op> extends true ? Op : never, pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | QueryOptions<Ops, Op>, optionsOrNull?: QueryOptions<Ops, Op>) => EndpointQueryReturn<Ops, Op>;
+    useMutation: <Op extends keyof Ops>(operationId: IsQueryOperation<Ops, Op> extends false ? Op : never, pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | MutationOptions<Ops, Op>, optionsOrNull?: MutationOptions<Ops, Op>) => {
+        data: import("vue").ComputedRef<import("./types").GetResponseData<Ops, Op> | undefined>;
+        isEnabled: import("vue").ComputedRef<boolean>;
+        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
+        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>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        mutate: (variables: import("./types").MutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        data: import("vue").ComputedRef<import("./types").GetResponseData<Ops, Op> | undefined>;
+        isEnabled: import("vue").ComputedRef<boolean>;
+        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
+        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").Ref<import("./types").MutationVars<Ops, Op>, import("./types").MutationVars<Ops, Op>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        mutate: (variables: import("./types").MutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        data: import("vue").ComputedRef<import("./types").GetResponseData<Ops, Op> | undefined>;
+        isEnabled: import("vue").ComputedRef<boolean>;
+        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
+        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").Ref<import("./types").MutationVars<Ops, Op>, import("./types").MutationVars<Ops, Op>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        mutate: (variables: import("./types").MutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        data: import("vue").ComputedRef<import("./types").GetResponseData<Ops, Op> | undefined>;
+        isEnabled: import("vue").ComputedRef<boolean>;
+        extraPathParams: import("vue").Ref<GetPathParameters<Ops, Op>, GetPathParameters<Ops, Op>>;
+        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").Ref<import("./types").MutationVars<Ops, Op>, import("./types").MutationVars<Ops, Op>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        mutate: (variables: import("./types").MutationVars<Ops, Op>, options?: import("@tanstack/query-core").MutateOptions<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("./types").GetResponseData<Ops, Op>, Error, import("./types").MutationVars<Ops, Op>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    };
+    useEndpoint: <Op extends keyof Ops>(operationId: Op, pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | (IsQueryOperation<Ops, Op> extends true ? QueryOptions<Ops, Op> : MutationOptions<Ops, Op>), optionsOrNull?: IsQueryOperation<Ops, Op> extends true ? QueryOptions<Ops, Op> : MutationOptions<Ops, Op>) => EndpointQueryReturn<Ops, Op> | import("./openapi-mutation").EndpointMutationReturn<Ops, Op>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAGjD,OAAO,EAAE,mBAAmB,EAAoB,MAAM,iBAAiB,CAAA;AAEvE,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAEvH,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC1D,OAAO,EAAE,KAAK,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAC5E,OAAO,EAAE,KAAK,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAErF,eAAO,MAAM,WAAW,aAItB,CAAA;AAEF,wBAAgB,UAAU,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC;eAE1D,EAAE,SAAS,MAAM,GAAG,eACzB,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,KAAK,wBAC1C,gBAAgB,CAAC,iBAAiB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,kBAC7F,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,KACpC,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC;kBAMR,EAAE,SAAS,MAAM,GAAG,eAC5B,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,KAAK,GAAG,EAAE,GAAG,KAAK,wBAC3C,gBAAgB,CAAC,iBAAiB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC,kBAChG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOnB,EAAE,SAAS,MAAM,GAAG,eAC5B,EAAE,wBAEX,gBAAgB,CAAC,iBAAiB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAC/D,CAAC,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,kBAC/E,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC;EAO9G"}

package/dist/index.js

@@ -0,0 +1,28 @@
+import { QueryClient } from '@tanstack/vue-query';
+import { useEndpoint } from './openapi-endpoint';
+import { useEndpointQuery } from './openapi-query';
+import { useEndpointMutation } from './openapi-mutation';
+import { getHelpers } from './openapi-helpers';
+export { useEndpointQuery } from './openapi-query';
+export { useEndpointMutation } from './openapi-mutation';
+export const queryClient = new QueryClient({
+    defaultOptions: {
+        queries: { staleTime: 1000 * 60 * 5 },
+    },
+});
+export function useOpenApi(config) {
+    return {
+        useQuery: function (operationId, pathParamsOrOptions, optionsOrNull) {
+            const helpers = getHelpers(config);
+            return useEndpointQuery(operationId, helpers, pathParamsOrOptions, optionsOrNull);
+        },
+        useMutation: function (operationId, pathParamsOrOptions, optionsOrNull) {
+            const helpers = getHelpers(config);
+            return useEndpointMutation(operationId, helpers, pathParamsOrOptions, optionsOrNull);
+        },
+        useEndpoint: function (operationId, pathParamsOrOptions, optionsOrNull) {
+            const helpers = getHelpers(config);
+            return useEndpoint(operationId, helpers, pathParamsOrOptions, optionsOrNull);
+        },
+    };
+}

package/dist/openapi-endpoint.d.ts

@@ -0,0 +1,18 @@
+import { type MaybeRefOrGetter } from 'vue';
+import { EndpointQueryReturn } from './openapi-query';
+import { EndpointMutationReturn } from './openapi-mutation';
+import type { GetPathParameters, QueryOptions, MutationOptions, Operations, IsQueryOperation } from './types';
+import { getHelpers } from './openapi-helpers';
+/**
+ * Composable for performing a strictly typed OpenAPI operation (query or mutation) using Vue Query.
+ * Automatically detects whether the operation is a query or mutation and delegates to the appropriate composable.
+ * Returns a reactive query or mutation object with strict typing and helpers.
+ *
+ * @template T OperationId type representing the OpenAPI operation.
+ * @param operationId The OpenAPI operation ID to execute.
+ * @param pathParamsOrOptions Optional path parameters for the endpoint, can be reactive.
+ * @param optionsOrNull Optional query or mutation options, including Vue Query options.
+ * @returns Query or mutation object with strict typing and helpers.
+ */
+export declare function useEndpoint<Ops extends Operations<Ops>, Op extends keyof Ops>(operationId: Op, helpers: ReturnType<typeof getHelpers<Ops, Op>>, pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | (IsQueryOperation<Ops, Op> extends true ? QueryOptions<Ops, Op> : MutationOptions<Ops, Op>), optionsOrNull?: IsQueryOperation<Ops, Op> extends true ? QueryOptions<Ops, Op> : MutationOptions<Ops, Op>): EndpointQueryReturn<Ops, Op> | EndpointMutationReturn<Ops, Op>;
+//# sourceMappingURL=openapi-endpoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-endpoint.d.ts","sourceRoot":"","sources":["../src/openapi-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAoB,MAAM,iBAAiB,CAAA;AACvE,OAAO,EAAE,sBAAsB,EAAuB,MAAM,oBAAoB,CAAA;AAChF,OAAO,KAAK,EAEV,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,UAAU,EACV,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAmB9C;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,SAAS,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,MAAM,GAAG,EAC3E,WAAW,EAAE,EAAE,EACf,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAC/C,mBAAmB,CAAC,EAChB,gBAAgB,CAAC,iBAAiB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAC/D,CAAC,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAC/F,aAAa,GAAE,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,IAAI,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,CAAM,GAC5G,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,sBAAsB,CAAC,GAAG,EAAE,EAAE,CAAC,CAahE"}

package/dist/openapi-endpoint.js

@@ -0,0 +1,39 @@
+import { useEndpointQuery } from './openapi-query';
+import { useEndpointMutation } from './openapi-mutation';
+// NOTE: rather than using conditional overloads, we are adjusting the signature in the calling code based on IsQueryOperation
+// Conditional overload: if operation is a query, use QueryOptions and return QueryReturn
+// export function useEndpoint<Ops extends Operations<Ops>, Op extends keyof Ops>(
+//   config: OpenApiConfig<Ops>,
+//   operationId: IsQueryOperation<Ops, Op> extends true ? Op : never,
+//   pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | QueryOptions<Ops, Op>,
+//   optionsOrNull?: QueryOptions<Ops, Op>
+// ): EndpointQueryReturn<Ops, Op>
+// // Conditional overload: if operation is a mutation, use MutationOptions and return MutationReturn
+// export function useEndpoint<Ops extends Operations<Ops>, Op extends keyof Ops>(
+//   config: OpenApiConfig<Ops>,
+//   operationId: IsQueryOperation<Ops, Op> extends false ? Op : never,
+//   pathParamsOrOptions?: MaybeRefOrGetter<GetPathParameters<Ops, Op> | null | undefined> | MutationOptions<Ops, Op>,
+//   optionsOrNull?: MutationOptions<Ops, Op>
+// ): EndpointMutationReturn<Ops, Op>
+/**
+ * Composable for performing a strictly typed OpenAPI operation (query or mutation) using Vue Query.
+ * Automatically detects whether the operation is a query or mutation and delegates to the appropriate composable.
+ * Returns a reactive query or mutation object with strict typing and helpers.
+ *
+ * @template T OperationId type representing the OpenAPI operation.
+ * @param operationId The OpenAPI operation ID to execute.
+ * @param pathParamsOrOptions Optional path parameters for the endpoint, can be reactive.
+ * @param optionsOrNull Optional query or mutation options, including Vue Query options.
+ * @returns Query or mutation object with strict typing and helpers.
+ */
+export function useEndpoint(operationId, helpers, pathParamsOrOptions, optionsOrNull = {}) {
+    if (helpers.isMutationOperation(operationId)) {
+        return useEndpointMutation(operationId, helpers, pathParamsOrOptions, optionsOrNull);
+    }
+    else if (helpers.isQueryOperation(operationId)) {
+        return useEndpointQuery(operationId, helpers, pathParamsOrOptions, optionsOrNull);
+    }
+    else {
+        throw new Error(`Operation ${String(operationId)} is neither a query nor a mutation operation`);
+    }
+}

package/dist/openapi-helpers.d.ts

@@ -0,0 +1,10 @@
+import { type OperationInfo, OpenApiConfig, Operations } from './types';
+export declare function getHelpers<Ops extends Operations<Ops>, Op extends keyof Ops>(config: OpenApiConfig<Ops>): {
+    getOperationInfo: (operationId: Op) => OperationInfo;
+    getListOperationPath: (operationId: Op) => string | null;
+    getCrudListPathPrefix: (operationId: Op) => string | null;
+    isQueryOperation: (operationId: Op) => boolean;
+    isMutationOperation: (operationId: Op) => boolean;
+    axios: import("axios").AxiosInstance;
+};
+//# sourceMappingURL=openapi-helpers.d.ts.map

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

@@ -0,0 +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,MAAM,SAAS,CAAA;AAiBnF,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;oCAgBvB,EAAE,KAAG,OAAO;uCAOT,EAAE,KAAG,OAAO;;EAcvD"}

package/dist/openapi-helpers.js

@@ -0,0 +1,89 @@
+import { HttpMethod } from './types';
+// helper returning the operationId prefix given an http method
+function _getMethodPrefix(method) {
+    const methodPrefixes = {
+        [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 methodPrefixes[method];
+}
+export function getHelpers(config) {
+    // Helper function to get operation info by ID
+    function getOperationInfo(operationId) {
+        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
+    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
+            return getCrudListPathPrefix(operationId);
+        const resourceName = operationIdStr.substring(operationPrefix.length);
+        const listOperationId = `list${resourceName}`;
+        let listOperationInfo = getOperationInfo(listOperationId);
+        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}`);
+        }
+        if (listOperationInfo && listOperationInfo.method === HttpMethod.GET) {
+            return listOperationInfo.path;
+        }
+        return null;
+    }
+    // Fallback to return a url path prefix matching list endpoint (e.g. /items/123 -> /items/)
+    // based on Assumes standard CRUD Restful patterns.
+    function getCrudListPathPrefix(operationId) {
+        const { path } = getOperationInfo(operationId);
+        // for PUT/PATCH/DELETE, strip last segment if it's a path parameter
+        const segments = path.split('/').filter((segment) => segment.length > 0);
+        if (segments.length >= 2 && /^{[^}]+}$/.test(segments.at(-1))) {
+            return '/' + segments.slice(0, -1).join('/') + '/';
+        }
+        return null;
+    }
+    // Helper function to get all operation IDs
+    // function getAllOperationIds(): OperationId<C>[] {
+    //   return Object.values(OperationId)
+    // }
+    // Helper to check if an operation is a query method at runtime
+    function isQueryOperation(operationId) {
+        const { method } = getOperationInfo(operationId);
+        const queryMethods = [HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS];
+        return queryMethods.includes(method);
+    }
+    // Helper to check if an operation is a mutation method at runtime
+    function isMutationOperation(operationId) {
+        const { method } = getOperationInfo(operationId);
+        const mutationMethods = [HttpMethod.POST, HttpMethod.PUT, HttpMethod.PATCH, HttpMethod.DELETE];
+        return mutationMethods.includes(method);
+    }
+    return {
+        getOperationInfo,
+        getListOperationPath,
+        getCrudListPathPrefix,
+        isQueryOperation,
+        isMutationOperation,
+        axios: config.axios,
+    };
+}