ts-procedures 3.3.4 → 4.0.0

package/build/implementations/http/hono-stream/index.test.js

@@ -19,7 +19,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('StreamMessages', { scope: 'messages', version: 1 }, async function* (ctx) {
                 yield { message: 'hello' };
-                yield { message: 'world' };
+                yield { data: { message: 'world' } };
             });
             builder.register(RPC, () => ({ userId: '123' }));
             const app = builder.build();
@@ -35,7 +35,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ app: customApp });
             const RPC = Procedures();
             RPC.CreateStream('StreamData', { scope: 'data', version: 1 }, async function* () {
-                yield { data: 1 };
+                yield { data: { data: 1 } };
             });
             builder.register(RPC, () => ({ userId: '123' }));
             const app = builder.build();
@@ -67,9 +67,9 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Counter', { scope: 'counter', version: 1 }, async function* () {
-                yield { count: 1 };
-                yield { count: 2 };
-                yield { count: 3 };
+                yield { data: { count: 1 } };
+                yield { data: { count: 2 } };
+                yield { data: { count: 3 } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -89,7 +89,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -100,7 +100,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ defaultStreamMode: 'sse' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -152,7 +152,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { method: 'works' };
+                yield { data: { method: 'works' } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -163,7 +163,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { method: 'works' };
+                yield { data: { method: 'works' } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -213,7 +213,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: '/api/v1' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -224,7 +224,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: 'custom' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -235,7 +235,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: '/api' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield {};
+                yield { data: {} };
             });
             builder.register(RPC, () => ({}));
             builder.build();
@@ -251,7 +251,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onRequestStart });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -264,11 +264,12 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onRequestEnd });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
-            await app.request('/test/test/1');
+            const response = await app.request('/test/test/1');
+            await response.text(); // Consume stream to trigger onRequestEnd
             expect(onRequestEnd).toHaveBeenCalledTimes(1);
             expect(onRequestEnd.mock.calls[0][0]).toHaveProperty('req');
         });
@@ -277,7 +278,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onStreamStart });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -290,7 +291,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onStreamEnd });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -311,7 +312,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
                 order.push('handler');
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -329,6 +330,8 @@ describe('HonoStreamAppBuilder', () => {
             expect(order[0]).toBe('request-start');
             // stream-start should be before handler
             expect(order.indexOf('stream-start')).toBeLessThan(order.indexOf('handler'));
+            // request-end should be last
+            expect(order[order.length - 1]).toBe('request-end');
         });
     });
     // --------------------------------------------------------------------------
