@fastify/sse 0.3.0 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/dependabot.yml +42 -2
- package/.github/workflows/ci.yml +6 -1
- package/.github/workflows/lock-threads.yml +19 -0
- package/LICENSE +22 -0
- package/README.md +149 -40
- package/bench/accept-header.js +344 -0
- package/bench/in-context.js +210 -0
- package/benching.md +106 -0
- package/eslint.config.js +5 -2
- package/examples/basic.js +130 -88
- package/examples/manual-streaming.js +81 -0
- package/index.js +355 -84
- package/package.json +13 -12
- package/test/basic.test.js +264 -16
- package/test/custom-headers.test.js +0 -6
- package/test/imports.test.js +50 -0
- package/test/lifecycle.test.js +0 -10
- package/test/manual.test.js +205 -0
- package/test/send-headers.test.js +263 -0
- package/types/index.d.ts +56 -11
- package/types/index.tst.ts +233 -0
- package/.github/.stale.yml +0 -21
- package/.github/tests_checker.yml +0 -8
- package/.github/workflows/package-manager-ci.yml +0 -24
- package/test-types/index.test-d.ts +0 -192
package/examples/basic.js
CHANGED
|
@@ -1,119 +1,161 @@
|
|
|
1
1
|
'use strict'
|
|
2
2
|
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
3
|
+
/**
|
|
4
|
+
* Example Basic with @fastify/sse
|
|
5
|
+
*
|
|
6
|
+
* Test endpoints with curl:
|
|
7
|
+
*
|
|
8
|
+
* curl -N -H "Accept: text/event-stream" http://localhost:3000/events
|
|
9
|
+
* curl -N -H "Accept: text/event-stream" http://localhost:3000/stream
|
|
10
|
+
* curl -N -H "Accept: text/event-stream" http://localhost:3000/live
|
|
11
|
+
* curl -N -H "Accept: text/event-stream" http://localhost:3000/headers
|
|
12
|
+
* curl -N -H "Accept: text/event-stream" http://localhost:3000/replay
|
|
13
|
+
*
|
|
14
|
+
**/
|
|
15
|
+
|
|
16
|
+
async function buildServer () {
|
|
17
|
+
const fastify = require('fastify')({ logger: true })
|
|
18
|
+
|
|
19
|
+
// Register the SSE plugin
|
|
20
|
+
await fastify.register(require('../index.js'))
|
|
21
|
+
|
|
22
|
+
// Basic SSE endpoint
|
|
23
|
+
fastify.get('/events', { sse: true }, async (request, reply) => {
|
|
24
|
+
// Send a simple message
|
|
25
|
+
await reply.sse.send({ data: 'Hello SSE!' })
|
|
26
|
+
|
|
27
|
+
// Send multiple events
|
|
28
|
+
for (let i = 0; i < 5; i++) {
|
|
29
|
+
await reply.sse.send({
|
|
30
|
+
id: String(i),
|
|
31
|
+
event: 'counter',
|
|
32
|
+
data: { count: i, timestamp: Date.now() }
|
|
33
|
+
})
|
|
34
|
+
}
|
|
21
35
|
|
|
22
|
-
|
|
23
|
-
})
|
|
36
|
+
// Connection will close automatically when handler ends
|
|
37
|
+
})
|
|
24
38
|
|
|
25
|
-
// Stream endpoint with async generator
|
|
26
|
-
fastify.get('/stream', { sse: true }, async (request, reply) => {
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
39
|
+
// Stream endpoint with async generator
|
|
40
|
+
fastify.get('/stream', { sse: true }, async (request, reply) => {
|
|
41
|
+
async function * generateEvents () {
|
|
42
|
+
for (let i = 0; i < 10; i++) {
|
|
43
|
+
await new Promise(resolve => setTimeout(resolve, 1000))
|
|
44
|
+
yield {
|
|
45
|
+
id: String(i),
|
|
46
|
+
event: 'tick',
|
|
47
|
+
data: { tick: i, time: new Date().toISOString() }
|
|
48
|
+
}
|
|
34
49
|
}
|
|
35
50
|
}
|
|
36
|
-
}
|
|
37
51
|
|
|
38
|
-
|
|
39
|
-
})
|
|
40
|
-
|
|
41
|
-
// Persistent connection with keepAlive
|
|
42
|
-
fastify.get('/live', { sse: true }, async (request, reply) => {
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
52
|
+
await reply.sse.send(generateEvents())
|
|
53
|
+
})
|
|
54
|
+
|
|
55
|
+
// Persistent connection with keepAlive
|
|
56
|
+
fastify.get('/live', { sse: true }, async (request, reply) => {
|
|
57
|
+
// Keep connection alive
|
|
58
|
+
reply.sse.keepAlive()
|
|
59
|
+
|
|
60
|
+
// Send initial event
|
|
61
|
+
await reply.sse.send({ data: 'Connected to live stream' })
|
|
62
|
+
|
|
63
|
+
// Send periodic updates
|
|
64
|
+
const interval = setInterval(async () => {
|
|
65
|
+
try {
|
|
66
|
+
if (reply.sse.isConnected) {
|
|
67
|
+
await reply.sse.send({
|
|
68
|
+
event: 'heartbeat',
|
|
69
|
+
data: { timestamp: Date.now() }
|
|
70
|
+
})
|
|
71
|
+
} else {
|
|
72
|
+
clearInterval(interval)
|
|
73
|
+
}
|
|
74
|
+
} catch (error) {
|
|
58
75
|
clearInterval(interval)
|
|
59
76
|
}
|
|
60
|
-
}
|
|
77
|
+
}, 2000)
|
|
78
|
+
|
|
79
|
+
// Clean up on close
|
|
80
|
+
reply.sse.onClose(() => {
|
|
61
81
|
clearInterval(interval)
|
|
62
|
-
|
|
63
|
-
|
|
82
|
+
console.log('Live stream connection closed')
|
|
83
|
+
})
|
|
84
|
+
})
|
|
85
|
+
|
|
86
|
+
// Custom headers with sendHeaders
|
|
87
|
+
fastify.get('/headers', { sse: true }, async (request, reply) => {
|
|
88
|
+
// Set custom headers using Fastify's header methods
|
|
89
|
+
reply.header('X-Session-ID', 'session-12345')
|
|
90
|
+
reply.header('X-API-Version', 'v1.2.3')
|
|
91
|
+
reply.headers({
|
|
92
|
+
'X-User-Agent': request.headers['user-agent'] || 'unknown',
|
|
93
|
+
'X-Request-Time': new Date().toISOString()
|
|
94
|
+
})
|
|
95
|
+
|
|
96
|
+
// Manually send headers before any SSE data
|
|
97
|
+
reply.sse.sendHeaders()
|
|
64
98
|
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
99
|
+
// Now send SSE data
|
|
100
|
+
await reply.sse.send({
|
|
101
|
+
data: 'Headers sent manually before this message',
|
|
102
|
+
event: 'custom-headers'
|
|
103
|
+
})
|
|
69
104
|
})
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
105
|
+
|
|
106
|
+
// Replay functionality
|
|
107
|
+
const messageHistory = []
|
|
108
|
+
let eventId = 0
|
|
109
|
+
|
|
110
|
+
fastify.get('/replay', { sse: true }, async (request, reply) => {
|
|
111
|
+
// Handle replay if client reconnects
|
|
112
|
+
|
|
113
|
+
reply.sse.keepAlive()
|
|
114
|
+
|
|
115
|
+
await reply.sse.replay(async (lastEventId) => {
|
|
116
|
+
const startIndex = messageHistory.findIndex(msg => msg.id === lastEventId)
|
|
117
|
+
const messagesToReplay = startIndex !== -1
|
|
118
|
+
? messageHistory.slice(startIndex + 1)
|
|
119
|
+
: messageHistory
|
|
120
|
+
|
|
121
|
+
for (const message of messagesToReplay) {
|
|
122
|
+
await reply.sse.send(message)
|
|
123
|
+
}
|
|
124
|
+
})
|
|
125
|
+
|
|
126
|
+
// Send new message
|
|
127
|
+
const newMessage = {
|
|
128
|
+
id: String(++eventId),
|
|
129
|
+
data: { message: `New event ${eventId}`, timestamp: Date.now() }
|
|
86
130
|
}
|
|
87
|
-
})
|
|
88
131
|
|
|
89
|
-
|
|
90
|
-
const newMessage = {
|
|
91
|
-
id: String(++eventId),
|
|
92
|
-
data: { message: `New event ${eventId}`, timestamp: Date.now() }
|
|
93
|
-
}
|
|
132
|
+
messageHistory.push(newMessage)
|
|
94
133
|
|
|
95
|
-
|
|
134
|
+
// Keep only last 100 messages
|
|
135
|
+
if (messageHistory.length > 100) {
|
|
136
|
+
messageHistory.shift()
|
|
137
|
+
}
|
|
96
138
|
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
messageHistory.shift()
|
|
100
|
-
}
|
|
139
|
+
await reply.sse.send(newMessage)
|
|
140
|
+
})
|
|
101
141
|
|
|
102
|
-
|
|
103
|
-
}
|
|
142
|
+
return fastify
|
|
143
|
+
}
|
|
104
144
|
|
|
105
145
|
// Start the server
|
|
106
146
|
const start = async () => {
|
|
147
|
+
const server = await buildServer()
|
|
107
148
|
try {
|
|
108
|
-
await
|
|
149
|
+
await server.listen({ port: 3000, host: '0.0.0.0' })
|
|
109
150
|
console.log('Server listening on http://localhost:3000')
|
|
110
151
|
console.log('Try these endpoints:')
|
|
111
152
|
console.log(' GET /events - Basic SSE messages')
|
|
112
153
|
console.log(' GET /stream - Streaming with async generator')
|
|
113
154
|
console.log(' GET /live - Persistent connection with heartbeat')
|
|
155
|
+
console.log(' GET /headers - Custom headers with sendHeaders()')
|
|
114
156
|
console.log(' GET /replay - Messages with replay support')
|
|
115
157
|
} catch (err) {
|
|
116
|
-
|
|
158
|
+
server.log.error(err)
|
|
117
159
|
process.exit(1)
|
|
118
160
|
}
|
|
119
161
|
}
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
'use strict'
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* Dynamic streaming with @fastify/sse (`sse: 'manual'`)
|
|
5
|
+
*
|
|
6
|
+
* Some APIs — OpenAI-compatible and other LLM endpoints, for example —
|
|
7
|
+
* decide whether to stream based on the request *body* (`{ "stream": true }`)
|
|
8
|
+
* rather than the `Accept` header. `sse: 'manual'` skips Accept negotiation
|
|
9
|
+
* entirely: `reply.sse` is always attached and the handler decides at runtime
|
|
10
|
+
* whether to stream or to return a normal JSON response. The connection is
|
|
11
|
+
* closed automatically when the handler resolves or throws.
|
|
12
|
+
*
|
|
13
|
+
* Test endpoints with curl:
|
|
14
|
+
*
|
|
15
|
+
* # Streaming response (Server-Sent Events):
|
|
16
|
+
* curl -N -X POST http://localhost:3000/v1/chat/completions \
|
|
17
|
+
* -H "Content-Type: application/json" \
|
|
18
|
+
* -d '{"prompt":"hello","stream":true}'
|
|
19
|
+
*
|
|
20
|
+
* # Non-streaming response (single JSON object):
|
|
21
|
+
* curl -X POST http://localhost:3000/v1/chat/completions \
|
|
22
|
+
* -H "Content-Type: application/json" \
|
|
23
|
+
* -d '{"prompt":"hello","stream":false}'
|
|
24
|
+
*
|
|
25
|
+
**/
|
|
26
|
+
|
|
27
|
+
async function buildServer () {
|
|
28
|
+
const fastify = require('fastify')({ logger: true })
|
|
29
|
+
|
|
30
|
+
await fastify.register(require('../index.js'))
|
|
31
|
+
|
|
32
|
+
// A tiny stand-in for a model that emits tokens one at a time.
|
|
33
|
+
async function * generateTokens (prompt) {
|
|
34
|
+
const tokens = `Echo: ${prompt}`.split(' ')
|
|
35
|
+
for (let i = 0; i < tokens.length; i++) {
|
|
36
|
+
await new Promise(resolve => setTimeout(resolve, 200))
|
|
37
|
+
yield {
|
|
38
|
+
id: String(i),
|
|
39
|
+
event: 'token',
|
|
40
|
+
data: { index: i, token: tokens[i] }
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
fastify.post('/v1/chat/completions', { sse: 'manual' }, async (request, reply) => {
|
|
46
|
+
const { prompt = '', stream = false } = request.body ?? {}
|
|
47
|
+
|
|
48
|
+
if (stream) {
|
|
49
|
+
// Stream tokens as SSE. The SSE response headers are committed on the
|
|
50
|
+
// first send(); the connection closes when this handler resolves.
|
|
51
|
+
await reply.sse.send(generateTokens(prompt))
|
|
52
|
+
await reply.sse.send({ event: 'done', data: '[DONE]' })
|
|
53
|
+
return
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
// Non-streaming client — fall through to Fastify's normal JSON
|
|
57
|
+
// serialization. `reply.sse` was attached but never written to, so no
|
|
58
|
+
// SSE headers were sent.
|
|
59
|
+
return {
|
|
60
|
+
id: 'chatcmpl-1',
|
|
61
|
+
object: 'chat.completion',
|
|
62
|
+
choices: [{ message: { role: 'assistant', content: `Echo: ${prompt}` } }]
|
|
63
|
+
}
|
|
64
|
+
})
|
|
65
|
+
|
|
66
|
+
return fastify
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
const start = async () => {
|
|
70
|
+
const server = await buildServer()
|
|
71
|
+
try {
|
|
72
|
+
await server.listen({ port: 3000, host: '0.0.0.0' })
|
|
73
|
+
console.log('Server listening on http://localhost:3000')
|
|
74
|
+
console.log('Try POST /v1/chat/completions with {"stream": true} or {"stream": false}')
|
|
75
|
+
} catch (err) {
|
|
76
|
+
server.log.error(err)
|
|
77
|
+
process.exit(1)
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
start()
|