hono-takibi 0.9.78 → 0.9.80

package/dist/core/rpc/index.js

@@ -18,240 +18,49 @@
  * @link https://github.com/honojs/hono/blob/main/src/client/types.ts#L46-L76
  */
 import path from 'node:path';
-import { core } from '../../helper/index.js';
+import { buildInferRequestType, buildOperationDocs, core, createOperationDeps, formatPath, HTTP_METHODS, isOpenAPIPaths, isOperationLike, operationHasArgs, parsePathItem, resolveSplitOutDir, } from '../../helper/index.js';
 import { isRecord, methodPath } from '../../utils/index.js';
-/* ─────────────────────────────── Guards ─────────────────────────────── */
-const isOpenAPIPaths = (v) => {
-    if (!isRecord(v))
-        return false;
-    for (const k in v) {
-        if (!isRecord(v[k]))
-            return false;
-    }
-    return true;
-};
-/* ─────────────────────────────── Formatters ─────────────────────────────── */
-const esc = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-/** Check if a string is a valid JavaScript identifier */
-const isValidIdent = (s) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
-/**
- * Format path for Hono RPC access (both type and runtime).
- * Hono hc client uses PathToChain which splits paths by '/'.
- *
- * Rules:
- * - '/' -> '.index'
- * - Valid identifiers use dot notation: '/users' -> '.users'
- * - Invalid identifiers use bracket notation: '/:id' -> "[':id']"
- * - Path params converted: '/files/{fileId}' -> ".files[':fileId']"
- *
- * For InferRequestType, when bracket notation exists in the path,
- * we need to wrap `typeof client.<prefix>` in parentheses and use
- * all bracket notation after:
- * - `/users/{id}` -> type: `(typeof client.users)[':id']['$get']`
- * - `/users/{id}/avatar` -> type: `(typeof client.users)[':id']['avatar']['$post']`
- */
-const formatPath = (p) => {
-    if (p === '/') {
-        return {
-            runtimePath: '.index',
-            typeofPrefix: '.index',
-            bracketSuffix: '',
-            hasBracket: false,
-        };
-    }
-    const segs = p.replace(/^\/+/, '').split('/').filter(Boolean);
-    // Convert {param} to :param (handles both full segments like {id} and partial like {Sid}.json)
-    const honoSegs = segs.map((seg) => seg.replace(/\{([^}]+)\}/g, ':$1'));
-    // Find the first segment that needs bracket notation
-    const firstBracketIdx = honoSegs.findIndex((seg) => !isValidIdent(seg));
-    const hasBracket = firstBracketIdx !== -1;
-    // Runtime path: mixed notation (current behavior)
-    const runtimeParts = honoSegs.map((seg) => (isValidIdent(seg) ? `.${seg}` : `['${esc(seg)}']`));
-    const runtimePath = runtimeParts.join('');
-    // For type expression: split at first bracket
-    const typeofPrefix = hasBracket
-        ? honoSegs
-            .slice(0, firstBracketIdx)
-            .map((seg) => `.${seg}`)
-            .join('')
-        : runtimePath;
-    const bracketSuffix = hasBracket
-        ? honoSegs
-            .slice(firstBracketIdx)
-            .map((seg) => `['${esc(seg)}']`)
-            .join('')
-        : '';
-    return { runtimePath, typeofPrefix, bracketSuffix, hasBracket };
-};
-const isRefObject = (v) => isRecord(v) && typeof v.$ref === 'string';
-const isParameterObject = (v) => {
-    if (!isRecord(v))
-        return false;
-    if (typeof v.name !== 'string')
-        return false;
-    const pos = v.in;
-    return pos === 'path' || pos === 'query' || pos === 'header' || pos === 'cookie';
-};
-const refParamName = (refLike) => {
-    const ref = typeof refLike === 'string' ? refLike : isRefObject(refLike) ? refLike.$ref : undefined;
-    const m = ref?.match(/^#\/components\/parameters\/(.+)$/);
-    return m ? m[1] : undefined;
-};
-const createResolveParameter = (componentsParameters) => (p) => {
-    if (isParameterObject(p))
-        return p;
-    const name = refParamName(p);
-    const cand = name ? componentsParameters[name] : undefined;
-    return isParameterObject(cand) ? cand : undefined;
-};
-const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr) ? arr.map((x) => resolveParam(x)).filter((param) => param !== undefined) : [];
-const isOperationLike = (v) => isRecord(v) && 'responses' in v;
-const HTTP_METHODS = [
-    'get',
-    'put',
-    'post',
-    'delete',
-    'options',
-    'head',
-    'patch',
-    'trace',
-];
-const hasSchemaProp = (v) => isRecord(v) && 'schema' in v;
-/** Extract requestBody name from $ref like "#/components/requestBodies/CreateProduct" */
-const refRequestBodyName = (refLike) => {
-    const ref = typeof refLike === 'string' ? refLike : isRefObject(refLike) ? refLike.$ref : undefined;
-    const m = ref?.match(/^#\/components\/requestBodies\/(.+)$/);
-    return m ? m[1] : undefined;
-};
-/**
- * Collect all body infos from content to handle multiple content-types.
- * Groups by body key ('form' or 'json') with union types.
- */
-const pickAllBodyInfoFromContent = (content) => {
-    if (!isRecord(content))
-        return undefined;
-    const formContentTypes = ['multipart/form-data', 'application/x-www-form-urlencoded'];
-    const isFormContentType = (ct) => formContentTypes.includes(ct.split(';')[0].trim());
-    const validEntries = Object.entries(content).filter(([_, mediaObj]) => isRecord(mediaObj) && hasSchemaProp(mediaObj) && isRecord(mediaObj.schema));
-    const formInfos = validEntries
-        .filter(([ct]) => isFormContentType(ct))
-        .map(([ct]) => ({ contentType: ct }));
-    const jsonInfos = validEntries
-        .filter(([ct]) => !isFormContentType(ct))
-        .map(([ct]) => ({ contentType: ct }));
-    if (formInfos.length === 0 && jsonInfos.length === 0)
-        return undefined;
-    return { form: formInfos, json: jsonInfos };
-};
-const createPickAllBodyInfo = (componentsRequestBodies) => (op) => {
-    const rb = op.requestBody;
-    if (!isRecord(rb))
-        return undefined;
-    // Handle $ref to components/requestBodies
-    const refName = refRequestBodyName(rb);
-    if (refName) {
-        const resolved = componentsRequestBodies[refName];
-        if (isRecord(resolved) && isRecord(resolved.content)) {
-            return pickAllBodyInfoFromContent(resolved.content);
-        }
-        // If $ref exists but can't resolve content, still consider it has a body
-        if (resolved !== undefined)
-            return { form: [], json: [{ contentType: 'application/json' }] };
-        return undefined;
-    }
-    // Direct inline requestBody
-    return pickAllBodyInfoFromContent(rb.content);
-};
-const generateOperationCode = (pathStr, method, item, deps) => {
+/* ─────────────────────────────── Single-operation generator ─────────────────────────────── */
+const makeOperationCode = (pathStr, method, item, deps) => {
     const op = item[method];
     if (!isOperationLike(op))
         return null;
     const funcName = methodPath(method, pathStr);
-    const { runtimePath, typeofPrefix, bracketSuffix, hasBracket } = formatPath(pathStr);
-    const pathLevelParams = deps.toParameterLikes(item.parameters);
-    const opParams = deps.toParameterLikes(op.parameters);
-    const allParams = [...pathLevelParams, ...opParams];
-    const pathParams = allParams.filter((p) => p.in === 'path');
-    const queryParams = allParams.filter((p) => p.in === 'query');
-    const headerParams = allParams.filter((p) => p.in === 'header');
-    const cookieParams = allParams.filter((p) => p.in === 'cookie');
-    const allBodyInfo = deps.pickAllBodyInfo(op);
-    const hasBody = allBodyInfo !== undefined && (allBodyInfo.form.length > 0 || allBodyInfo.json.length > 0);
-    const hasArgs = pathParams.length > 0 ||
-        queryParams.length > 0 ||
-        headerParams.length > 0 ||
-        cookieParams.length > 0 ||
-        hasBody;
-    // For runtime calls, always use dot notation for method access
-    const methodAccess = `.$${method}`;
-    // For InferRequestType, handle bracket notation properly:
-    // - No bracket: `typeof client.users.$get`
-    // - With bracket: `(typeof client.users)[':id']['avatar']['$post']`
-    const inferType = hasBracket
-        ? `InferRequestType<(typeof ${deps.client}${typeofPrefix})${bracketSuffix}['$${method}']>`
-        : `InferRequestType<typeof ${deps.client}${runtimePath}.$${method}>`;
+    const pathResult = formatPath(pathStr);
+    const hasArgs = operationHasArgs(item, op, deps);
+    const inferType = buildInferRequestType(deps.client, pathResult, method);
     const argSig = hasArgs
         ? `args:${inferType},options?:ClientRequestOptions`
         : 'options?:ClientRequestOptions';
     const call = hasArgs
-        ? `${deps.client}${runtimePath}${methodAccess}(args,options)`
-        : `${deps.client}${runtimePath}${methodAccess}(undefined,options)`;
+        ? `${deps.client}${pathResult.runtimePath}.$${method}(args,options)`
+        : `${deps.client}${pathResult.runtimePath}.$${method}(undefined,options)`;
     const summary = typeof op.summary === 'string' ? op.summary : '';
     const description = typeof op.description === 'string' ? op.description : '';
-    // Format multiline description with JSDoc prefix on each line
-    const formatJsDocLines = (text) => text
-        .trimEnd()
-        .split('\n')
-        .map((line) => ` * ${line}`);
-    // Escape /* in path to avoid oxfmt regex parsing issue (/* looks like /regex/)
-    const safePathStr = pathStr.replace(/\/\*/g, '/[*]');
-    const docs = [
-        '/**',
-        ` * ${method.toUpperCase()} ${safePathStr}`,
-        ...(summary ? [' *', ...formatJsDocLines(summary)] : []),
-        ...(description ? [' *', ...formatJsDocLines(description)] : []),
-        ' */',
-    ].join('\n');
+    const docs = buildOperationDocs(method, pathStr, summary || undefined, description || undefined);
     const func = `export async function ${funcName}(${argSig}){return await ${call}}`;
     return { code: `${docs}\n${func}`, hasArgs };
 };
 /**
  * Builds operation codes from OpenAPI paths.
- *
- * Iterates through all HTTP methods for each path and generates
- * typed RPC client wrapper functions.
- *
- * @param paths - OpenAPI paths object
- * @param deps - Dependencies including client name and parameter utilities
- * @returns Array of operation codes with function names and generated code
  */
 const makeOperationCodes = (paths, deps) => Object.entries(paths)
     .filter((entry) => isRecord(entry[1]))
     .flatMap(([p, rawItem]) => {
-    const pathItem = {
-        parameters: rawItem.parameters,
-        get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
-        put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
-        post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
-        delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
-        options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
-        head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
-        patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
-        trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
-    };
+    const pathItem = parsePathItem(rawItem);
     return HTTP_METHODS.map((method) => {
-        const result = generateOperationCode(p, method, pathItem, deps);
+        const result = makeOperationCode(p, method, pathItem, deps);
         return result
             ? { funcName: methodPath(method, p), code: result.code, hasArgs: result.hasArgs }
             : null;
     }).filter((item) => item !== null);
 });
-/* ─────────────────────────────── Split ─────────────────────────────── */
-const resolveSplitOutDir = (output) => {
-    const looksLikeFile = output.endsWith('.ts');
-    const outDir = looksLikeFile ? path.dirname(output) : output;
-    const indexPath = path.join(outDir, 'index.ts');
-    return { outDir, indexPath };
+/* ─────────────────────────────── Header ─────────────────────────────── */
+const makeHeader = (importPath, needsInferRequestType, clientName) => {
+    const typeImports = needsInferRequestType
+        ? 'InferRequestType,ClientRequestOptions'
+        : 'ClientRequestOptions';
+    return `import type{${typeImports}}from'hono/client'\nimport{${clientName}}from'${importPath}'\n\n`;
 };
 /* ─────────────────────────────── Entry ─────────────────────────────── */
 /**
@@ -275,6 +84,7 @@ const resolveSplitOutDir = (output) => {
  * @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
@@ -288,42 +98,20 @@ const resolveSplitOutDir = (output) => {
  * // Generates: src/rpc/getUsers.ts, src/rpc/postUsers.ts, src/rpc/index.ts
  * ```
  */
-/**
- * Generates the import header for RPC client files.
- *
- * @param importPath - The import path for the Hono client
- * @param needsInferRequestType - Whether InferRequestType import is needed
- * @param clientName - The name of the client to import (default: 'client')
- * @returns Import header string
- */
-const makeHeader = (importPath, needsInferRequestType, clientName) => {
-    const typeImports = needsInferRequestType
-        ? 'InferRequestType,ClientRequestOptions'
-        : 'ClientRequestOptions';
-    return `import type{${typeImports}}from'hono/client'\nimport{${clientName}}from'${importPath}'\n\n`;
-};
 export async function rpc(openAPI, output, importPath, split, clientName = 'client') {
-    const client = clientName;
     const pathsMaybe = openAPI.paths;
     if (!isOpenAPIPaths(pathsMaybe)) {
         return { ok: false, error: 'Invalid OpenAPI paths' };
     }
     const componentsParameters = openAPI.components?.parameters ?? {};
     const componentsRequestBodies = openAPI.components?.requestBodies ?? {};
-    const resolveParameter = createResolveParameter(componentsParameters);
-    const toParameterLikes = createToParameterLikes(resolveParameter);
-    const pickAllBodyInfo = createPickAllBodyInfo(componentsRequestBodies);
-    const deps = {
-        client,
-        toParameterLikes,
-        pickAllBodyInfo,
-    };
+    const deps = createOperationDeps(clientName, componentsParameters, componentsRequestBodies);
     const operationCodes = makeOperationCodes(pathsMaybe, deps);
     // Non-split: write single file
     if (!split) {
         const body = operationCodes.map(({ code }) => code).join('\n\n');
         const needsInferRequestType = operationCodes.some(({ hasArgs }) => hasArgs);
-        const header = makeHeader(importPath, needsInferRequestType, client);
+        const header = makeHeader(importPath, needsInferRequestType, clientName);
         const code = `${header}${body}${operationCodes.length ? '\n' : ''}`;
         const coreResult = await core(code, path.dirname(output), output);
         if (!coreResult.ok)
@@ -336,7 +124,7 @@ export async function rpc(openAPI, output, importPath, split, clientName = 'clie
     const index = `${exportLines.join('\n')}\n`;
     const allResults = await Promise.all([
         ...operationCodes.map(({ funcName, code, hasArgs }) => {
-            const header = makeHeader(importPath, hasArgs, client);
+            const header = makeHeader(importPath, hasArgs, clientName);
             const fileSrc = `${header}${code}\n`;
             const filePath = path.join(outDir, `${funcName}.ts`);
             return core(fileSrc, path.dirname(filePath), filePath);

package/dist/core/svelte-query/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Svelte Query hook generation module.
+ *
+ * Generates type-safe Svelte Query hooks from OpenAPI specifications
+ * for use with Hono's RPC client.
+ *
+ * - GET operations generate `createQuery` hooks
+ * - POST/PUT/DELETE/PATCH operations generate `createMutation` hooks
+ *
+ * ```mermaid
+ * flowchart TD
+ *   A["svelteQuery(openAPI, output, importPath, split)"] --> B["Parse OpenAPI paths"]
+ *   B --> C["Build hook codes"]
+ *   C --> D{"split mode?"}
+ *   D -->|No| E["Write single file"]
+ *   D -->|Yes| F["Write per-hook files"]
+ *   F --> G["Write index.ts barrel"]
+ * ```
+ *
+ * @module core/svelte-query
+ * @link https://tanstack.com/query/latest/docs/framework/svelte/overview
+ * @link https://hono.dev/docs/guides/rpc
+ */
+import type { OpenAPI } from '../../openapi/index.js';
+/**
+ * Generates Svelte Query hooks from OpenAPI specification.
+ *
+ * Creates type-safe Svelte Query hooks that wrap Hono RPC client calls,
+ * with proper TypeScript types derived from OpenAPI schemas.
+ *
+ * - GET operations generate `createQuery` hooks
+ * - POST/PUT/DELETE/PATCH operations generate `createMutation` hooks
+ *
+ * ```mermaid
+ * flowchart LR
+ *   subgraph "Generated Code"
+ *     A["export function createGetUsers(...) { return createQuery(...) }"]
+ *   end
+ *   subgraph "Usage"
+ *     B["const { data, error } = createGetUsers({ 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 hook)
+ * @param clientName - Name of the client export (default: 'client')
+ * @returns Promise resolving to success message or error
+ *
+ * @example
+ * ```ts
+ * // Single file output
+ * await svelteQuery(openAPI, 'src/hooks.ts', './client')
+ * // Generates: src/hooks.ts with all Svelte Query hooks
+ *
+ * // Split mode output
+ * await svelteQuery(openAPI, 'src/hooks', './client', true)
+ * // Generates: src/hooks/createGetUsers.ts, src/hooks/createPostUsers.ts, src/hooks/index.ts
+ * ```
+ */
+export declare function svelteQuery(openAPI: OpenAPI, output: string | `${string}.ts`, importPath: string, split?: boolean, clientName?: string): Promise<{
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+}>;

package/dist/core/svelte-query/index.js

@@ -0,0 +1,77 @@
+/**
+ * Svelte Query hook generation module.
+ *
+ * Generates type-safe Svelte Query hooks from OpenAPI specifications
+ * for use with Hono's RPC client.
+ *
+ * - GET operations generate `createQuery` hooks
+ * - POST/PUT/DELETE/PATCH operations generate `createMutation` hooks
+ *
+ * ```mermaid
+ * flowchart TD
+ *   A["svelteQuery(openAPI, output, importPath, split)"] --> B["Parse OpenAPI paths"]
+ *   B --> C["Build hook codes"]
+ *   C --> D{"split mode?"}
+ *   D -->|No| E["Write single file"]
+ *   D -->|Yes| F["Write per-hook files"]
+ *   F --> G["Write index.ts barrel"]
+ * ```
+ *
+ * @module core/svelte-query
+ * @link https://tanstack.com/query/latest/docs/framework/svelte/overview
+ * @link https://hono.dev/docs/guides/rpc
+ */
+import { makeQueryHooks } from '../../helper/query.js';
+/**
+ * Generates Svelte Query hooks from OpenAPI specification.
+ *
+ * Creates type-safe Svelte Query hooks that wrap Hono RPC client calls,
+ * with proper TypeScript types derived from OpenAPI schemas.
+ *
+ * - GET operations generate `createQuery` hooks
+ * - POST/PUT/DELETE/PATCH operations generate `createMutation` hooks
+ *
+ * ```mermaid
+ * flowchart LR
+ *   subgraph "Generated Code"
+ *     A["export function createGetUsers(...) { return createQuery(...) }"]
+ *   end
+ *   subgraph "Usage"
+ *     B["const { data, error } = createGetUsers({ 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 hook)
+ * @param clientName - Name of the client export (default: 'client')
+ * @returns Promise resolving to success message or error
+ *
+ * @example
+ * ```ts
+ * // Single file output
+ * await svelteQuery(openAPI, 'src/hooks.ts', './client')
+ * // Generates: src/hooks.ts with all Svelte Query hooks
+ *
+ * // Split mode output
+ * await svelteQuery(openAPI, 'src/hooks', './client', true)
+ * // Generates: src/hooks/createGetUsers.ts, src/hooks/createPostUsers.ts, src/hooks/index.ts
+ * ```
+ */
+export async function svelteQuery(openAPI, output, importPath, split, clientName = 'client') {
+    // Svelte Query v5+ requires thunk pattern: createQuery(() => options)
+    // @see https://tanstack.com/query/v5/docs/framework/svelte/reactivity
+    const config = {
+        packageName: '@tanstack/svelte-query',
+        frameworkName: 'Svelte Query',
+        hookPrefix: 'create',
+        queryFn: 'createQuery',
+        mutationFn: 'createMutation',
+        useThunk: true,
+        useQueryOptionsType: 'CreateQueryOptions',
+        useMutationOptionsType: 'CreateMutationOptions',
+    };
+    return makeQueryHooks(openAPI, output, importPath, config, split, clientName);
+}

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

@@ -0,0 +1,46 @@
+import type { OpenAPI } from '../../openapi/index.js';
+/**
+ * Generates SWR hooks from OpenAPI specification.
+ *
+ * Creates type-safe SWR hooks that wrap Hono RPC client calls,
+ * with proper TypeScript types derived from OpenAPI schemas.
+ *
+ * - GET operations generate `useSWR` hooks
+ * - POST/PUT/DELETE/PATCH operations generate `useSWRMutation` hooks
+ *
+ * ```mermaid
+ * flowchart LR
+ *   subgraph "Generated Code"
+ *     A["export function useGetUsers(...) { return useSWR(...) }"]
+ *   end
+ *   subgraph "Usage"
+ *     B["const { data, error } = useGetUsers({ 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 hook)
+ * @param clientName - Name of the client export (default: 'client')
+ * @returns Promise resolving to success message or error
+ *
+ * @example
+ * ```ts
+ * // Single file output
+ * await swr(openAPI, 'src/hooks.ts', './client')
+ * // Generates: src/hooks.ts with all SWR hooks
+ *
+ * // Split mode output
+ * await swr(openAPI, 'src/hooks', './client', true)
+ * // Generates: src/hooks/useGetUsers.ts, src/hooks/usePostUsers.ts, src/hooks/index.ts
+ * ```
+ */
+export declare function swr(openAPI: OpenAPI, output: string | `${string}.ts`, importPath: string, split?: boolean, clientName?: string): Promise<{
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+}>;