@@ -339,21 +342,32 @@ describe('HonoStreamAppBuilder', () => {
             const errorHandler = vi.fn((procedure, c, error) => {
                 return c.json({ customError: error.message }, 400);
             });
-            const builder = new HonoStreamAppBuilder({ onStreamError: errorHandler });
+            const builder = new HonoStreamAppBuilder({ onPreStreamError: errorHandler });
             const RPC = Procedures();
-            // Error during context resolution (before streaming starts)
-            builder.register(RPC, () => {
-                throw new Error('Context error');
+            RPC.CreateStream('ValidatedStream', {
+                scope: 'validated',
+                version: 1,
+                schema: {
+                    params: v.object({ count: v.number() }),
+                },
+            }, async function* (ctx, params) {
+                yield { data: { count: params.count } };
             });
+            builder.register(RPC, () => ({}));
             const app = builder.build();
-            // Since no streaming procedures were registered, this should 404
-            // Let's test with a real streaming procedure that throws during setup
+            const res = await app.request('/validated/validated-stream/1?count=not-a-number');
+            expect(res.status).toBe(400);
+            const body = await res.json();
+            expect(body.customError).toContain('Validation error');
+            expect(errorHandler).toHaveBeenCalledTimes(1);
+            expect(errorHandler.mock.calls[0][0].name).toBe('ValidatedStream');
+            expect(errorHandler.mock.calls[0][2].message).toContain('Validation error');
         });
         test('errors during streaming are sent as error events (SSE mode)', async () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
-                yield { count: 1 };
+                yield { data: { count: 1 } };
                 throw new Error('Stream error');
             });
             builder.register(RPC, () => ({}));
@@ -380,11 +394,8 @@ describe('HonoStreamAppBuilder', () => {
             // Error is wrapped by Procedures with "Error in streaming handler for {name}" prefix
             expect(JSON.parse(lines[1]).error).toContain('Stream error');
         });
-        test('onStreamError is called when params fail validation', async () => {
-            const onStreamError = vi.fn((procedure, c, error) => {
-                return c.json({ error: error.message }, 400);
-            });
-            const builder = new HonoStreamAppBuilder({ onStreamError });
+        test('validation errors return 400 by default when no error handler', async () => {
+            const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('ValidatedStream', {
                 scope: 'validated',
@@ -393,22 +404,22 @@ describe('HonoStreamAppBuilder', () => {
                     params: v.object({ count: v.number() }),
                 },
             }, async function* (ctx, params) {
-                yield { count: params.count };
+                yield { data: { count: params.count } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
             const res = await app.request('/validated/validated-stream/1?count=not-a-number');
-            // HTTP error response returned (not a stream)
+            // Default: returns 400 JSON error
             expect(res.status).toBe(400);
             const body = await res.json();
             expect(body.error).toContain('Validation error');
-            // onStreamError callback was called
-            expect(onStreamError).toHaveBeenCalledTimes(1);
-            expect(onStreamError.mock.calls[0][0].name).toBe('ValidatedStream');
-            expect(onStreamError.mock.calls[0][2].message).toContain('Validation error');
         });
-        test('validation errors return 400 by default when no onStreamError handler', async () => {
-            const builder = new HonoStreamAppBuilder();
+        // Tests for onPreStreamError and onMidStreamError callbacks
+        test('onPreStreamError handles validation errors with custom Response', async () => {
+            const onPreStreamError = vi.fn((procedure, c, error) => {
+                return c.json({ customError: true, procedureName: procedure.name, details: error.message }, 422);
+            });
+            const builder = new HonoStreamAppBuilder({ onPreStreamError });
             const RPC = Procedures();
             RPC.CreateStream('ValidatedStream', {
                 scope: 'validated',
@@ -417,15 +428,115 @@ describe('HonoStreamAppBuilder', () => {
                     params: v.object({ count: v.number() }),
                 },
             }, async function* (ctx, params) {
-                yield { count: params.count };
+                yield { data: { count: params.count } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
             const res = await app.request('/validated/validated-stream/1?count=not-a-number');
-            // Default: returns 400 JSON error
-            expect(res.status).toBe(400);
+            expect(res.status).toBe(422);
             const body = await res.json();
-            expect(body.error).toContain('Validation error');
+            expect(body.customError).toBe(true);
+            expect(body.procedureName).toBe('ValidatedStream');
+            expect(body.details).toContain('Validation error');
+            expect(onPreStreamError).toHaveBeenCalledTimes(1);
+        });
+        test('onPreStreamError handles context resolution errors', async () => {
+            const onPreStreamError = vi.fn((procedure, c, error) => {
+                return c.json({ contextError: error.message }, 401);
+            });
+            const builder = new HonoStreamAppBuilder({ onPreStreamError });
+            const RPC = Procedures();
+            RPC.CreateStream('SecureStream', { scope: 'secure', version: 1 }, async function* (ctx) {
+                yield { data: { userId: ctx.userId } };
+            });
+            builder.register(RPC, () => {
+                throw new Error('Authentication required');
+            });
+            const app = builder.build();
+            const res = await app.request('/secure/secure-stream/1');
+            expect(res.status).toBe(401);
+            const body = await res.json();
+            expect(body.contextError).toBe('Authentication required');
+            expect(onPreStreamError).toHaveBeenCalledTimes(1);
+        });
+        test('onMidStreamError returns custom value written to SSE stream', async () => {
+            const onMidStreamError = vi.fn((procedure, c, error) => {
+                return {
+                    data: {
+                        type: 'error',
+                        code: 'STREAM_FAILED',
+                        message: error.message,
+                        retryable: false,
+                    },
+                    closeStream: true,
+                };
+            });
+            const builder = new HonoStreamAppBuilder({ onMidStreamError });
+            const RPC = Procedures();
+            RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+                yield { data: { type: 'data', value: 1 } };
+                throw new Error('Something broke');
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/error/error-stream/1');
+            const text = await res.text();
+            // First yield should be present
+            expect(text).toContain('data: {"type":"data","value":1}');
+            // Error should use custom format from onMidStreamError
+            expect(text).toContain('data: {"type":"error","code":"STREAM_FAILED"');
+            expect(text).toContain('"retryable":false');
+            // Event should use procedure name (not 'error') since custom value provided
+            expect(text).toContain('event: ErrorStream');
+            expect(onMidStreamError).toHaveBeenCalledTimes(1);
+        });
+        test('onMidStreamError returns custom value written to text stream', async () => {
+            const onMidStreamError = vi.fn((procedure, c, error) => {
+                return {
+                    data: { type: 'error', message: error.message },
+                };
+            });
+            const builder = new HonoStreamAppBuilder({
+                defaultStreamMode: 'text',
+                onMidStreamError,
+            });
+            const RPC = Procedures();
+            RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+                yield { type: 'data', value: 'hello' };
+                throw new Error('Stream failed');
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/error/error-stream/1');
+            const text = await res.text();
+            const lines = text.trim().split('\n');
+            expect(JSON.parse(lines[0])).toEqual({ type: 'data', value: 'hello' });
+            // Error message may be wrapped by Procedures with "Error in streaming handler for X - " prefix
+            const errorLine = JSON.parse(lines[1]);
+            expect(errorLine.type).toBe('error');
+            expect(errorLine.message).toContain('Stream failed');
+            expect(onMidStreamError).toHaveBeenCalledTimes(1);
+        });
+        test('onMidStreamError returning undefined falls back to default error format', async () => {
+            const onMidStreamError = vi.fn(() => undefined);
+            const builder = new HonoStreamAppBuilder({
+                defaultStreamMode: 'text',
+                onMidStreamError,
+            });
+            const RPC = Procedures();
+            RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+                yield { value: 1 };
+                throw new Error('Fallback test');
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/error/error-stream/1');
+            const text = await res.text();
+            const lines = text.trim().split('\n');
+            expect(JSON.parse(lines[0])).toEqual({ value: 1 });
+            // Falls back to default { error: message } format
+            expect(JSON.parse(lines[1]).error).toContain('Fallback test');
+            expect(onMidStreamError).toHaveBeenCalledTimes(1);
         });
     });
     // --------------------------------------------------------------------------
@@ -535,7 +646,7 @@ describe('HonoStreamAppBuilder', () => {
             }));
             // Streaming procedure (should be registered)
             RPC.CreateStream('Stream', { scope: 'stream', version: 1 }, async function* () {
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -558,7 +669,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('StreamEvents', { scope: 'events', version: 1 }, async function* () {
-                yield {};
+                yield { data: {} };
             });
             builder.register(RPC, () => ({}), {
                 extendProcedureDoc: ({ base, procedure }) => ({
@@ -577,7 +688,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield {};
+                yield { data: {} };
             });
             builder.register(RPC, () => ({}), {
                 extendProcedureDoc: () => ({
@@ -627,7 +738,7 @@ describe('HonoStreamAppBuilder', () => {
             const SSERPC = Procedures();
             const TextRPC = Procedures();
             SSERPC.CreateStream('SSEStream', { scope: 'sse', version: 1 }, async function* () {
-                yield { mode: 'sse' };
+                yield { data: { mode: 'sse' } };
             });
             TextRPC.CreateStream('TextStream', { scope: 'text', version: 1 }, async function* () {
                 yield { mode: 'text' };
@@ -678,7 +789,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('CheckPrevalidated', { scope: 'check', version: 1 }, async function* (ctx) {
                 receivedIsPrevalidated = ctx.isPrevalidated;
-                yield { ok: true };
+                yield { data: { ok: true } };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -738,6 +849,77 @@ describe('HonoStreamAppBuilder', () => {
         });
     });
     // --------------------------------------------------------------------------
+    // SSE Yield Shape Tests
+    // --------------------------------------------------------------------------
+    describe('SSE yield shape', () => {
+        test('custom event names in yields', async () => {
+            const builder = new HonoStreamAppBuilder();
+            const RPC = Procedures();
+            RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
+                yield { data: { type: 'user_joined' }, event: 'join' };
+                yield { data: { type: 'message' }, event: 'chat' };
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/events/events/1');
+            const text = await res.text();
+            expect(text).toContain('event: join');
+            expect(text).toContain('event: chat');
+            expect(text).not.toContain('event: Events');
+        });
+        test('custom id in yields', async () => {
+            const builder = new HonoStreamAppBuilder();
+            const RPC = Procedures();
+            RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
+                yield { data: { msg: 'first' }, id: 'msg-001' };
+                yield { data: { msg: 'second' }, id: 'msg-002' };
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/events/events/1');
+            const text = await res.text();
+            expect(text).toContain('id: msg-001');
+            expect(text).toContain('id: msg-002');
+        });
+        test('string data pass-through without double-stringify', async () => {
+            const builder = new HonoStreamAppBuilder();
+            const RPC = Procedures();
+            RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
+                yield { data: 'already a string' };
+                yield { data: { needs: 'stringify' } };
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/events/events/1');
+            const text = await res.text();
+            // String data should be passed through as-is (not JSON-stringified again)
+            expect(text).toContain('data: already a string');
+            // Object data should be JSON-stringified
+            expect(text).toContain('data: {"needs":"stringify"}');
+        });
+        test('default event falls back to procedure name when omitted', async () => {
+            const builder = new HonoStreamAppBuilder();
+            const RPC = Procedures();
+            RPC.CreateStream('MyProcedure', { scope: 'test', version: 1 }, async function* () {
+                yield { data: { value: 1 } };
+                yield { data: { value: 2 }, event: 'custom' };
+                yield { data: { value: 3 } };
+            });
+            builder.register(RPC, () => ({}));
+            const app = builder.build();
+            const res = await app.request('/test/my-procedure/1');
+            const text = await res.text();
+            // Split into individual SSE messages
+            const messages = text.split('\n\n').filter(Boolean);
+            // First and third should use procedure name as event
+            expect(messages[0]).toContain('event: MyProcedure');
+            // Second should use custom event
+            expect(messages[1]).toContain('event: custom');
+            // Third should fall back to procedure name
+            expect(messages[2]).toContain('event: MyProcedure');
+        });
+    });
+    // --------------------------------------------------------------------------
     // Integration Test
     // --------------------------------------------------------------------------
     describe('integration', () => {