hono-takibi 0.9.76 → 0.9.78

package/README.md

@@ -75,7 +75,9 @@ export const getRoute = createRoute({
       description: 'OK',
       content: {
         'application/json': {
-          schema: z.object({ message: z.string().openapi({ example: 'Hono Takibi🔥' }) }),
+          schema: z
+            .object({ message: z.string().openapi({ example: 'Hono Takibi🔥' }) })
+            .openapi({ required: ['message'] }),
         },
       },
     },

package/dist/cli/index.js

@@ -227,7 +227,7 @@ export async function honoTakibi() {
             ? type(openAPI, config.type.output, config.type.readonly)
             : Promise.resolve(undefined),
         config.rpc
-            ? rpc(openAPI, config.rpc.output, config.rpc.import, config.rpc.split ?? false)
+            ? rpc(openAPI, config.rpc.output, config.rpc.import, config.rpc.split ?? false, config.rpc.client ?? 'client')
             : Promise.resolve(undefined),
     ]);
     if (takibiResult && !takibiResult.ok)

package/dist/config/index.d.ts

@@ -78,6 +78,7 @@ type Config = {
         readonly output: string | `${string}.ts`;
         readonly import: string;
         readonly split?: boolean;
+        readonly client?: string;
     };
 };
 /**

package/dist/config/index.js

@@ -199,6 +199,9 @@ export function parseConfig(config) {
         if (config.rpc.split !== undefined && typeof config.rpc.split !== 'boolean') {
             return { ok: false, error: `Invalid split format for rpc: ${String(config.rpc.split)}` };
         }
+        if (config.rpc.client !== undefined && typeof config.rpc.client !== 'string') {
+            return { ok: false, error: `Invalid client format for rpc: ${String(config.rpc.client)}` };
+        }
         // split: true requires directory (no .ts)
         if (config.rpc.split === true && isTs(config.rpc.output)) {
             return {

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

@@ -1,5 +1,5 @@
 import type { OpenAPI } from '../../openapi/index.js';
-export declare function rpc(openAPI: OpenAPI, output: string | `${string}.ts`, importPath: string, split?: boolean): Promise<{
+export declare function rpc(openAPI: OpenAPI, output: string | `${string}.ts`, importPath: string, split?: boolean, clientName?: string): Promise<{
     readonly ok: true;
     readonly value: string;
 } | {

package/dist/core/rpc/index.js

@@ -293,16 +293,17 @@ const resolveSplitOutDir = (output) => {
  *
  * @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) => {
+const makeHeader = (importPath, needsInferRequestType, clientName) => {
     const typeImports = needsInferRequestType
         ? 'InferRequestType,ClientRequestOptions'
         : 'ClientRequestOptions';
-    return `import type{${typeImports}}from'hono/client'\nimport{client}from'${importPath}'\n\n`;
+    return `import type{${typeImports}}from'hono/client'\nimport{${clientName}}from'${importPath}'\n\n`;
 };
-export async function rpc(openAPI, output, importPath, split) {
-    const client = 'client';
+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' };
@@ -322,7 +323,7 @@ export async function rpc(openAPI, output, importPath, split) {
     if (!split) {
         const body = operationCodes.map(({ code }) => code).join('\n\n');
         const needsInferRequestType = operationCodes.some(({ hasArgs }) => hasArgs);
-        const header = makeHeader(importPath, needsInferRequestType);
+        const header = makeHeader(importPath, needsInferRequestType, client);
         const code = `${header}${body}${operationCodes.length ? '\n' : ''}`;
         const coreResult = await core(code, path.dirname(output), output);
         if (!coreResult.ok)
@@ -335,7 +336,7 @@ export async function rpc(openAPI, output, importPath, split) {
     const index = `${exportLines.join('\n')}\n`;
     const allResults = await Promise.all([
         ...operationCodes.map(({ funcName, code, hasArgs }) => {
-            const header = makeHeader(importPath, hasArgs);
+            const header = makeHeader(importPath, hasArgs, client);
             const fileSrc = `${header}${code}\n`;
             const filePath = path.join(outDir, `${funcName}.ts`);
             return core(fileSrc, path.dirname(filePath), filePath);

package/dist/vite-plugin/index.js

@@ -368,7 +368,7 @@ const runAllGenerationTasks = async (configuration) => {
                 const outputDirectory = toAbsolutePath(rpcConfig.output);
                 const beforeFiles = await listTypeScriptFilesShallow(outputDirectory);
                 await deleteTypeScriptFiles(beforeFiles);
-                const rpcResult = await rpc(openAPI, outputDirectory, rpcConfig.import, true);
+                const rpcResult = await rpc(openAPI, outputDirectory, rpcConfig.import, true, rpcConfig.client ?? 'client');
                 if (!rpcResult.ok)
                     return `✗ rpc(split): ${rpcResult.error}`;
                 return beforeFiles.length > 0
@@ -376,7 +376,7 @@ const runAllGenerationTasks = async (configuration) => {
                     : `✓ rpc(split) -> ${outputDirectory}/*.ts`;
             }
             const outputPath = toAbsolutePath(rpcConfig.output);
-            const rpcResult = await rpc(openAPI, outputPath, rpcConfig.import, false);
+            const rpcResult = await rpc(openAPI, outputPath, rpcConfig.import, false, rpcConfig.client ?? 'client');
             return rpcResult.ok ? `✓ rpc -> ${outputPath}` : `✗ rpc: ${rpcResult.error}`;
         })();
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
-  "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.9.76",
+  "description": "Hono Takibi is a code generator from OpenAPI to @hono/zod-openapi",
+  "version": "0.9.78",
   "type": "module",
   "license": "MIT",
   "keywords": [