hono-takibi 0.9.73 → 0.9.74

package/dist/cli/index.js

@@ -154,8 +154,8 @@ export async function honoTakibi() {
         const cliResult = parseCli(args);
         if (!cliResult.ok)
             return { ok: false, error: cliResult.error };
-        const cli = cliResult.value;
-        const { input, output, template, test, basePath, componentsOptions } = cli;
+        const value = cliResult.value;
+        const { input, output, template, test, basePath, componentsOptions } = value;
         const openAPIResult = await parseOpenAPI(input);
         if (!openAPIResult.ok)
             return { ok: false, error: openAPIResult.error };
@@ -165,10 +165,10 @@ export async function honoTakibi() {
             return { ok: false, error: takibiResult.error };
         return { ok: true, value: takibiResult.value };
     }
-    const loadConfigResult = await readConfig();
-    if (!loadConfigResult.ok)
-        return { ok: false, error: loadConfigResult.error };
-    const config = loadConfigResult.value;
+    const readConfigResult = await readConfig();
+    if (!readConfigResult.ok)
+        return { ok: false, error: readConfigResult.error };
+    const config = readConfigResult.value;
     const openAPIResult = await parseOpenAPI(config.input);
     if (!openAPIResult.ok)
         return { ok: false, error: openAPIResult.error };
@@ -268,253 +268,3 @@ export async function honoTakibi() {
     ].filter((v) => v !== undefined);
     return { ok: true, value: results.join('\n') };
 }
