@rx-ted/packages-honest-plugins 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @rx-ted/packages-honest-plugins
+
+## 1.0.1
+
+### Patch Changes
+
+- 11bbae7: Remove defunct packages (web-admin, auth, http-client, search) and introduce barrel packages for consolidated exports. Migrate all internal imports from scoped plugin names (`@rx-ted/packages-honest-plugins-db`) to path-based barrel imports (`@rx-ted/packages-honest-plugins/db`). Reset all package versions to 1.0.0 with consolidated changelogs. Clean up obsolete documentation across the monorepo.
+- Updated dependencies [11bbae7]
+  - @rx-ted/packages-honest-plugins-db@1.0.1
+  - @rx-ted/packages-honest-plugins-cache@1.0.1
+  - @rx-ted/packages-honest-plugins-mail@1.0.1
+  - @rx-ted/packages-honest-plugins-s3@1.0.1
+  - @rx-ted/packages-honest-plugins-api-doc@1.0.1

package/README.md

@@ -0,0 +1,45 @@
+# @rx-ted/packages-honest-plugins
+
+HonestJS 插件集合 — db, cache, mail, s3, api-doc。
+
+## 插件列表
+
+| 插件 | 子包 | 用途 |
+| --- | --- | --- |
+| `db` | `@rx-ted/packages-honest-plugins-db` | 数据库（Drizzle ORM + MySQL/SQLite/D1/PostgreSQL） |
+| `cache` | `@rx-ted/packages-honest-plugins-cache` | 缓存（Redis/KV/Local） |
+| `mail` | `@rx-ted/packages-honest-plugins-mail` | 邮件（Resend/Brevo/SMTP） |
+| `s3` | `@rx-ted/packages-honest-plugins-s3` | 对象存储（AWS S3） |
+| `api-doc` | `@rx-ted/packages-honest-plugins-api-doc` | OpenAPI 文档 + Scalar UI |
+
+## 导入方式
+
+```ts
+// 通过 barrel 导入
+import { DbService } from '@rx-ted/packages-honest-plugins/db'
+import { CacheService } from '@rx-ted/packages-honest-plugins/cache'
+import { MailPlugin } from '@rx-ted/packages-honest-plugins/mail'
+import { S3Plugin } from '@rx-ted/packages-honest-plugins/s3'
+import { ApiDocPlugin } from '@rx-ted/packages-honest-plugins/api-doc'
+```
+
+## 子包结构
+
+```
+packages/honest-plugins/
+├── db/          @rx-ted/packages-honest-plugins-db      (private)
+├── cache/       @rx-ted/packages-honest-plugins-cache   (private)
+├── mail/        @rx-ted/packages-honest-plugins-mail    (private)
+├── s3/          @rx-ted/packages-honest-plugins-s3      (private)
+└── api-doc/     @rx-ted/packages-honest-plugins-api-doc (private)
+```
+
+子包为 `private: true`，仅通过 barrel 包 `@rx-ted/packages-honest-plugins` 发布。
+
+## 开发
+
+```bash
+pnpm build       # 构建所有插件
+pnpm test        # 运行所有测试
+pnpm typecheck   # 类型检查
+```

package/api-doc/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc -p tsconfig.json

package/api-doc/.turbo/turbo-test.log

@@ -0,0 +1,11 @@
+$ vitest run
+
+ RUN  v4.1.8 /Users/ben/projects/app/packages/honest-plugins/api-doc
+
+ ✓ src/plugin.test.ts (45 tests) 296ms
+
+ Test Files  1 passed (1)
+      Tests  45 passed (45)
+   Start at  14:17:11
+   Duration  513ms (transform 112ms, setup 0ms, import 159ms, tests 296ms, environment 0ms)
+

package/api-doc/.turbo/turbo-typecheck.log

@@ -0,0 +1 @@
+$ tsc -p tsconfig.json --noEmit

package/api-doc/CHANGELOG.md

