hono-takibi 0.9.78 → 0.9.80

package/README.md

@@ -85,10 +85,6 @@ export const getRoute = createRoute({
 })
 ```
 
-### Demo 
-
-![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/demo/hono-takibi.gif)
-
 ## CLI
 
 ### Options
@@ -114,12 +110,6 @@ Options:
   -h, --help                  display help for command
 ```
 
-### Example
-
-```bash
-npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-schemas --export-schemas-types --template --base-path '/api/v1'
-```
-
 ## Configuration File (`hono-takibi.config.ts`)
 
 Config used by both the CLI and the Vite plugin.
@@ -206,19 +196,46 @@ export default defineConfig({
   },
   type: {
     output: './src/types.ts',
+    readonly: true,
   },
   rpc: {
     output: './src/rpc',
     import: '../client',
     split: true,
+    client: 'client',
+  },
+  // Client library integrations
+  'tanstack-query': {
+    output: './src/tanstack-query',
+    import: '../client',
+    split: true,
+    client: 'client',
+  },
+  'svelte-query': {
+    output: './src/svelte-query',
+    import: '../client',
+    split: true,
+    client: 'client',
+  },
+  swr: {
+    output: './src/swr',
+    import: '../client',
+    split: true,
+    client: 'client',
+  },
+  'vue-query': {
+    output: './src/vue-query',
+    import: '../client',
+    split: true,
+    client: 'client',
   },
 })
 ```
 
-## Essentials
+### Essentials
 
 * Put **`hono-takibi.config.ts`** at repo root.
-* Default‑export with `defineConfig(...)`.
+* Default-export with `defineConfig(...)`.
 * `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
 
 > **About `split`**