-// Test run
-// pnpm vitest run ./packages/hono-takibi/src/cli/index.ts
-if (import.meta.vitest) {
-    const { describe, it, expect, beforeAll, afterAll } = import.meta.vitest;
-    const fs = await import('node:fs');
-    const openapi = {
-        openapi: '3.1.0',
-        info: {
-            title: 'HonoTakibi',
-            version: 'v1',
-        },
-        tags: [{ name: 'Hono' }, { name: 'HonoX' }, { name: 'ZodOpenAPIHono' }],
-        paths: {
-            '/hono': {
-                get: {
-                    tags: ['Hono'],
-                    summary: 'Hono',
-                    description: 'Hono',
-                    responses: {
-                        '200': {
-                            description: 'OK',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            message: {
-                                                type: 'string',
-                                                example: 'Hono',
-                                            },
-                                        },
-                                        required: ['message'],
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            '/hono-x': {
-                get: {
-                    tags: ['HonoX'],
-                    summary: 'HonoX',
-                    description: 'HonoX',
-                    responses: {
-                        '200': {
-                            description: 'OK',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            message: {
-                                                type: 'string',
-                                                example: 'HonoX',
-                                            },
-                                        },
-                                        required: ['message'],
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            '/zod-openapi-hono': {
-                get: {
-                    tags: ['ZodOpenAPIHono'],
-                    summary: 'ZodOpenAPIHono',
-                    description: 'ZodOpenAPIHono',
-                    responses: {
-                        '200': {
-                            description: 'OK',
-                            content: {
-                                'application/json': {
-                                    schema: {
-                                        type: 'object',
-                                        properties: {
-                                            message: {
-                                                type: 'string',
-                                                example: 'ZodOpenAPIHono',
-                                            },
-                                        },
-                                        required: ['message'],
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    };
-    describe('honoTakibi', () => {
-        beforeAll(() => {
-            process.argv = [
-                '*/*/bin/node',
-                '*/dist/index.js',
-                'openapi.json',
-                '-o',
-                'zod-openapi-hono.ts',
-            ];
-            fs.writeFileSync('openapi.json', JSON.stringify(openapi));
-        });
-        afterAll(() => {
-            fs.rmSync('openapi.json', { force: true });
-            fs.rmSync('zod-openapi-hono.ts', { force: true });
-        });
-        it('honoTakibi generated', async () => {
-            const result = await honoTakibi();
-            expect(result).toEqual({
-                ok: true,
-                value: 'Generated code written to zod-openapi-hono.ts',
-            });
-            const generatedCode = fs.readFileSync('zod-openapi-hono.ts', 'utf-8');
-            const expectedCode = `import { createRoute, z } from '@hono/zod-openapi'
-
-export const getHonoRoute = createRoute({
-  method: 'get',
-  path: '/hono',
-  tags: ['Hono'],
-  summary: 'Hono',
-  description: 'Hono',
-  responses: {
-    200: {
-      description: 'OK',
-      content: {
-        'application/json': {
-          schema: z
-            .object({ message: z.string().openapi({ example: 'Hono' }) })
-            .openapi({ required: ['message'] }),
-        },
-      },
-    },
-  },
-})
-
-export const getHonoXRoute = createRoute({
-  method: 'get',
-  path: '/hono-x',
-  tags: ['HonoX'],
-  summary: 'HonoX',
-  description: 'HonoX',
-  responses: {
-    200: {
-      description: 'OK',
-      content: {
-        'application/json': {
-          schema: z
-            .object({ message: z.string().openapi({ example: 'HonoX' }) })
-            .openapi({ required: ['message'] }),
-        },
-      },
-    },
-  },
-})
-
-export const getZodOpenapiHonoRoute = createRoute({
-  method: 'get',
-  path: '/zod-openapi-hono',
-  tags: ['ZodOpenAPIHono'],
-  summary: 'ZodOpenAPIHono',
-  description: 'ZodOpenAPIHono',
-  responses: {
-    200: {
-      description: 'OK',
-      content: {
-        'application/json': {
-          schema: z
-            .object({ message: z.string().openapi({ example: 'ZodOpenAPIHono' }) })
-            .openapi({ required: ['message'] }),
-        },
-      },
-    },
-  },
-})
-`;
-            expect(generatedCode).toBe(expectedCode);
-        });
-    });
-    describe('honoTakibi --help', () => {
-        beforeAll(() => {
-            process.argv = ['*/*/bin/node', '*/dist/index.js', '--help'];
-        });
-        it('honoTakibi help requested --help', async () => {
-            const result = await honoTakibi();
-            expect(result).toStrictEqual({
-                ok: true,
-                value: `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
-
-Options:
-  --export-schemas-types      export schemas types
-  --export-schemas            export schemas
-  --export-parameters-types   export parameters types
-  --export-parameters         export parameters
-  --export-security-schemes   export securitySchemes
-  --export-request-bodies     export requestBodies
-  --export-responses          export responses
-  --export-headers-types      export headers types
-  --export-headers            export headers
-  --export-examples           export examples
-  --export-links              export links
-  --export-callbacks          export callbacks
-  --template                  generate app file and handler stubs
-  --test                      generate empty *.test.ts files
-  --base-path <path>          api prefix (default: /)
-  -h, --help                  display help for command`,
-            });
-        });
-    });
-    describe('honoTakibi -h', () => {
-        beforeAll(() => {
-            process.argv = ['*/*/bin/node', '*/dist/index.js', '-h'];
-        });
-        it('honoTakibi help requested -h', async () => {
-            const result = await honoTakibi();
-            expect(result).toStrictEqual({
-                ok: true,
-                value: `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
-
-Options:
-  --export-schemas-types      export schemas types
-  --export-schemas            export schemas
-  --export-parameters-types   export parameters types
-  --export-parameters         export parameters
-  --export-security-schemes   export securitySchemes
-  --export-request-bodies     export requestBodies
-  --export-responses          export responses
-  --export-headers-types      export headers types
-  --export-headers            export headers
-  --export-examples           export examples
-  --export-links              export links
-  --export-callbacks          export callbacks
-  --template                  generate app file and handler stubs
-  --test                      generate empty *.test.ts files
-  --base-path <path>          api prefix (default: /)
-  -h, --help                  display help for command`,
-            });
-        });
-        describe('honoTakibi missing output', () => {
-            beforeAll(() => {
-                process.argv = ['node', 'dist/index.js', 'openapi.yaml'];
-            });
-            it('should fail if output is not specified', async () => {
-                const result = await honoTakibi();
-                expect(result.ok).toBe(false);
-            });
-        });
-    });
-}

package/dist/config/index.d.ts

@@ -78,6 +78,13 @@ type Config = {
         readonly split?: boolean;
     };
 };
+/**
+ * Validates and parses a hono-takibi configuration object.
+ * When split is false and output doesn't end with .ts, normalizes to {output}/index.ts.
+ *
+ * @param config - The configuration object to validate
+ * @returns Result object with validated and normalized config or error message
+ */
 export declare function parseConfig(config: Config): {
     readonly ok: true;
     readonly value: Config;
@@ -85,6 +92,11 @@ export declare function parseConfig(config: Config): {
     readonly ok: false;
     readonly error: string;
 };
+/**
+ * Reads and validates the hono-takibi configuration from hono-takibi.config.ts.
+ *
+ * @returns Result object with validated config or error message
+ */
 export declare function readConfig(): Promise<{
     readonly ok: true;
     readonly value: Config;
@@ -95,7 +107,8 @@ export declare function readConfig(): Promise<{
 /**
  * Helper to define a config with full type completion.
  *
- * @see config
+ * @param config - The configuration object
+ * @returns The same configuration object (identity function for type inference)
  */
 export declare function defineConfig(config: Config): Config;
 export {};

package/dist/config/index.js

@@ -2,11 +2,17 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { register } from 'tsx/esm/api';
+/**
+ * Validates and parses a hono-takibi configuration object.
+ * When split is false and output doesn't end with .ts, normalizes to {output}/index.ts.
+ *
+ * @param config - The configuration object to validate
+ * @returns Result object with validated and normalized config or error message
+ */
 export function parseConfig(config) {
     const isYamlOrJsonOrTsp = (i) => typeof i === 'string' && (i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp'));
-    // ts
     const isTs = (o) => typeof o === 'string' && o.endsWith('.ts');
-    const parseComponentsValue = (k, v) => {
+    const validateComponentsValue = (k, v) => {
         if (v === undefined)
             return { ok: false, error: `Invalid config: zod-openapi.components.${k} is undefined` };
         if (k === 'schemas' || k === 'parameters' || k === 'headers') {
@@ -25,22 +31,12 @@ export function parseConfig(config) {
                 error: `Invalid split format for components.${k}: ${String(splitValue)}`,
             };
         }
-        const isSplit = splitValue ?? false;
-        if (isSplit) {
-            if (isTs(v.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid ${k} output path for split mode (must be a directory, not .ts): ${v.output}`,
-                };
-            }
-        }
-        else {
-            if (!isTs(v.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid ${k} output path for non-split mode (must be .ts file): ${v.output}`,
-                };
-            }
+        // split: true requires directory (no .ts)
+        if (splitValue === true && isTs(v.output)) {
+            return {
+                ok: false,
+                error: `Invalid ${k} output path for split mode (must be a directory, not .ts): ${v.output}`,
+            };
         }
         if (v.import !== undefined && typeof v.import !== 'string') {
             return {
@@ -48,7 +44,7 @@ export function parseConfig(config) {
                 error: `Invalid import format for components.${k}: ${String(v.import)}`,
             };
         }
-        return { ok: true, value: undefined };
+        return { ok: true };
     };
     if (!isYamlOrJsonOrTsp(config.input)) {
         return {
@@ -151,21 +147,12 @@ export function parseConfig(config) {
                 error: `Invalid split format for routes: ${String(config['zod-openapi'].routes.split)}`,
             };
         }
-        if (config['zod-openapi'].routes.split === true) {
-            if (isTs(config['zod-openapi'].routes.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid routes output path for split mode (must be a directory, not .ts): ${config['zod-openapi'].routes.output}`,
-                };
-            }
-        }
-        else {
-            if (!isTs(config['zod-openapi'].routes.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid routes output path for non-split mode (must be .ts file): ${config['zod-openapi'].routes.output}`,
-                };
-            }
+        // split: true requires directory (no .ts)
+        if (config['zod-openapi'].routes.split === true && isTs(config['zod-openapi'].routes.output)) {
+            return {
+                ok: false,
+                error: `Invalid routes output path for split mode (must be a directory, not .ts): ${config['zod-openapi'].routes.output}`,
+            };
         }
     }
     if (config['zod-openapi']?.components !== undefined) {
@@ -179,7 +166,7 @@ export function parseConfig(config) {
                 k === 'examples' ||
                 k === 'links' ||
                 k === 'callbacks') {
-                const result = parseComponentsValue(k, config['zod-openapi'].components[k]);
+                const result = validateComponentsValue(k, config['zod-openapi'].components[k]);
                 if (!result.ok)
                     return { ok: false, error: result.error };
             }
@@ -205,26 +192,135 @@ 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)}` };
         }
-        // split
-        if (config.rpc.split === true) {
-            if (isTs(config.rpc.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid rpc output path for split mode (must be a directory, not .ts): ${config.rpc.output}`,
-                };
-            }
-        }
-        else {
-            if (!isTs(config.rpc.output)) {
-                return {
-                    ok: false,
-                    error: `Invalid output format for rpc (non-split mode must be .ts file): ${String(config.rpc.output)}`,
-                };
-            }
+        // split: true requires directory (no .ts)
+        if (config.rpc.split === true && isTs(config.rpc.output)) {
+            return {
+                ok: false,
+                error: `Invalid rpc output path for split mode (must be a directory, not .ts): ${config.rpc.output}`,
+            };
         }
     }
-    return { ok: true, value: config };
+    const result = {
+        ...config,
+        ...(config['zod-openapi'] && {
+            'zod-openapi': {
+                ...config['zod-openapi'],
+                ...(config['zod-openapi'].routes && {
+                    routes: {
+                        ...config['zod-openapi'].routes,
+                        output: config['zod-openapi'].routes.split !== true &&
+                            !isTs(config['zod-openapi'].routes.output)
+                            ? `${config['zod-openapi'].routes.output}/index.ts`
+                            : config['zod-openapi'].routes.output,
+                    },
+                }),
+                ...(config['zod-openapi'].components && {
+                    components: {
+                        ...config['zod-openapi'].components,
+                        ...(config['zod-openapi'].components.schemas && {
+                            schemas: {
+                                ...config['zod-openapi'].components.schemas,
+                                output: config['zod-openapi'].components.schemas.split !== true &&
+                                    !isTs(config['zod-openapi'].components.schemas.output)
+                                    ? `${config['zod-openapi'].components.schemas.output}/index.ts`
+                                    : config['zod-openapi'].components.schemas.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.parameters && {
+                            parameters: {
+                                ...config['zod-openapi'].components.parameters,
+                                output: config['zod-openapi'].components.parameters.split !== true &&
+                                    !isTs(config['zod-openapi'].components.parameters.output)
+                                    ? `${config['zod-openapi'].components.parameters.output}/index.ts`
+                                    : config['zod-openapi'].components.parameters.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.securitySchemes && {
+                            securitySchemes: {
+                                ...config['zod-openapi'].components.securitySchemes,
+                                output: config['zod-openapi'].components.securitySchemes.split !== true &&
+                                    !isTs(config['zod-openapi'].components.securitySchemes.output)
+                                    ? `${config['zod-openapi'].components.securitySchemes.output}/index.ts`
+                                    : config['zod-openapi'].components.securitySchemes.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.requestBodies && {
+                            requestBodies: {
+                                ...config['zod-openapi'].components.requestBodies,
+                                output: config['zod-openapi'].components.requestBodies.split !== true &&
+                                    !isTs(config['zod-openapi'].components.requestBodies.output)
+                                    ? `${config['zod-openapi'].components.requestBodies.output}/index.ts`
+                                    : config['zod-openapi'].components.requestBodies.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.responses && {
+                            responses: {
+                                ...config['zod-openapi'].components.responses,
+                                output: config['zod-openapi'].components.responses.split !== true &&
+                                    !isTs(config['zod-openapi'].components.responses.output)
+                                    ? `${config['zod-openapi'].components.responses.output}/index.ts`
+                                    : config['zod-openapi'].components.responses.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.headers && {
+                            headers: {
+                                ...config['zod-openapi'].components.headers,
+                                output: config['zod-openapi'].components.headers.split !== true &&
+                                    !isTs(config['zod-openapi'].components.headers.output)
+                                    ? `${config['zod-openapi'].components.headers.output}/index.ts`
+                                    : config['zod-openapi'].components.headers.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.examples && {
+                            examples: {
+                                ...config['zod-openapi'].components.examples,
+                                output: config['zod-openapi'].components.examples.split !== true &&
+                                    !isTs(config['zod-openapi'].components.examples.output)
+                                    ? `${config['zod-openapi'].components.examples.output}/index.ts`
+                                    : config['zod-openapi'].components.examples.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.links && {
+                            links: {
+                                ...config['zod-openapi'].components.links,
+                                output: config['zod-openapi'].components.links.split !== true &&
+                                    !isTs(config['zod-openapi'].components.links.output)
+                                    ? `${config['zod-openapi'].components.links.output}/index.ts`
+                                    : config['zod-openapi'].components.links.output,
+                            },
+                        }),
+                        ...(config['zod-openapi'].components.callbacks && {
+                            callbacks: {
+                                ...config['zod-openapi'].components.callbacks,
+                                output: config['zod-openapi'].components.callbacks.split !== true &&
+                                    !isTs(config['zod-openapi'].components.callbacks.output)
+                                    ? `${config['zod-openapi'].components.callbacks.output}/index.ts`
+                                    : config['zod-openapi'].components.callbacks.output,
+                            },
+                        }),
+                    },
+                }),
+            },
+        }),
+        ...(config.rpc && {
+            rpc: {
+                ...config.rpc,
+                output: config.rpc.split !== true && !isTs(config.rpc.output)
+                    ? `${config.rpc.output}/index.ts`
+                    : config.rpc.output,
+            },
+        }),
+    };
+    return {
+        ok: true,
+        value: result,
+    };
 }
+/**
+ * Reads and validates the hono-takibi configuration from hono-takibi.config.ts.
+ *
+ * @returns Result object with validated config or error message
+ */
 export async function readConfig() {
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
     if (!existsSync(abs))
@@ -247,69 +343,9 @@ export async function readConfig() {
 /**
  * Helper to define a config with full type completion.
  *
- * @see config
+ * @param config - The configuration object
+ * @returns The same configuration object (identity function for type inference)
  */
 export function defineConfig(config) {
     return config;
 }
-// Test run
-// pnpm vitest run ./packages/hono-takibi/src/config/index.ts
-if (import.meta.vitest) {
-    const { describe, it, expect, beforeEach, afterEach, vi } = import.meta.vitest;
-    const fs = await import('node:fs');
-    const os = await import('node:os');
-    const path = await import('node:path');
-    describe('loadConfig()', () => {
-        const origCwd = process.cwd();
-        beforeEach(() => {
-            vi.resetModules();
-            const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'hono-takibi-config-ts-'));
-            process.chdir(tmpdir);
-        });
-        afterEach(() => {
-            const cwd = process.cwd();
-            process.chdir(origCwd);
-            fs.rmSync(cwd, { recursive: true, force: true });
-        });
-        it('passes: legacy top-level output mode', async () => {
-            const p = path.join(process.cwd(), 'hono-takibi.config.ts');
-            const c = `
-export default {
-  input: 'openapi.yaml',
-  'zod-openapi': {
-    output: 'routes/index.ts',
-    exportSchemasTypes: true,
-    exportSchemas: true
-  },
-  rpc: {
-    output: 'rpc/index.ts',
-    import: '../client'
-  }
-}
-`;
-            fs.writeFileSync(p, c, 'utf-8');
-            await expect(readConfig()).resolves.toStrictEqual({
-                ok: true,
-                value: {
-                    input: 'openapi.yaml',
-                    'zod-openapi': {
-                        output: 'routes/index.ts',
-                        exportSchemasTypes: true,
-                        exportSchemas: true,
-                    },
-                    rpc: {
-                        output: 'rpc/index.ts',
-                        import: '../client',
-                    },
-                },
-            });
-        });
-        it('fails: config file missing', async () => {
-            const result = await readConfig();
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toMatch(/Config not found:/);
-            }
-        });
-    });
-}