ts-typed-api 0.1.21 → 0.1.23

package/dist/openapi-self.js

@@ -166,10 +166,47 @@ class SchemaRegistry {
                 };
             }
             if (zodSchema instanceof zod_1.ZodArray) {
-                const itemType = getZodType(zodSchema);
+                // Try multiple ways to get the array item type
+                let itemType;
+                // Method 1: Try _def.element (this is the correct property for ZodArray)
+                try {
+                    const def = getZodDef(zodSchema);
+                    if (def && def.element && typeof def.element === 'object' && def.element.constructor) {
+                        itemType = def.element;
+                    }
+                }
+                catch (error) {
+                    // Continue to next method
+                }
+                // Method 2: Try getZodType if method 1 failed
+                if (!itemType) {
+                    const typeResult = getZodType(zodSchema);
+                    if (typeResult && typeof typeResult === 'object' && typeResult.constructor) {
+                        itemType = typeResult;
+                    }
+                }
+                // Method 3: Direct access to _def.element as fallback
+                if (!itemType) {
+                    try {
+                        const directElement = zodSchema._def?.element;
+                        if (directElement && typeof directElement === 'object' && directElement.constructor) {
+                            itemType = directElement;
+                        }
+                    }
+                    catch (error) {
+                        // Continue to fallback
+                    }
+                }
+                if (itemType) {
+                    return {
+                        type: 'array',
+                        items: this.zodToOpenAPI(itemType, shouldRegister)
+                    };
+                }
+                // Ultimate fallback
                 return {
                     type: 'array',
-                    items: itemType ? this.zodToOpenAPI(itemType, shouldRegister) : { type: 'string' }
+                    items: { type: 'string' }
                 };
             }
             if (zodSchema instanceof zod_1.ZodObject) {

package/examples/hono-cloudflare-worker-example.ts

@@ -0,0 +1,66 @@
+import { Hono } from 'hono';
+import { RegisterHonoHandlers } from '../src';
+import { PublicApiDefinition, PrivateApiDefinition } from './simple/definitions';
+
+// Create Hono app for Cloudflare Workers
+const app = new Hono();
+
+// Example middlewares that receive endpoint information
+const loggingMiddleware = async (req: any, res: any, next: any, endpointInfo: any) => {
+    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path} - Endpoint: ${endpointInfo.domain}.${endpointInfo.routeKey}`);
+    await next();
+};
+
+const authMiddleware = async (req: any, res: any, next: any) => {
+    // Example auth logic for Workers
+    const authHeader = req.headers.get('authorization');
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        console.log(`Auth failed - No valid auth header`);
+        return res.status(401).json({ error: [{ field: "authorization", type: "general", message: "Unauthorized" }] });
+    }
+    console.log(`Auth passed`);
+    await next();
+};
+
+// Register public handlers (same as Express version)
+RegisterHonoHandlers(app, PublicApiDefinition, {
+    common: {
+        ping: async (req, res) => {
+            res.respond(200, "pong");
+        }
+    },
+    status: {
+        probe1: async (req, res) => {
+            if (req.query.match) {
+                return res.respond(201, { status: true });
+            }
+            res.respond(200, "pong");
+        },
+        probe2: async (req, res) => {
+            res.respond(200, "pong");
+        }
+    }
+}, [loggingMiddleware]);
+
+// Register private handlers with auth
+RegisterHonoHandlers(app, PrivateApiDefinition, {
+    user: {
+        get: async (req, res) => {
+            console.log('Fetching user', req.params.id);
+            res.respond(200, "ok");
+        }
+    }
+}, [loggingMiddleware, authMiddleware]);
+
+// Export for Cloudflare Workers
+export default app;
+
+// For local development/testing (commented out for Workers compatibility)
+// if (typeof process !== 'undefined' && process.env.NODE_ENV === 'development') {
+//     console.log('Hono Cloudflare Worker example running locally');
+//     console.log('Available routes:');
+//     console.log('- GET /api/v1/public/ping');
+//     console.log('- GET /api/v1/public/status/probe1');
+//     console.log('- GET /api/v1/public/status/probe2');
+//     console.log('- GET /api/v1/private/user/:id (requires Bearer token)');
+// }

package/examples/test-hono-server.ts

@@ -0,0 +1,125 @@
+import { Hono } from 'hono';
+import http from 'http';
+import { PublicApiDefinition as SimplePublicApiDefinition, PrivateApiDefinition as SimplePrivateApiDefinition } from './examples/simple/definitions';
+import { RegisterHonoHandlers } from './src';
+
+const HONO_PORT = 3004;
+
+async function startHonoServer() {
+    console.log('Starting Hono server...');
+
+    const app = new Hono();
+
+    console.log('Registering handlers...');
+
+    // Register public handlers using Hono
+    RegisterHonoHandlers(app, SimplePublicApiDefinition, {
+        common: {
+            ping: async (req, res) => {
+                console.log('Handling ping request');
+                res.respond(200, "pong");
+            }
+        },
+        status: {
+            probe1: async (req, res) => {
+                console.log('Handling probe1 request, query:', req.query);
+                if (req.query.match) {
+                    return res.respond(201, { status: true });
+                }
+                res.respond(200, "pong");
+            },
+            probe2: async (req, res) => {
+                console.log('Handling probe2 request');
+                res.respond(200, "pong");
+            }
+        }
+    });
+
+    // Register private handlers using Hono
+    RegisterHonoHandlers(app, SimplePrivateApiDefinition, {
+        user: {
+            get: async (req, res) => {
+                console.log('Handling user get request, params:', req.params);
+                res.respond(200, "ok");
+            }
+        }
+    });
+
+    console.log('Creating HTTP server wrapper...');
+
+    // Create HTTP server from Hono app
+    const server = app.fetch;
+
+    // Create a simple HTTP server wrapper for Hono
+    const honoServer = http.createServer(async (req: any, res: any) => {
+        console.log(`Incoming request: ${req.method} ${req.url}`);
+
+        try {
+            // Read the request body for non-GET/HEAD methods
+            let body: ReadableStream | undefined;
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                console.log('Reading request body...');
+                const chunks: Buffer[] = [];
+                for await (const chunk of req) {
+                    chunks.push(chunk);
+                }
+                const buffer = Buffer.concat(chunks);
+                console.log('Request body length:', buffer.length);
+                body = new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(buffer);
+                        controller.close();
+                    }
+                });
+            }
+
+            console.log('Creating Web API Request...');
+            const request = new Request(`http://localhost:${HONO_PORT}${req.url}`, {
+                method: req.method,
+                headers: req.headers,
+                body: body
+            });
+
+            console.log('Calling Hono app.fetch...');
+            const response = await server(request);
+
+            console.log('Response status:', response.status);
+            console.log('Response headers:', Object.fromEntries(response.headers.entries()));
+
+            res.statusCode = response.status;
+            for (const [key, value] of response.headers) {
+                res.setHeader(key, value);
+            }
+
+            const responseBody = await response.text();
+            console.log('Response body:', responseBody);
+            res.end(responseBody);
+        } catch (error) {
+            console.error('Hono server error:', error);
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+        }
+    });
+
+    console.log(`Starting server on port ${HONO_PORT}...`);
+    honoServer.listen(HONO_PORT, () => {
+        console.log(`Hono server listening on port ${HONO_PORT}`);
+        console.log('Available endpoints:');
+        console.log('  GET  /api/v1/public/ping');
+        console.log('  GET  /api/v1/public/status/probe1');
+        console.log('  GET  /api/v1/public/status/probe1?match=true');
+        console.log('  GET  /api/v1/public/status/probe2');
+        console.log('  GET  /api/v1/private/user/:id');
+    });
+
+    // Graceful shutdown
+    process.on('SIGINT', () => {
+        console.log('Shutting down server...');
+        honoServer.close(() => {
+            console.log('Server closed');
+            process.exit(0);
+        });
+    });
+}
+
+startHonoServer().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,6 +48,7 @@
     "@types/multer": "^1.4.13",
     "@types/node": "^24.0.3",
     "express": "^5.1.0",
+    "hono": "^4.10.0",
     "multer": "^2.0.1",
     "zod": "^4.0.5"
   },
@@ -77,4 +78,4 @@
     "url": "https://github.com/PeterOsinski/ts-typed-api/issues"
   },
   "homepage": "https://github.com/PeterOsinski/ts-typed-api#readme"
-}
+}