@@ -0,0 +1,22 @@
+# @rx-ted/packages-honest-plugins-api-doc
+
+## 1.0.1
+
+### Patch Changes
+
+- 11bbae7: Remove defunct packages (web-admin, auth, http-client, search) and introduce barrel packages for consolidated exports. Migrate all internal imports from scoped plugin names (`@rx-ted/packages-honest-plugins-db`) to path-based barrel imports (`@rx-ted/packages-honest-plugins/db`). Reset all package versions to 1.0.0 with consolidated changelogs. Clean up obsolete documentation across the monorepo.
+- Updated dependencies [11bbae7]
+  - @rx-ted/packages-core@1.0.1
+  - @rx-ted/packages-honest@1.0.1
+
+## 1.0.0
+
+Initial consolidated release.
+
+### Features
+
+- API documentation plugin for @rx-ted/packages-honest
+- OpenAPI spec generation
+- NestJS-compatible decorators: `@Headers`, `@Ip`, `@Session`, `@HostParam`, `@Next`
+- `@Redirect(url, statusCode?)` method decorator
+- DESIGN.md documentation

package/api-doc/README.md

@@ -0,0 +1,80 @@
+# @rx-ted/packages-honest-plugins-api-doc
+
+OpenAPI documentation plugin for [@rx-ted/packages-honest](https://github.com/rx-ted/honest). Generates OpenAPI specs from Honest route metadata with Scalar and Swagger UI renderers.
+
+## Features
+
+- **Auto-generate**: OpenAPI spec from Honest decorator metadata
+- **Scalar UI**: modern interactive API documentation
+- **Swagger UI**: classic Swagger documentation
+- **Plugin-based**: integrates with Honest's plugin lifecycle
+
+## Installation
+
+```bash
+pnpm add @rx-ted/packages-honest-plugins-api-doc
+```
+
+Peer dependencies: `@rx-ted/packages-honest`, `hono`, `reflect-metadata`
+
+## Usage
+
+### Register as a plugin
+
+```ts
+import { ApiDocPlugin } from '@rx-ted/packages-honest-plugins/api-doc';
+
+const plugin = new ApiDocPlugin({
+  title: 'My API',
+  version: '1.0.0',
+  renderer: 'scalar', // 'scalar' | 'swagger'
+});
+
+const { hono } = await Application.create(AppModule, {
+  plugins: [plugin],
+});
+```
+
+### Renderers
+
+```ts
+import { ScalarRenderer } from '@rx-ted/packages-honest-plugins/api-doc';
+import { SwaggerRenderer } from '@rx-ted/packages-honest-plugins/api-doc';
+
+// Scalar UI (default)
+const scalar = new ScalarRenderer({ title: 'API Docs' });
+
+// Swagger UI
+const swagger = new SwaggerRenderer({ title: 'API Docs' });
+```
+
+### Endpoints
+
+Once registered, the plugin adds:
+
+- `GET /openapi.json` — OpenAPI spec
+- `GET /docs` — UI rendering (Scalar or Swagger)
+
+## Types
+
+```ts
+interface ApiDocPluginOptions {
+  title?: string;
+  version?: string;
+  description?: string;
+  renderer?: 'scalar' | 'swagger';
+  specPath?: string;
+}
+
+interface IDocRenderer {
+  render(spec: Record<string, unknown>): string;
+}
+```
+
+## Scripts
+
+| Script | Description |
+|--------|-------------|
+| `pnpm test` | Run tests |
+| `pnpm build` | Build |
+| `pnpm typecheck` | Type check |

package/api-doc/dist/api-doc.plugin.d.ts

@@ -0,0 +1,53 @@
+import { type ILogger } from '@rx-ted/packages-core';
+import type { ApiDocSecurityScheme, ApiDocSecurityRequirement, Application, HonestOptions, IPlugin } from '@rx-ted/packages-honest';
+import type { Context, Hono } from 'hono';
+import type { IDocRenderer } from './interfaces/renderer.interface';
+type RendererName = 'scalar' | 'swagger';
+export interface ApiDocPluginOptions {
+    specUrl?: string;
+    uiRoute?: string;
+    uiTitle?: string;
+    defaultRenderer?: RendererName;
+    renderers?: IDocRenderer[];
+    onRequest?: (c: Context) => void | Promise<void>;
+    securitySchemes?: Record<string, ApiDocSecurityScheme>;
+    security?: ApiDocSecurityRequirement[];
+    exclude?: string[];
+    excludeMethods?: string[];
+    excludeTags?: string[];
+}
+export declare function normalizeRoute(input: string): string;
+export declare class ApiDocPlugin implements IPlugin {
+    readonly name = "api-doc-plugin";
+    readonly version = "1.0.0";
+    logger?: ILogger;
+    private readonly specUrl;
+    private readonly uiRoute;
+    private readonly uiTitle;
+    private readonly defaultRendererName;
+    private readonly onRequest?;
+    private readonly securitySchemes;
+    private readonly defaultSecurity?;
+    private readonly exclude?;
+    private readonly excludeMethods?;
+    private readonly excludeTags?;
+    private renderers;
+    private spec;
+    private routingPrefix?;
+    private routingVersion?;
+    private app?;
+    constructor(options?: ApiDocPluginOptions);
+    private applyPrefixToUrl;
+    setRoutingOptions(options?: HonestOptions['routing']): void;
+    registerRenderer(renderer: IDocRenderer): void;
+    getRenderer(name: string): IDocRenderer | undefined;
+    beforeModulesRegistered: (app: Application, hono: Hono) => Promise<void>;
+    afterModulesRegistered: (app: Application, hono: Hono) => Promise<void>;
+    private generateSpec;
+    private convertHonoPathToOpenAPI;
+    private isPathExcluded;
+    private toOpenAPISchema;
+    private zodToOpenAPI;
+    private runHook;
+}
+export {};

package/api-doc/dist/api-doc.plugin.js

@@ -0,0 +1,452 @@
+import { ENV_SYMBOL } from '@rx-ted/packages-core';
+import { ComponentManager, VERSION_NEUTRAL, normalizePath, resolvePluginLogger, } from '@rx-ted/packages-honest';
+import { ScalarRenderer } from './renderers/scalar.renderer';
+import { SwaggerRenderer } from './renderers/swagger.renderer';
+export function normalizeRoute(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return '/';
+    let normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    if (normalized.length > 1) {
+        normalized = normalized.replace(/\/+$/g, '');
+    }
+    return normalized || '/';
+}
+const DEFAULT_SECURITY_SCHEMES = {
+    bearerAuth: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
+    basicAuth: { type: 'http', scheme: 'basic' },
+    apiKey: { type: 'apiKey', in: 'header', name: 'X-API-Key' },
+    cookieAuth: { type: 'apiKey', in: 'cookie', name: 'token' },
+};
+export class ApiDocPlugin {
+    name = 'api-doc-plugin';
+    version = '1.0.0';
+    logger;
+    specUrl = '/openapi.json';
+    uiRoute = '/docs';
+    uiTitle = 'API Documentation';
+    defaultRendererName = 'scalar';
+    onRequest;
+    securitySchemes = {
+        ...DEFAULT_SECURITY_SCHEMES,
+    };
+    defaultSecurity;
+    exclude;
+    excludeMethods;
+    excludeTags;
+    renderers = new Map();
+    spec = null;
+    routingPrefix;
+    routingVersion;
+    app;
+    constructor(options = {}) {
+        if (options.specUrl !== undefined)
+            this.specUrl = options.specUrl;
+        if (options.uiRoute !== undefined)
+            this.uiRoute = normalizeRoute(options.uiRoute);
+        if (options.uiTitle !== undefined)
+            this.uiTitle = options.uiTitle;
+        if (options.defaultRenderer !== undefined)
+            this.defaultRendererName = options.defaultRenderer;
+        if (options.onRequest !== undefined)
+            this.onRequest = options.onRequest;
+        if (options.securitySchemes !== undefined)
+            this.securitySchemes = options.securitySchemes;
+        if (options.security !== undefined)
+            this.defaultSecurity = options.security;
+        if (options.exclude !== undefined)
+            this.exclude = options.exclude;
+        if (options.excludeMethods !== undefined)
+            this.excludeMethods = options.excludeMethods;
+        if (options.excludeTags !== undefined)
+            this.excludeTags = options.excludeTags;
+        if (options.renderers !== undefined) {
+            options.renderers.forEach((r) => this.renderers.set(r.name, r));
+        }
+        else {
+            [new ScalarRenderer(), new SwaggerRenderer()].forEach((r) => this.renderers.set(r.name, r));
+        }
+    }
+    applyPrefixToUrl(url) {
+        if (!this.routingPrefix && !this.routingVersion) {
+            return url;
+        }
+        const prefix = this.routingPrefix ? normalizePath(`/${this.routingPrefix}`) : '';
+        let versionSegment = '';
+        if (this.routingVersion !== undefined &&
+            this.routingVersion !== null &&
+            this.routingVersion !== VERSION_NEUTRAL &&
+            !Array.isArray(this.routingVersion)) {
+            versionSegment = `/v${this.routingVersion}`;
+        }
+        const base = `${prefix}${versionSegment}`;
+        if (!base)
+            return url;
+        const urlPath = url.startsWith('/') ? url : `/${url}`;
+        return normalizePath(`${base}${urlPath}`);
+    }
+    setRoutingOptions(options) {
+        if (options) {
+            this.routingPrefix = options.prefix;
+            this.routingVersion = options.version;
+        }
+    }
+    registerRenderer(renderer) {
+        this.renderers.set(renderer.name, renderer);
+    }
+    getRenderer(name) {
+        return this.renderers.get(name);
+    }
+    beforeModulesRegistered = async (app, hono) => {
+        this.logger ??= resolvePluginLogger(this.name);
+        if (!ComponentManager.hasPlugin(ENV_SYMBOL)) {
+            this.logger.warn('ApiDoc disabled (env not configured)');
+            return;
+        }
+        const envInstance = ComponentManager.getPlugin(ENV_SYMBOL);
+        if (!envInstance.DEBUG) {
+            this.logger.warn('ApiDoc disabled in production');
+            return;
+        }
+        try {
+            const routingOptions = app.getRoutingOptions();
+            if (routingOptions) {
+                this.setRoutingOptions(routingOptions);
+            }
+        }
+        catch {
+            // Ignore if options are not accessible
+        }
+        const specUrlWithPrefix = this.applyPrefixToUrl(this.specUrl);
+        const uiRouteWithPrefix = this.applyPrefixToUrl(this.uiRoute);
+        // Register callback to print doc URLs when server starts
+        if (app.registerOnStartCallback) {
+            app.registerOnStartCallback((port) => {
+                const base = `http://localhost:${port}`;
+                this.logger?.info(`Docs: ${base}${uiRouteWithPrefix}`);
+                this.logger?.info(`OpenAPI JSON: ${base}${specUrlWithPrefix}`);
+            });
+        }
+        hono.get(specUrlWithPrefix, async (c) => {
+            await this.runHook(c);
+            if (!this.spec) {
+                return c.json({ status: 500, code: 'ERROR', data: null, error: 'API spec not generated yet' }, 500);
+            }
+            return c.json({ status: 200, code: 'OK', data: this.spec });
+        });
+        hono.get(uiRouteWithPrefix, async (c) => {
+            await this.runHook(c);
+            const renderer = this.renderers.get(this.defaultRendererName);
+            if (!renderer) {
+                return c.json({ error: `Default renderer '${this.defaultRendererName}' not found` }, 500);
+            }
+            return c.html(renderer.renderHtml({
+                specUrl: specUrlWithPrefix,
+                uiTitle: this.uiTitle,
+            }));
+        });
+        hono.get(`${uiRouteWithPrefix}/:renderer`, async (c) => {
+            await this.runHook(c);
+            const rendererName = c.req.param('renderer');
+            if (!rendererName)
+                return c.json({
+                    error: `Renderer '${rendererName}' not found`,
+                    available: Array.from(this.renderers.keys()),
+                }, 404);
+            const renderer = this.renderers.get(rendererName);
+            if (!renderer) {
+                return c.json({
+                    error: `Renderer '${rendererName}' not found`,
+                    available: Array.from(this.renderers.keys()),
+                }, 404);
+            }
+            return c.html(renderer.renderHtml({
+                specUrl: specUrlWithPrefix,
+                uiTitle: this.uiTitle,
+            }));
+        });
+    };
+    afterModulesRegistered = async (app, hono) => {
+        this.app = app;
+        this.spec = this.generateSpec();
+    };
+    generateSpec() {
+        const paths = {};
+        const tags = [];
+        if (!this.app) {
+            return {
+                openapi: '3.0.0',
+                info: {
+                    title: this.uiTitle,
+                    version: '1.0.0',
+                    description: 'API Documentation',
+                },
+                paths: {},
+            };
+        }
+        const routes = this.app.getRoutes();
+        const controllerTags = new Map();
+        // Collect all controller tags first
+        for (const route of routes) {
+            if (route.controllerClass) {
+                const tag = Reflect.getMetadata('api:controller:tag', route.controllerClass);
+                if (tag && !controllerTags.has(route.controller)) {
+                    controllerTags.set(route.controller, tag);
+                    tags.push({
+                        name: tag.name,
+                        description: tag.description ?? `${tag.name} endpoints`,
+                    });
+                }
+            }
+        }
+        for (const route of routes) {
+            let fullPath = route.fullPath;
+            if (!fullPath)
+                continue;
+            // Skip excluded paths
+            if (this.exclude && this.isPathExcluded(fullPath, this.exclude)) {
+                continue;
+            }
+            // Skip excluded methods
+            if (this.excludeMethods?.map((m) => m.toLowerCase()).includes(route.method.toLowerCase())) {
+                continue;
+            }
+            // Convert Hono :param syntax to OpenAPI {param} syntax
+            fullPath = this.convertHonoPathToOpenAPI(fullPath);
+            const pathItem = paths[fullPath] ?? {};
+            const apiDoc = route.controllerClass
+                ? Reflect.getMetadata('api:method:apiDoc', route.controllerClass.prototype, route.handler)
+                : undefined;
+            const controllerTag = controllerTags.get(route.controller);
+            // Skip excluded tags
+            const tagName = apiDoc?.tags ?? (controllerTag ? [controllerTag.name] : ['Default']);
+            if (this.excludeTags && tagName.some((tag) => this.excludeTags.includes(tag))) {
+                continue;
+            }
+            const operation = {
+                ...(apiDoc?.summary && { summary: apiDoc.summary }),
+                ...(apiDoc?.description && { description: apiDoc.description }),
+                tags: tagName,
+                // Add security requirements
+                ...(apiDoc?.security
+                    ? { security: apiDoc.security }
+                    : this.defaultSecurity
+                        ? { security: this.defaultSecurity }
+                        : this.securitySchemes
+                            ? { security: Object.keys(this.securitySchemes).map((n) => ({ [n]: [] })) }
+                            : {}),
+            };
+            // Handle parameters (path params from Zod schema + query params)
+            const parameters = [];
+            // Add path parameters from apiDoc.request.params
+            if (apiDoc?.request?.params) {
+                const paramsSchema = this.toOpenAPISchema(apiDoc.request.params);
+                if (paramsSchema.properties) {
+                    for (const [name, schema] of Object.entries(paramsSchema.properties)) {
+                        parameters.push({
+                            name,
+                            in: 'path',
+                            required: true,
+                            schema,
+                        });
+                    }
+                }
+            }
+            // Add query parameters from apiDoc.request.query
+            if (apiDoc?.request?.query) {
+                const querySchema = this.toOpenAPISchema(apiDoc.request.query);
+                if (querySchema.properties) {
+                    for (const [name, schema] of Object.entries(querySchema.properties)) {
+                        parameters.push({
+                            name,
+                            in: 'query',
+                            required: querySchema.required?.includes(name) ?? false,
+                            schema,
+                        });
+                    }
+                }
+            }
+            if (parameters.length > 0) {
+                operation.parameters = parameters;
+            }
+            if (apiDoc?.request?.body) {
+                operation.requestBody = {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: this.toOpenAPISchema(apiDoc.request.body),
+                        },
+                    },
+                };
+            }
+            if (apiDoc?.responses) {
+                operation.responses = {};
+                for (const [statusStr, response] of Object.entries(apiDoc.responses)) {
+                    const status = parseInt(statusStr, 10);
+                    operation.responses[status] = {
+                        description: response.description ?? 'Success',
+                        ...(response.schema && {
+                            content: {
+                                'application/json': {
+                                    schema: this.toOpenAPISchema(response.schema),
+                                },
+                            },
+                        }),
+                    };
+                }
+            }
+            pathItem[route.method] = operation;
+            paths[fullPath] = pathItem;
+        }
+        return {
+            openapi: '3.0.0',
+            info: {
+                title: this.uiTitle,
+                version: '1.0.0',
+                description: 'API Documentation',
+            },
+            paths,
+            ...(tags.length > 0 && { tags }),
+            components: {
+                securitySchemes: this.securitySchemes,
+            },
+        };
+    }
+    convertHonoPathToOpenAPI(honoPath) {
+        // Convert Hono :param syntax to OpenAPI {param} syntax
+        return honoPath.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+    }
+    isPathExcluded(path, excludePatterns) {
+        return excludePatterns.some((pattern) => {
+            // Convert pattern to regex (support wildcard *)
+            const regex = new RegExp(`^${pattern.replace(/\*/g, '.*')}$`);
+            return regex.test(path);
+        });
+    }
+    toOpenAPISchema(schema) {
+        if (!schema)
+            return { type: 'object' };
+        if (schema._def) {
+            return this.zodToOpenAPI(schema);
+        }
+        if (schema.type || schema.properties) {
+            return schema;
+        }
+        return { type: 'object' };
+    }
+    zodToOpenAPI(schema) {
+        if (!schema?._def)
+            return { type: 'object' };
+        const def = schema._def;
+        // Handle Zod 4.x new structure (type, innerType, etc.)
+        // Zod 4.x uses def.type property instead of typeName
+        const zodType = def.type || def.typeName;
+        switch (zodType) {
+            case 'string':
+            case 'ZodString': {
+                const stringMeta = { type: 'string' };
+                // Zod 3.x: checks in def.checks
+                if (def.checks) {
+                    for (const check of def.checks) {
+                        if (check.kind === 'min')
+                            stringMeta.minLength = check.value;
+                        if (check.kind === 'max')
+                            stringMeta.maxLength = check.value;
+                        if (check.kind === 'regex')
+                            stringMeta.pattern = check.regex.source;
+                    }
+                }
+                // Zod 4.x: instance properties
+                if (schema.minLength != null)
+                    stringMeta.minLength = schema.minLength;
+                if (schema.maxLength != null)
+                    stringMeta.maxLength = schema.maxLength;
+                return stringMeta;
+            }
+            case 'number':
+            case 'ZodNumber': {
+                const numberMeta = { type: 'number' };
+                // Zod 3.x: checks in def.checks
+                if (def.checks) {
+                    for (const check of def.checks) {
+                        if (check.kind === 'min')
+                            numberMeta.minimum = check.value;
+                        if (check.kind === 'max')
+                            numberMeta.maximum = check.value;
+                    }
+                }
+                // Zod 4.x: instance properties
+                if (schema.minValue != null && Number.isFinite(schema.minValue))
+                    numberMeta.minimum = schema.minValue;
+                if (schema.maxValue != null && Number.isFinite(schema.maxValue))
+                    numberMeta.maximum = schema.maxValue;
+                return numberMeta;
+            }
+            case 'boolean':
+            case 'ZodBoolean':
+                return { type: 'boolean' };
+            case 'array':
+            case 'ZodArray': {
+                // Zod 4.x: def.element, Zod 3.x: def.type (the schema, not a string)
+                const elementSchema = def.element ||
+                    (typeof def.type !== 'string' ? def.type : null) ||
+                    (def.typeName ? def : null);
+                return {
+                    type: 'array',
+                    items: elementSchema ? this.zodToOpenAPI(elementSchema) : { type: 'object' },
+                };
+            }
+            case 'object':
+            case 'ZodObject': {
+                const properties = {};
+                const required = [];
+                // Zod 4.x: def.shape() or def.shape
+                // Zod 3.x: def.shape()
+                const shape = typeof def.shape === 'function' ? def.shape() : def.shape || {};
+                for (const [key, value] of Object.entries(shape)) {
+                    const field = value;
+                    properties[key] = this.zodToOpenAPI(field);
+                    // Check if field is required (not optional)
+                    const fieldDef = field?._def;
+                    const fieldType = fieldDef?.type || fieldDef?.typeName;
+                    if (fieldType !== 'optional' && fieldType !== 'ZodOptional') {
+                        required.push(key);
+                    }
+                }
+                return {
+                    type: 'object',
+                    properties,
+                    ...(required.length > 0 && { required }),
+                };
+            }
+            case 'optional':
+            case 'ZodOptional':
+                // Zod 4.x: def.innerType, Zod 3.x: def.innerType or def.type
+                return this.zodToOpenAPI(def.innerType ?? def.type);
+            case 'enum':
+            case 'ZodEnum':
+                return {
+                    type: 'string',
+                    enum: def.values || (def.entries ? Object.values(def.entries) : []),
+                };
+            case 'null':
+            case 'ZodNull':
+                return { type: 'null' };
+            case 'union':
+            case 'ZodUnion':
+                if (def.options) {
+                    return {
+                        oneOf: def.options.map((opt) => this.zodToOpenAPI(opt)),
+                    };
+                }
+                return { type: 'object' };
+            default:
+                return { type: 'object' };
+        }
+    }
+    async runHook(c) {
+        if (this.onRequest) {
+            await this.onRequest(c);
+        }
+    }
+}