@@ -226,49 +243,74 @@ export default defineConfig({
 > * `split: true` → `output` is a **directory**; many files + `index.ts`.
 > * `split` **omitted** or `false` → `output` is a **single `*.ts` file** (one file only).
 
----
-
-## Single‑file
+## Client Library Integrations
 
-One file. Set top‑level `output` (don't define `components`/`routes`).
+### TanStack Query
 
 ```ts
-import { defineConfig } from 'hono-takibi/config'
-
 export default defineConfig({
   input: 'openapi.yaml',
-  'zod-openapi': {
-    output: './src/index.ts',
-    exportSchemas: true,
-    exportSchemasTypes: true,
-  },
+  'zod-openapi': { output: './src/routes.ts', exportSchemas: true },
+  'tanstack-query': { output: './src/hooks', import: '../client', split: true, client: 'client' },
 })
 ```
 
----
-
-## RPC (optional)
-
-Works with either pattern.
-
-* `split: true` → `output` is a **directory**; many files + `index.ts`.
-* `split` **omitted** or `false` → `output` is **one `*.ts` file**.
+Generated hooks (from Pet Store):
 
 ```ts
-import { defineConfig } from 'hono-takibi/config'
-
-export default defineConfig({
-  input: 'openapi.yaml',
-  'zod-openapi': { output: './src/index.ts', exportSchemas: true, exportSchemasTypes: true },
-  rpc: { output: './src/rpc', import: '../client', split: true },
+import type {
+  QueryFunctionContext,
+  UseMutationOptions,
+  UseQueryOptions,
+} from '@tanstack/react-query'
+import { useMutation, useQuery } from '@tanstack/react-query'
+import type { ClientRequestOptions, InferRequestType } from 'hono/client'
+import { parseResponse } from 'hono/client'
+import { client } from '../clients/pet-store'
+
+/**
+ * Generates TanStack Query mutation key for PUT /pet
+ * Returns key ['prefix', 'method', 'path'] for mutation state tracking
+ */
+export function getPutPetMutationKey() {
+  return ['pet', 'PUT', '/pet'] as const
+}
+
+/**
+ * Returns TanStack Query mutation options for PUT /pet
+ *
+ * Use with useMutation, setMutationDefaults, or isMutating.
+ */
+export const getPutPetMutationOptions = (clientOptions?: ClientRequestOptions) => ({
+  mutationKey: getPutPetMutationKey(),
+  mutationFn: async (args: InferRequestType<typeof client.pet.$put>) =>
+    parseResponse(client.pet.$put(args, clientOptions)),
 })
-```
 
----
+/**
+ * PUT /pet
+ *
+ * Update an existing pet
+ *
+ * Update an existing pet by Id
+ */
+export function usePutPet(options?: {
+  mutation?: UseMutationOptions<
+    Awaited<ReturnType<typeof parseResponse<Awaited<ReturnType<typeof client.pet.$put>>>>>,
+    Error,
+    InferRequestType<typeof client.pet.$put>
+  >
+  client?: ClientRequestOptions
+}) {
+  const { mutation: mutationOptions, client: clientOptions } = options ?? {}
+  const { mutationKey, mutationFn, ...baseOptions } = getPutPetMutationOptions(clientOptions)
+  return useMutation({ ...baseOptions, ...mutationOptions, mutationKey, mutationFn })
+}
+```
 
-## Vite Plugin (`honoTakibiVite`)
+## Vite Plugin
 
-Auto‑regenerates on changes and reloads dev server.
+Auto-regenerate on file changes:
 
 ```ts
 // vite.config.ts
@@ -280,41 +322,34 @@ export default defineConfig({
 })
 ```
 
-**What it does**
-
-* **Watches**: the config, your `input`, and nearby `**/*.{yaml,json,tsp}`.
-* **Generates** outputs per your config (single‑file or split, plus `rpc`).
-* **Cleans** old generated files safely when paths or `split` change.
-
-That’s it — set `input`, choose one of the two patterns, and (optionally) add `rpc`. ✅
-
-### Demo (Vite + HMR)
-
 ![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
 
-### ⚠️ WARNING: Potential Breaking Changes Without Notice
+## Limitations
 
 **This package is in active development and may introduce breaking changes without prior notice.**
-Specifically:
+
+- Not all OpenAPI features are supported
+- Complex schemas might not convert correctly
+- Some OpenAPI validations may not be perfectly converted to Zod
 - Schema generation logic might be updated
 - Output code structure could be modified
-- Example value handling might be altered
 
 We strongly recommend:
 - Pinning to exact versions in production
 - Testing thoroughly when updating versions
 - Reviewing generated code after updates
 
+## Contributing
+
 We welcome feedback and contributions to improve the tool!
 
-### Current Limitations
+If you find any issues with the generated code or have suggestions for improvements, please:
+
+- Open an issue at [GitHub Issues](https://github.com/nakita628/hono-takibi/issues)
+- Submit a pull request with your improvements
 
-  **OpenAPI Support**
-   - Not all OpenAPI features are supported
-   - Complex schemas might not convert correctly
-   - Limited support for certain response types
-   - Some OpenAPI validations may not be perfectly converted to Zod validations
+Your contributions help make this tool better for the community.
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita-Ypm/hono-takibi?tab=MIT-1-ov-file) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/hono-takibi?tab=MIT-1-ov-file) for more information.

package/dist/cli/index.js

@@ -22,7 +22,7 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { readConfig } from '../config/index.js';
-import { callbacks, examples, headers, links, parameters, requestBodies, responses, route, rpc, schemas, securitySchemes, takibi, type, } from '../core/index.js';
+import { callbacks, examples, headers, links, parameters, requestBodies, responses, route, rpc, schemas, securitySchemes, svelteQuery, swr, takibi, tanstackQuery, type, vueQuery, } from '../core/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
@@ -175,7 +175,7 @@ export async function honoTakibi() {
     if (!openAPIResult.ok)
         return { ok: false, error: openAPIResult.error };
     const openAPI = openAPIResult.value;
-    const [takibiResult, schemaResult, parameterResult, headersResult, examplesResult, linksResult, callbacksResult, securitySchemesResult, requestBodiesResult, responsesResult, routeResult, typeResult, rpcResult,] = await Promise.all([
+    const [takibiResult, schemaResult, parameterResult, headersResult, examplesResult, linksResult, callbacksResult, securitySchemesResult, requestBodiesResult, responsesResult, routeResult, typeResult, rpcResult, swrResult, tanstackQueryResult, svelteQueryResult, vueQueryResult,] = await Promise.all([
         config['zod-openapi']?.output
             ? takibi(openAPI, config['zod-openapi'].output, false, false, '/', {
                 readonly: config['zod-openapi'].readonly,
@@ -229,6 +229,18 @@ export async function honoTakibi() {
         config.rpc
             ? rpc(openAPI, config.rpc.output, config.rpc.import, config.rpc.split ?? false, config.rpc.client ?? 'client')
             : Promise.resolve(undefined),
+        config.swr
+            ? swr(openAPI, config.swr.output, config.swr.import, config.swr.split ?? false, config.swr.client ?? 'client')
+            : Promise.resolve(undefined),
+        config['tanstack-query']
+            ? tanstackQuery(openAPI, config['tanstack-query'].output, config['tanstack-query'].import, config['tanstack-query'].split ?? false, config['tanstack-query'].client ?? 'client')
+            : Promise.resolve(undefined),
+        config['svelte-query']
+            ? svelteQuery(openAPI, config['svelte-query'].output, config['svelte-query'].import, config['svelte-query'].split ?? false, config['svelte-query'].client ?? 'client')
+            : Promise.resolve(undefined),
+        config['vue-query']
+            ? vueQuery(openAPI, config['vue-query'].output, config['vue-query'].import, config['vue-query'].split ?? false, config['vue-query'].client ?? 'client')
+            : Promise.resolve(undefined),
     ]);
     if (takibiResult && !takibiResult.ok)
         return { ok: false, error: takibiResult.error };
@@ -256,6 +268,14 @@ export async function honoTakibi() {
         return { ok: false, error: typeResult.error };
     if (rpcResult && !rpcResult.ok)
         return { ok: false, error: rpcResult.error };
+    if (swrResult && !swrResult.ok)
+        return { ok: false, error: swrResult.error };
+    if (tanstackQueryResult && !tanstackQueryResult.ok)
+        return { ok: false, error: tanstackQueryResult.error };
+    if (svelteQueryResult && !svelteQueryResult.ok)
+        return { ok: false, error: svelteQueryResult.error };
+    if (vueQueryResult && !vueQueryResult.ok)
+        return { ok: false, error: vueQueryResult.error };
     const results = [
         takibiResult?.value,
         schemaResult?.value,
@@ -270,6 +290,10 @@ export async function honoTakibi() {
         routeResult?.value,
         typeResult?.value,
         rpcResult?.value,
+        swrResult?.value,
+        tanstackQueryResult?.value,
+        svelteQueryResult?.value,
+        vueQueryResult?.value,
     ].filter((v) => v !== undefined);
     return { ok: true, value: results.join('\n') };
 }

package/dist/config/index.d.ts

@@ -80,6 +80,30 @@ type Config = {
         readonly split?: boolean;
         readonly client?: string;
     };
+    readonly swr?: {
+        readonly output: string | `${string}.ts`;
+        readonly import: string;
+        readonly split?: boolean;
+        readonly client?: string;
+    };
+    readonly 'tanstack-query'?: {
+        readonly output: string | `${string}.ts`;
+        readonly import: string;
+        readonly split?: boolean;
+        readonly client?: string;
+    };
+    readonly 'svelte-query'?: {
+        readonly output: string | `${string}.ts`;
+        readonly import: string;
+        readonly split?: boolean;
+        readonly client?: string;
+    };
+    readonly 'vue-query'?: {
+        readonly output: string | `${string}.ts`;
+        readonly import: string;
+        readonly split?: boolean;
+        readonly client?: string;
+    };
 };
 /**
  * Validates and parses a hono-takibi configuration object.

package/dist/config/index.js

@@ -210,6 +210,135 @@ export function parseConfig(config) {
             };
         }
     }
+    // swr
+    if (config.swr !== undefined) {
+        if (typeof config.swr.output !== 'string') {
+            return { ok: false, error: `Invalid output format for swr: ${String(config.swr.output)}` };
+        }
+        if (typeof config.swr.import !== 'string') {
+            return { ok: false, error: `Invalid import format for swr: ${String(config.swr.import)}` };
+        }
+        if (config.swr.split !== undefined && typeof config.swr.split !== 'boolean') {
+            return { ok: false, error: `Invalid split format for swr: ${String(config.swr.split)}` };
+        }
+        if (config.swr.client !== undefined && typeof config.swr.client !== 'string') {
+            return { ok: false, error: `Invalid client format for swr: ${String(config.swr.client)}` };
+        }
+        // split: true requires directory (no .ts)
+        if (config.swr.split === true && isTs(config.swr.output)) {
+            return {
+                ok: false,
+                error: `Invalid swr output path for split mode (must be a directory, not .ts): ${config.swr.output}`,
+            };
+        }
+    }
+    // tanstack-query
+    if (config['tanstack-query'] !== undefined) {
+        if (typeof config['tanstack-query'].output !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid output format for tanstack-query: ${String(config['tanstack-query'].output)}`,
+            };
+        }
+        if (typeof config['tanstack-query'].import !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid import format for tanstack-query: ${String(config['tanstack-query'].import)}`,
+            };
+        }
+        if (config['tanstack-query'].split !== undefined &&
+            typeof config['tanstack-query'].split !== 'boolean') {
+            return {
+                ok: false,
+                error: `Invalid split format for tanstack-query: ${String(config['tanstack-query'].split)}`,
+            };
+        }
+        if (config['tanstack-query'].client !== undefined &&
+            typeof config['tanstack-query'].client !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid client format for tanstack-query: ${String(config['tanstack-query'].client)}`,
+            };
+        }
+        // split: true requires directory (no .ts)
+        if (config['tanstack-query'].split === true && isTs(config['tanstack-query'].output)) {
+            return {
+                ok: false,
+                error: `Invalid tanstack-query output path for split mode (must be a directory, not .ts): ${config['tanstack-query'].output}`,
+            };
+        }
+    }
+    // svelte-query
+    if (config['svelte-query'] !== undefined) {
+        if (typeof config['svelte-query'].output !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid output format for svelte-query: ${String(config['svelte-query'].output)}`,
+            };
+        }
+        if (typeof config['svelte-query'].import !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid import format for svelte-query: ${String(config['svelte-query'].import)}`,
+            };
+        }
+        if (config['svelte-query'].split !== undefined &&
+            typeof config['svelte-query'].split !== 'boolean') {
+            return {
+                ok: false,
+                error: `Invalid split format for svelte-query: ${String(config['svelte-query'].split)}`,
+            };
+        }
+        if (config['svelte-query'].client !== undefined &&
+            typeof config['svelte-query'].client !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid client format for svelte-query: ${String(config['svelte-query'].client)}`,
+            };
+        }
+        // split: true requires directory (no .ts)
+        if (config['svelte-query'].split === true && isTs(config['svelte-query'].output)) {
+            return {
+                ok: false,
+                error: `Invalid svelte-query output path for split mode (must be a directory, not .ts): ${config['svelte-query'].output}`,
+            };
+        }
+    }
+    // vue-query
+    if (config['vue-query'] !== undefined) {
+        if (typeof config['vue-query'].output !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid output format for vue-query: ${String(config['vue-query'].output)}`,
+            };
+        }
+        if (typeof config['vue-query'].import !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid import format for vue-query: ${String(config['vue-query'].import)}`,
+            };
+        }
+        if (config['vue-query'].split !== undefined && typeof config['vue-query'].split !== 'boolean') {
+            return {
+                ok: false,
+                error: `Invalid split format for vue-query: ${String(config['vue-query'].split)}`,
+            };
+        }
+        if (config['vue-query'].client !== undefined &&
+            typeof config['vue-query'].client !== 'string') {
+            return {
+                ok: false,
+                error: `Invalid client format for vue-query: ${String(config['vue-query'].client)}`,
+            };
+        }
+        // split: true requires directory (no .ts)
+        if (config['vue-query'].split === true && isTs(config['vue-query'].output)) {
+            return {
+                ok: false,
+                error: `Invalid vue-query output path for split mode (must be a directory, not .ts): ${config['vue-query'].output}`,
+            };
+        }
+    }
     const result = {
         ...config,
         ...(config['zod-openapi'] && {
@@ -320,6 +449,38 @@ export function parseConfig(config) {
                     : config.rpc.output,
             },
         }),
+        ...(config.swr && {
+            swr: {
+                ...config.swr,
+                output: config.swr.split !== true && !isTs(config.swr.output)
+                    ? `${config.swr.output}/index.ts`
+                    : config.swr.output,
+            },
+        }),
+        ...(config['tanstack-query'] && {
+            'tanstack-query': {
+                ...config['tanstack-query'],
+                output: config['tanstack-query'].split !== true && !isTs(config['tanstack-query'].output)
+                    ? `${config['tanstack-query'].output}/index.ts`
+                    : config['tanstack-query'].output,
+            },
+        }),
+        ...(config['svelte-query'] && {
+            'svelte-query': {
+                ...config['svelte-query'],
+                output: config['svelte-query'].split !== true && !isTs(config['svelte-query'].output)
+                    ? `${config['svelte-query'].output}/index.ts`
+                    : config['svelte-query'].output,
+            },
+        }),
+        ...(config['vue-query'] && {
+            'vue-query': {
+                ...config['vue-query'],
+                output: config['vue-query'].split !== true && !isTs(config['vue-query'].output)
+                    ? `${config['vue-query'].output}/index.ts`
+                    : config['vue-query'].output,
+            },
+        }),
     };
     return {
         ok: true,

package/dist/core/index.d.ts

@@ -3,8 +3,13 @@
  *
  * @module core
  */
+export { makeQueryHooks } from '../helper/query.js';
 export * from './components/index.js';
 export { route } from './route/index.js';
 export { rpc } from './rpc/index.js';
+export { svelteQuery } from './svelte-query/index.js';
+export { swr } from './swr/index.js';
 export { takibi } from './takibi/index.js';
+export { tanstackQuery } from './tanstack-query/index.js';
 export { type } from './type/index.js';
+export { vueQuery } from './vue-query/index.js';

package/dist/core/index.js

@@ -3,9 +3,15 @@
  *
  * @module core
  */
+// Shared query module
+export { makeQueryHooks } from '../helper/query.js';
 export * from './components/index.js';
 // Generation functions
 export { route } from './route/index.js';
 export { rpc } from './rpc/index.js';
+export { svelteQuery } from './svelte-query/index.js';
+export { swr } from './swr/index.js';
 export { takibi } from './takibi/index.js';
+export { tanstackQuery } from './tanstack-query/index.js';
 export { type } from './type/index.js';
+export { vueQuery } from './vue-query/index.js';

package/dist/core/rpc/index.d.ts

@@ -1,4 +1,39 @@
 import type { OpenAPI } from '../../openapi/index.js';
+/**
+ * Generates RPC client wrapper functions from OpenAPI specification.
+ *
+ * Creates type-safe client functions that wrap Hono RPC client calls,
+ * with proper TypeScript types derived from OpenAPI schemas.
+ *
+ * ```mermaid
+ * flowchart LR
+ *   subgraph "Generated Code"
+ *     A["export async function getUsers(params) { return await client.users.$get(params) }"]
+ *   end
+ *   subgraph "Usage"
+ *     B["const users = await getUsers({ query: { limit: 10 } })"]
+ *   end
+ *   A --> B
+ * ```
+ *
+ * @param openAPI - Parsed OpenAPI specification
+ * @param output - Output file path or directory
+ * @param importPath - Import path for the Hono client
+ * @param split - Whether to split into multiple files (one per operation)
+ * @param clientName - Name of the client export (default: 'client')
+ * @returns Promise resolving to success message or error
+ *
+ * @example
+ * ```ts
+ * // Single file output
+ * await rpc(openAPI, 'src/rpc.ts', './client')
+ * // Generates: src/rpc.ts with all RPC functions
+ *
+ * // Split mode output
+ * await rpc(openAPI, 'src/rpc', './client', true)
+ * // Generates: src/rpc/getUsers.ts, src/rpc/postUsers.ts, src/rpc/index.ts
+ * ```
+ */
 export declare function rpc(openAPI: OpenAPI, output: string | `${string}.ts`, importPath: string, split?: boolean, clientName?: string): Promise<{
     readonly ok: true;
     readonly value: string;