hono-takibi 0.8.0 → 0.8.1

package/dist/cli/index.d.ts

@@ -1 +1,9 @@
-export { honoTakibi } from './hono-takibi/index.js';
+import { type Result } from '../result/index.js';
+/**
+ * CLI entry point for `hono-takibi`.
+ *
+ * @returns A `Result` containing help text or CLI execution result.
+ */
+export declare function honoTakibi(): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/index.js

@@ -1 +1,24 @@
-export { honoTakibi } from './hono-takibi/index.js';
+import { asyncAndThen, ok } from '../result/index.js';
+import { isHelpRequested, sliceArgv } from '../utils/index.js';
+import { parseCli } from './parse.js';
+import { takibi } from './takibi.js';
+const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
+
+Options:
+  --export-type        export TypeScript type aliases
+  --export-schema      export Zod schema objects
+  --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`;
+/**
+ * CLI entry point for `hono-takibi`.
+ *
+ * @returns A `Result` containing help text or CLI execution result.
+ */
+export async function honoTakibi() {
+    const args = sliceArgv(process.argv);
+    return isHelpRequested(sliceArgv(process.argv))
+        ? ok({ message: HELP_TEXT })
+        : await asyncAndThen(parseCli(args), async (cli) => asyncAndThen(await takibi(cli.input, cli.output, cli.exportSchema ?? false, cli.exportType ?? false, cli.template ?? false, cli.test ?? false, cli.basePath), async (result) => ok(result)));
+}

package/dist/cli/parse.d.ts

@@ -0,0 +1,16 @@
+import type { Result } from '../result/index.js';
+/**
+ * Parses CLI arguments into structured options.
+ *
+ * @param args - Raw CLI arguments.
+ * @returns A `Result` containing parsed CLI options or an error message.
+ */
+export declare function parseCli(args: readonly string[]): Result<{
+    input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+    output: `${string}.ts`;
+    exportType?: boolean;
+    exportSchema?: boolean;
+    template: boolean;
+    test: boolean;
+    basePath?: string;
+}, string>;

package/dist/cli/parse.js

@@ -0,0 +1,25 @@
+import { err, ok } from '../result/index.js';
+import { getFlagValue, hasFlag, isTs, isYamlOrJsonOrTsp } from '../utils/index.js';
+/**
+ * Parses CLI arguments into structured options.
+ *
+ * @param args - Raw CLI arguments.
+ * @returns A `Result` containing parsed CLI options or an error message.
+ */
+export function parseCli(args) {
+    const input = args[0];
+    const oIdx = args.indexOf('-o');
+    const output = oIdx !== -1 ? args[oIdx + 1] : undefined;
+    if (!(input && output && isYamlOrJsonOrTsp(input) && isTs(output))) {
+        return err('Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]');
+    }
+    return ok({
+        input,
+        output,
+        exportType: hasFlag(args, '--export-type'),
+        exportSchema: hasFlag(args, '--export-schema'),
+        template: hasFlag(args, '--template'),
+        test: hasFlag(args, '--test'),
+        basePath: getFlagValue(args, '--base-path'),
+    });
+}

package/dist/cli/takibi.d.ts

@@ -0,0 +1,16 @@
+import type { Result } from '../result/index.js';
+/**
+ * Generates TypeScript code from an OpenAPI spec and optional templates.
+ *
+ * @param input - Input OpenAPI file (`.yaml`, `.json`, or `.tsp`).
+ * @param output - Output `.ts` file path.
+ * @param exportSchema - Whether to export schemas.
+ * @param exportType - Whether to export types.
+ * @param template - Whether to generate templates.
+ * @param test - Whether to generate test files.
+ * @param basePath - Optional base path for template output.
+ * @returns A `Result` containing a success message or an error string.
+ */
+export declare function takibi(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, exportSchema: boolean, exportType: boolean, template: boolean, test: boolean, basePath?: string): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/takibi.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
+import { parseOpenAPI } from '../openapi/parse-openapi.js';
+import { asyncAndThen, ok } from '../result/index.js';
+import { templateCode } from './template-code.js';
+/**
+ * Generates TypeScript code from an OpenAPI spec and optional templates.
+ *
+ * @param input - Input OpenAPI file (`.yaml`, `.json`, or `.tsp`).
+ * @param output - Output `.ts` file path.
+ * @param exportSchema - Whether to export schemas.
+ * @param exportType - Whether to export types.
+ * @param template - Whether to generate templates.
+ * @param test - Whether to generate test files.
+ * @param basePath - Optional base path for template output.
+ * @returns A `Result` containing a success message or an error string.
+ */
+export async function takibi(input, output, exportSchema, exportType, template, test, basePath) {
+    return await asyncAndThen(await parseOpenAPI(input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType)), async (code) => asyncAndThen(await mkdir(path.dirname(output)), async () => asyncAndThen(await writeFile(output, code), async () => template && output.includes('/')
+        ? asyncAndThen(await templateCode(openAPI, output, test, basePath), async () => ok({
+            message: 'Generated code and template files written',
+        }))
+        : ok({
+            message: `Generated code written to ${output}`,
+        })))));
+}

package/dist/cli/template-code.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPI } from '../openapi/index.js';
+import type { Result } from '../result/index.js';
+/**
+ * Generates Hono Takibi application and handler templates.
+ *
+ * @param openAPI - The OpenAPI document to generate from.
+ * @param output - Path to the main `.ts` output file.
+ * @param test - Whether to include test code.
+ * @param basePath - Optional base path for the generated app.
+ * @returns A `Result` indicating success or an error message.
+ */
+export declare function templateCode(openAPI: OpenAPI, output: `${string}.ts`, test: boolean, basePath?: string): Promise<Result<void, string>>;

package/dist/cli/template-code.js

@@ -0,0 +1,22 @@
+import path from 'node:path';
+import { fmt } from '../format/index.js';
+import { readdir, writeFile } from '../fsp/index.js';
+import { app } from '../generator/zod-openapi-hono/app/index.js';
+import { zodOpenapiHonoHandler } from '../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
+import { asyncAndThen, ok } from '../result/index.js';
+/**
+ * Generates Hono Takibi application and handler templates.
+ *
+ * @param openAPI - The OpenAPI document to generate from.
+ * @param output - Path to the main `.ts` output file.
+ * @param test - Whether to include test code.
+ * @param basePath - Optional base path for the generated app.
+ * @returns A `Result` indicating success or an error message.
+ */
+export async function templateCode(openAPI, output, test, basePath) {
+    const dir = path.dirname(output);
+    return await asyncAndThen(await fmt(app(openAPI, output, basePath)), async (appCode) => asyncAndThen(await readdir(dir), async (files) => {
+        const target = path.join(dir, files.includes('index.ts') ? 'main.ts' : 'index.ts');
+        return await asyncAndThen(await writeFile(target, appCode), async () => asyncAndThen(await zodOpenapiHonoHandler(openAPI, output, test), async () => ok(undefined)));
+    }));
+}

package/dist/format/index.d.ts

@@ -1,7 +1,8 @@
 import type { Result } from '../result/index.js';
 /**
- * Formats TypeScript code using Prettier
- * @param { string } code - The TypeScript code to format
- * @returns { Promise<Result<string, string>> } - A promise that resolves to a Result containing the formatted code or an error message
+ * Formats TypeScript source with Prettier.
+ *
+ * @param code - Source code to format.
+ * @returns A `Result` containing the formatted code or an error message.
  */
 export declare function fmt(code: string): Promise<Result<string, string>>;

package/dist/format/index.js

@@ -1,8 +1,9 @@
 import { format } from 'prettier';
 /**
- * Formats TypeScript code using Prettier
- * @param { string } code - The TypeScript code to format
- * @returns { Promise<Result<string, string>> } - A promise that resolves to a Result containing the formatted code or an error message
+ * Formats TypeScript source with Prettier.
+ *
+ * @param code - Source code to format.
+ * @returns A `Result` containing the formatted code or an error message.
  */
 export async function fmt(code) {
     try {

package/dist/fsp/index.d.ts

@@ -1,17 +1,23 @@
 import type { Result } from '../result/index.js';
 /**
- * @param { string } dir - The directory to create.
- * @returns { Promise<Result<void, string>> } - A promise that resolves to a Result indicating success or an error message.
+ * Creates a directory if it does not already exist.
+ *
+ * @param dir - Directory path to create.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export declare function mkdir(dir: string): Promise<Result<void, string>>;
 /**
- * @param { string } dir - The directory to read.
- * @returns { Promise<Result<string[], string>> } - A promise that resolves to a Result containing an array of file names or an error message.
+ * Reads the contents of a directory.
+ *
+ * @param dir - Directory to read.
+ * @returns A `Result` with the file list on success, otherwise an error message.
  */
 export declare function readdir(dir: string): Promise<Result<string[], string>>;
 /**
- * @param {string} path - The path to the file.
- * @param {string} data - The data to write to the file.
- * @returns {Promise<Result<void, string>>} - A promise that resolves to a Result indicating success or an error message.
+ * Writes UTF-8 text to a file, creating it if necessary.
+ *
+ * @param path - File path to write.
+ * @param data - Text data to write.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export declare function writeFile(path: string, data: string): Promise<Result<void, string>>;

package/dist/fsp/index.js

@@ -1,8 +1,10 @@
 import fsp from 'node:fs/promises';
-import { ok, err } from '../result/index.js';
+import { err, ok } from '../result/index.js';
 /**
- * @param { string } dir - The directory to create.
- * @returns { Promise<Result<void, string>> } - A promise that resolves to a Result indicating success or an error message.
+ * Creates a directory if it does not already exist.
+ *
+ * @param dir - Directory path to create.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export async function mkdir(dir) {
     try {
@@ -14,8 +16,10 @@ export async function mkdir(dir) {
     }
 }
 /**
- * @param { string } dir - The directory to read.
- * @returns { Promise<Result<string[], string>> } - A promise that resolves to a Result containing an array of file names or an error message.
+ * Reads the contents of a directory.
+ *
+ * @param dir - Directory to read.
+ * @returns A `Result` with the file list on success, otherwise an error message.
  */
 export async function readdir(dir) {
     try {
@@ -27,9 +31,11 @@ export async function readdir(dir) {
     }
 }
 /**
- * @param {string} path - The path to the file.
- * @param {string} data - The data to write to the file.
- * @returns {Promise<Result<void, string>>} - A promise that resolves to a Result indicating success or an error message.
+ * Writes UTF-8 text to a file, creating it if necessary.
+ *
+ * @param path - File path to write.
+ * @param data - Text data to write.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export async function writeFile(path, data) {
     try {

package/dist/generator/zod/helper/array-reference-schema.d.ts

@@ -0,0 +1,31 @@
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod schema string for an array of referenced schemas.
+ *
+ * If the schema's `items` contains a `$ref`, it generates:
+ * `z.array(<ref>Schema)`
+ *
+ * Falls back to `z.array(z.any())` if the `$ref` is missing or invalid.
+ *
+ * @param schema - The OpenAPI schema object with array type
+ * @returns The Zod schema string for the array
+ *
+ * @example
+ * // Array of Tag references
+ * arrayReferenceSchema({
+ *   type: 'array',
+ *   items: { $ref: '#/components/schemas/Tag' }
+ * })
+ * // → 'z.array(tagSchema)'
+ *
+ * @example
+ * // Invalid items reference
+ * arrayReferenceSchema({ type: 'array', items: {} })
+ * // → 'z.array(z.any())'
+ *
+ * @example
+ * // Missing items
+ * arrayReferenceSchema({ type: 'array' })
+ * // → 'z.array(z.any())'
+ */
+export declare function arrayReferenceSchema(schema: Schema): string;

package/dist/generator/zod/helper/array-reference-schema.js

@@ -0,0 +1,40 @@
+import { array, refName } from '../../../utils/index.js';
+/**
+ * Generates a Zod schema string for an array of referenced schemas.
+ *
+ * If the schema's `items` contains a `$ref`, it generates:
+ * `z.array(<ref>Schema)`
+ *
+ * Falls back to `z.array(z.any())` if the `$ref` is missing or invalid.
+ *
+ * @param schema - The OpenAPI schema object with array type
+ * @returns The Zod schema string for the array
+ *
+ * @example
+ * // Array of Tag references
+ * arrayReferenceSchema({
+ *   type: 'array',
+ *   items: { $ref: '#/components/schemas/Tag' }
+ * })
+ * // → 'z.array(tagSchema)'
+ *
+ * @example
+ * // Invalid items reference
+ * arrayReferenceSchema({ type: 'array', items: {} })
+ * // → 'z.array(z.any())'
+ *
+ * @example
+ * // Missing items
+ * arrayReferenceSchema({ type: 'array' })
+ * // → 'z.array(z.any())'
+ */
+export function arrayReferenceSchema(schema) {
+    if (!schema.items?.$ref) {
+        return 'z.array(z.any())';
+    }
+    const ref = refName(schema.items?.$ref);
+    if (!ref) {
+        return 'z.array(z.any())';
+    }
+    return array(`${ref}Schema`);
+}

package/dist/generator/zod/helper/index.d.ts

@@ -0,0 +1,5 @@
+export { arrayReferenceSchema } from './array-reference-schema.js';
+export { propertiesSchema } from './properties-schema.js';
+export { propertySchema } from './property-schema.js';
+export { referenceSchema } from './reference-schema.js';
+export { zodSchemaFromSubSchema } from './zod-schema-from-sub-schema.js';

package/dist/generator/zod/helper/index.js

@@ -0,0 +1,5 @@
+export { arrayReferenceSchema } from './array-reference-schema.js';
+export { propertiesSchema } from './properties-schema.js';
+export { propertySchema } from './property-schema.js';
+export { referenceSchema } from './reference-schema.js';
+export { zodSchemaFromSubSchema } from './zod-schema-from-sub-schema.js';

package/dist/generator/zod/helper/properties-schema.d.ts

@@ -0,0 +1,46 @@
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod object schema string from a set of OpenAPI properties.
+ *
+ * - Handles required and optional fields
+ * - Supports primitive types, arrays, and `$ref`-based references
+ * - Automatically wraps in `.partial()` if all properties are optional
+ *
+ * @param properties - Object mapping property names to their schema definitions
+ * @param required - List of required property names
+ * @returns A Zod schema string representing the object
+ *
+ * @example
+ * // 1. All fields optional
+ * propertiesSchema(
+ *   {
+ *     id: { type: 'integer' },
+ *     status: { type: 'string', enum: ['active', 'inactive'] },
+ *   },
+ *   []
+ * )
+ * // → 'z.object({id:z.number().int().optional(),status:z.enum(["active","inactive"]).optional()}).partial()'
+ *
+ * @example
+ * // 2. All fields required
+ * propertiesSchema(
+ *   {
+ *     name: { type: 'string' },
+ *     items: { type: 'array', items: { type: 'string' } },
+ *   },
+ *   ['name', 'items']
+ * )
+ * // → 'z.object({name:z.string(),items:z.array(z.string())})'
+ *
+ * @example
+ * // 3. With schema references
+ * propertiesSchema(
+ *   {
+ *     user: { $ref: '#/components/schemas/User' },
+ *     tags: { type: 'array', items: { $ref: '#/components/schemas/Tag' } },
+ *   },
+ *   []
+ * )
+ * // → 'z.object({user:userSchema.optional(),tags:z.array(tagSchema).optional()}).partial()'
+ */
+export declare function propertiesSchema(properties: Record<string, Schema>, required: string[]): string;

package/dist/generator/zod/helper/properties-schema.js

@@ -0,0 +1,60 @@
+import { getToSafeIdentifier, isAllOptional, partial } from '../../../utils/index.js';
+import { propertySchema } from './property-schema.js';
+/**
+ * Generates a Zod object schema string from a set of OpenAPI properties.
+ *
+ * - Handles required and optional fields
+ * - Supports primitive types, arrays, and `$ref`-based references
+ * - Automatically wraps in `.partial()` if all properties are optional
+ *
+ * @param properties - Object mapping property names to their schema definitions
+ * @param required - List of required property names
+ * @returns A Zod schema string representing the object
+ *
+ * @example
+ * // 1. All fields optional
+ * propertiesSchema(
+ *   {
+ *     id: { type: 'integer' },
+ *     status: { type: 'string', enum: ['active', 'inactive'] },
+ *   },
+ *   []
+ * )
+ * // → 'z.object({id:z.number().int().optional(),status:z.enum(["active","inactive"]).optional()}).partial()'
+ *
+ * @example
+ * // 2. All fields required
+ * propertiesSchema(
+ *   {
+ *     name: { type: 'string' },
+ *     items: { type: 'array', items: { type: 'string' } },
+ *   },
+ *   ['name', 'items']
+ * )
+ * // → 'z.object({name:z.string(),items:z.array(z.string())})'
+ *
+ * @example
+ * // 3. With schema references
+ * propertiesSchema(
+ *   {
+ *     user: { $ref: '#/components/schemas/User' },
+ *     tags: { type: 'array', items: { $ref: '#/components/schemas/Tag' } },
+ *   },
+ *   []
+ * )
+ * // → 'z.object({user:userSchema.optional(),tags:z.array(tagSchema).optional()}).partial()'
+ */
+export function propertiesSchema(properties, required) {
+    const objectProperties = Object.entries(properties).map(([key, schema]) => {
+        const isRequired = required.includes(key);
+        const safeKey = getToSafeIdentifier(key);
+        return `${safeKey}:${propertySchema(schema)}${isRequired ? '' : '.optional()'}`;
+    });
+    // Check if all properties are optional
+    const allOptional = isAllOptional(objectProperties);
+    // If all properties are optional and no required properties, return partial schema
+    if (required.length === 0 && allOptional) {
+        return partial(objectProperties);
+    }
+    return `z.object({${objectProperties}})`;
+}

package/dist/generator/zod/helper/property-schema.d.ts

@@ -0,0 +1,27 @@
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod-compatible schema string for a given property.
+ *
+ * - Delegates `$ref` schemas to `referenceSchema`
+ * - Handles arrays with referenced items via `arrayReferenceSchema`
+ * - Falls back to `zodToOpenAPI` for primitives or complex inline schemas
+ *
+ * @param schema - The OpenAPI schema object for the property
+ * @returns The corresponding Zod schema string
+ *
+ * @example
+ * // Primitive string type
+ * propertySchema({ type: 'string' })
+ * // → 'z.string()'
+ *
+ * @example
+ * // Reference to another schema
+ * propertySchema({ $ref: '#/components/schemas/User' })
+ * // → 'userSchema'
+ *
+ * @example
+ * // Array of referenced items
+ * propertySchema({ type: 'array', items: { $ref: '#/components/schemas/Tag' } })
+ * // → 'z.array(tagSchema)'
+ */
+export declare function propertySchema(schema: Schema): string;

package/dist/generator/zod/helper/property-schema.js

@@ -0,0 +1,39 @@
+import { zodToOpenAPI } from '../../../helper/zod-to-openapi.js';
+import { isArrayWithSchemaReference } from '../../../utils/index.js';
+import { zod } from '../index.js';
+import { arrayReferenceSchema } from './array-reference-schema.js';
+import { referenceSchema } from './reference-schema.js';
+/**
+ * Generates a Zod-compatible schema string for a given property.
+ *
+ * - Delegates `$ref` schemas to `referenceSchema`
+ * - Handles arrays with referenced items via `arrayReferenceSchema`
+ * - Falls back to `zodToOpenAPI` for primitives or complex inline schemas
+ *
+ * @param schema - The OpenAPI schema object for the property
+ * @returns The corresponding Zod schema string
+ *
+ * @example
+ * // Primitive string type
+ * propertySchema({ type: 'string' })
+ * // → 'z.string()'
+ *
+ * @example
+ * // Reference to another schema
+ * propertySchema({ $ref: '#/components/schemas/User' })
+ * // → 'userSchema'
+ *
+ * @example
+ * // Array of referenced items
+ * propertySchema({ type: 'array', items: { $ref: '#/components/schemas/Tag' } })
+ * // → 'z.array(tagSchema)'
+ */
+export function propertySchema(schema) {
+    if (Boolean(schema.$ref) === true) {
+        return referenceSchema(schema);
+    }
+    if (isArrayWithSchemaReference(schema)) {
+        return arrayReferenceSchema(schema);
+    }
+    return zodToOpenAPI(zod(schema), schema);
+}

package/dist/generator/zod/helper/reference-schema.d.ts

@@ -0,0 +1,26 @@
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod schema string for a referenced schema.
+ *
+ * If the schema contains a `$ref`, it extracts the reference name and appends `Schema`.
+ * Falls back to `'z.any()'` if the `$ref` is missing or invalid.
+ *
+ * @param schema - The OpenAPI schema object containing a `$ref`
+ * @returns The Zod schema string referencing another schema
+ *
+ * @example
+ * // Reference to Category schema
+ * referenceSchema({ $ref: '#/components/schemas/Category' })
+ * // → 'CategorySchema'
+ *
+ * @example
+ * // Invalid reference
+ * referenceSchema({})
+ * // → 'z.any()'
+ *
+ * @example
+ * // Malformed $ref
+ * referenceSchema({ $ref: '#/components/schemas/' })
+ * // → 'z.any()'
+ */
+export declare function referenceSchema(schema: Schema): string;

package/dist/generator/zod/helper/reference-schema.js

@@ -0,0 +1,35 @@
+import { refName } from '../../../utils/index.js';
+/**
+ * Generates a Zod schema string for a referenced schema.
+ *
+ * If the schema contains a `$ref`, it extracts the reference name and appends `Schema`.
+ * Falls back to `'z.any()'` if the `$ref` is missing or invalid.
+ *
+ * @param schema - The OpenAPI schema object containing a `$ref`
+ * @returns The Zod schema string referencing another schema
+ *
+ * @example
+ * // Reference to Category schema
+ * referenceSchema({ $ref: '#/components/schemas/Category' })
+ * // → 'CategorySchema'
+ *
+ * @example
+ * // Invalid reference
+ * referenceSchema({})
+ * // → 'z.any()'
+ *
+ * @example
+ * // Malformed $ref
+ * referenceSchema({ $ref: '#/components/schemas/' })
+ * // → 'z.any()'
+ */
+export function referenceSchema(schema) {
+    if (!schema.$ref) {
+        return 'z.any()';
+    }
+    const ref = refName(schema.$ref);
+    if (!ref) {
+        return 'z.any()';
+    }
+    return `${ref}Schema` || 'z.any()';
+}

package/dist/generator/zod/helper/zod-schema-from-sub-schema.d.ts

@@ -0,0 +1,22 @@
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod schema string from a given OpenAPI sub-schema.
+ *
+ * If the schema contains a `$ref`, it resolves to the corresponding schema name;
+ * otherwise, it generates an inline Zod schema using the `zod()` converter.
+ *
+ * @param subSchema - The OpenAPI sub-schema object.
+ * @returns The Zod schema string (e.g., `'UserSchema'` or `'z.string()'`).
+ *
+ * @example
+ * ```ts
+ * // With $ref
+ * zodSchemaFromSubSchema({ $ref: '#/components/schemas/User' })
+ * // → 'UserSchema'
+ *
+ * // Without $ref
+ * zodSchemaFromSubSchema({ type: 'string', minLength: 3 })
+ * // → 'z.string().min(3)'
+ * ```
+ */
+export declare function zodSchemaFromSubSchema(subSchema: Schema): string;

package/dist/generator/zod/helper/zod-schema-from-sub-schema.js

@@ -0,0 +1,25 @@
+import { refName } from '../../../utils/index.js';
+import { zod } from '../index.js';
+/**
+ * Generates a Zod schema string from a given OpenAPI sub-schema.
+ *
+ * If the schema contains a `$ref`, it resolves to the corresponding schema name;
+ * otherwise, it generates an inline Zod schema using the `zod()` converter.
+ *
+ * @param subSchema - The OpenAPI sub-schema object.
+ * @returns The Zod schema string (e.g., `'UserSchema'` or `'z.string()'`).
+ *
+ * @example
+ * ```ts
+ * // With $ref
+ * zodSchemaFromSubSchema({ $ref: '#/components/schemas/User' })
+ * // → 'UserSchema'
+ *
+ * // Without $ref
+ * zodSchemaFromSubSchema({ type: 'string', minLength: 3 })
+ * // → 'z.string().min(3)'
+ * ```
+ */
+export function zodSchemaFromSubSchema(subSchema) {
+    return subSchema.$ref ? `${refName(subSchema.$ref)}Schema` : zod(subSchema);
+}