@efebia/fastify-zod-reply 1.3.0 → 1.4.0

package/lib/cjs/index.d.ts

@@ -23,12 +23,13 @@ export type FastifyReplyPluginOptions = {
 export type DecoratedReply = {
     [key in keyof FastifyStatusCode]: <T>(val?: T) => T;
 };
-declare module 'fastify' {
+declare module "fastify" {
     interface FastifyReply extends DecoratedReply {
     }
 }
 declare const _default: import("fastify").FastifyPluginCallback<FastifyReplyPluginOptions, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
 export default _default;
-export * from './error.js';
-export * from './routeV4.js';
-export * from './types.js';
+export * from "./error.js";
+export * from "./routeV4.js";
+export * from "./sseRouteV4.js";
+export * from "./types.js";

package/lib/cjs/index.js

@@ -22,28 +22,34 @@ const reply_js_1 = require("./reply.js");
 const utils_js_1 = require("./utils.js");
 const defaultOptions = {
     statusCodes: {
-        ok: { statusCode: 200, payload: { message: 'ok' } },
-        created: { statusCode: 201, payload: { message: 'created' } },
-        accepted: { statusCode: 202, payload: { message: 'accepted' } },
-        noContent: { statusCode: 204, payload: undefined },
-        badRequest: { statusCode: 400, payload: { message: 'badRequest' } },
-        unauthorized: { statusCode: 401, payload: { message: 'unauthorized' } },
-        forbidden: { statusCode: 403, payload: { message: 'forbidden' } },
-        notFound: { statusCode: 404, payload: { message: 'notFound' } },
-        notAcceptable: { statusCode: 406, payload: { message: 'notAcceptable' } },
-        conflict: { statusCode: 409, payload: { message: 'conflict' } },
-        internalServerError: { statusCode: 500, payload: { message: 'internalServerError' } },
-    }
+        ok: { statusCode: 200, payload: { message: "ok" } },
+        created: { statusCode: 201, payload: { message: "created" } },
+        accepted: { statusCode: 202, payload: { message: "accepted" } },
+        noContent: { statusCode: 204, payload: null },
+        badRequest: { statusCode: 400, payload: { message: "badRequest" } },
+        unauthorized: { statusCode: 401, payload: { message: "unauthorized" } },
+        forbidden: { statusCode: 403, payload: { message: "forbidden" } },
+        notFound: { statusCode: 404, payload: { message: "notFound" } },
+        notAcceptable: { statusCode: 406, payload: { message: "notAcceptable" } },
+        conflict: { statusCode: 409, payload: { message: "conflict" } },
+        internalServerError: {
+            statusCode: 500,
+            payload: { message: "internalServerError" },
+        },
+    },
 };
 exports.default = (0, fastify_plugin_1.default)(async (fastify, opts) => {
     const finalOptions = (0, utils_js_1.mergeDeep)(defaultOptions, opts);
     Object.entries(finalOptions.statusCodes).forEach(([key, value]) => {
         fastify.decorateReply(key, (0, reply_js_1.createReply)(value.statusCode, value.payload));
     });
+    fastify.decorateRequest("abortController");
+    fastify.decorateReply("sse");
 }, {
     fastify: "5.x",
-    name: '@efebia/fastify-zod-reply'
+    name: "@efebia/fastify-zod-reply",
 });
 __exportStar(require("./error.js"), exports);
 __exportStar(require("./routeV4.js"), exports);
+__exportStar(require("./sseRouteV4.js"), exports);
 __exportStar(require("./types.js"), exports);

package/lib/cjs/routeHelpers.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+import { RouteV4Options } from "./routeV4.js";
+export declare const parse: (schema: z.ZodTypeAny, payload: any, tag: string) => Promise<{
+    tag: string;
+    success: true;
+    data: unknown;
+    error?: never;
+} | {
+    tag: string;
+    success: false;
+    data?: never;
+    error: z.ZodError<unknown>;
+}>;
+export declare const strictifySchema: (schema: z.ZodType, strict: boolean) => any;
+export declare const parseStrict: (tag: keyof Exclude<NonNullable<RouteV4Options["strict"]>, boolean>, value: NonNullable<RouteV4Options["strict"]>) => boolean;
+export declare const findStatusCode: (statusCode: number, availableStatusCodes: [string | number, any][]) => [string | number, any] | undefined;
+export declare const mapZodError: (zodError: z.ZodError, prefix: string) => string;

package/lib/cjs/routeHelpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapZodError = exports.findStatusCode = exports.parseStrict = exports.strictifySchema = exports.parse = void 0;
+const parse = async (schema, payload, tag) => {
+    const result = await schema.safeParseAsync(payload);
+    return Object.assign(Object.assign({}, result), { tag });
+};
+exports.parse = parse;
+const strictifySchema = (schema, strict) => {
+    if (!strict)
+        return schema;
+    return "strict" in schema && typeof schema["strict"] === "function"
+        ? schema.strict()
+        : schema;
+};
+exports.strictifySchema = strictifySchema;
+const parseStrict = (tag, value) => {
+    if (typeof value === "boolean")
+        return value;
+    return value[tag];
+};
+exports.parseStrict = parseStrict;
+const findStatusCode = (statusCode, availableStatusCodes) => {
+    return availableStatusCodes.find(([key]) => {
+        if (!["number", "string"].includes(typeof key))
+            return false;
+        if (typeof key === "number")
+            return statusCode === key;
+        if (/^[0-9]{3}$/.test(key))
+            return statusCode === parseInt(key);
+        if (/^[0-9]xx$/i.test(key))
+            return statusCode.toString()[0] === key[0];
+    });
+};
+exports.findStatusCode = findStatusCode;
+const mapZodError = (zodError, prefix) => {
+    return zodError.issues
+        .map((issue) => {
+        const pathStr = `Error at ${prefix}->${issue.path.join("->")}`;
+        return issue.message ? `${pathStr}->${issue.message}` : pathStr;
+    })
+        .join("\n");
+};
+exports.mapZodError = mapZodError;

package/lib/cjs/routeV4.d.ts

@@ -1,19 +1,21 @@
-import { z } from 'zod/v4';
-import { APIHandler, APIOptions, RouteSecurity, RouteTag } from './types.js';
+import { z } from "zod/v4";
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from "./types.js";
 export type BaseZodV4Schema = {
     Body?: z.ZodTypeAny;
     Params?: z.ZodTypeAny;
     Query?: z.ZodTypeAny;
     Headers?: z.ZodTypeAny;
-    Reply: z.ZodObject;
-    Security?: (RouteSecurity[keyof RouteSecurity])[];
+    Reply: z.ZodObject<{
+        [key: string | number]: z.ZodTypeAny;
+    }>;
+    Security?: RouteSecurity[keyof RouteSecurity][];
     Tags?: (keyof RouteTag)[];
 };
 export type FastifyZodV4Schema<TZodSchema extends BaseZodV4Schema> = {
-    Body: TZodSchema['Body'] extends z.ZodTypeAny ? z.output<TZodSchema['Body']> : undefined;
-    Params: TZodSchema['Params'] extends z.ZodTypeAny ? z.output<TZodSchema['Params']> : undefined;
-    Querystring: TZodSchema['Query'] extends z.ZodTypeAny ? z.output<TZodSchema['Query']> : undefined;
-    Reply: TZodSchema['Reply'] extends z.ZodTypeAny ? z.input<TZodSchema['Reply']>[keyof z.input<TZodSchema['Reply']>] : undefined;
+    Body: TZodSchema["Body"] extends z.ZodTypeAny ? z.output<TZodSchema["Body"]> : undefined;
+    Params: TZodSchema["Params"] extends z.ZodTypeAny ? z.output<TZodSchema["Params"]> : undefined;
+    Querystring: TZodSchema["Query"] extends z.ZodTypeAny ? z.output<TZodSchema["Query"]> : undefined;
+    Reply: TZodSchema["Reply"] extends z.ZodTypeAny ? z.input<TZodSchema["Reply"]>[keyof z.input<TZodSchema["Reply"]>] : undefined;
 };
 export type RouteV4Options = {
     strict?: boolean | {
@@ -23,9 +25,9 @@ export type RouteV4Options = {
         headers: boolean;
     };
 };
-export declare const createRouteV4: ({ strict: globalStrict }?: RouteV4Options) => <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
+export declare const createRouteV4: <RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}>({ strict: globalStrict }?: RouteV4Options) => <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<APIHandler<FastifySchema, RequestAugmentation, ReplyAugmentation>>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
     handler: APIHandler<FastifySchema>;
 };
-export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
+export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<APIHandler<FastifySchema, {}, {}>>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
     handler: APIHandler<FastifySchema>;
 };

package/lib/cjs/routeV4.js

@@ -3,67 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.routeV4 = exports.createRouteV4 = void 0;
 const v4_1 = require("zod/v4");
 const error_js_1 = require("./error.js");
-const mapZodError = (zodError, prefix) => {
-    return zodError.issues.map(issue => {
-        const pathStr = `Error at ${prefix}->${issue.path.join('->')}`;
-        return issue.message ? `${pathStr}->${issue.message}` : pathStr;
-    }).join('\n');
-};
-const parse = async (schema, payload, tag) => {
-    const result = await schema.safeParseAsync(payload);
-    return Object.assign(Object.assign({}, result), { tag });
-};
-const findStatusCode = (statusCode, availableStatusCodes) => {
-    return availableStatusCodes.find(([key]) => {
-        if (!['number', 'string'].includes(typeof key))
-            return false;
-        if (typeof key === 'number')
-            return statusCode === key;
-        if (/^[0-9]{3}$/.test(key))
-            return statusCode === parseInt(key);
-        if (/^[0-9]xx$/i.test(key))
-            return statusCode.toString()[0] === key[0];
-    });
-};
-const strictifySchema = (schema, strict) => {
-    if (!strict)
-        return schema;
-    return 'strict' in schema && typeof schema['strict'] === 'function' ? schema.strict() : schema;
-};
-const parseStrict = (tag, value) => {
-    if (typeof value === 'boolean')
-        return value;
-    return value[tag];
-};
+const routeHelpers_js_1 = require("./routeHelpers.js");
 const createRouteV4 = ({ strict: globalStrict = false } = {}) => (schema, handler, options) => {
-    const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.strict : globalStrict;
-    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: v4_1.z.toJSONSchema(strictifySchema(schema.Body, parseStrict('body', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Params && { params: v4_1.z.toJSONSchema(strictifySchema(schema.Params, parseStrict('params', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Query && { querystring: v4_1.z.toJSONSchema(strictifySchema(schema.Query, parseStrict('query', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Headers && { headers: v4_1.z.toJSONSchema(strictifySchema(schema.Headers, parseStrict('headers', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), { response: v4_1.z.toJSONSchema(schema.Reply.partial(), { reused: 'inline', target: "draft-7" })['properties'] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
+    const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== "undefined" ? options === null || options === void 0 ? void 0 : options.strict : globalStrict;
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && {
+        body: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Body, (0, routeHelpers_js_1.parseStrict)("body", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Params && {
+        params: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Params, (0, routeHelpers_js_1.parseStrict)("params", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Query && {
+        querystring: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Query, (0, routeHelpers_js_1.parseStrict)("query", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Headers && {
+        headers: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Headers, (0, routeHelpers_js_1.parseStrict)("headers", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), { response: v4_1.z.toJSONSchema(schema.Reply.partial(), {
+            reused: "inline",
+            target: "draft-7",
+        })["properties"] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
     return {
         schema: finalResult,
         handler,
         preHandler: async (request, reply) => {
             var _a, _b, _c;
             const results = await Promise.all([
-                ...(schema.Body ? [parse(schema.Body, request.body, 'body')] : []),
-                ...(schema.Params ? [parse(schema.Params, request.params, 'params')] : []),
-                ...(schema.Query ? [parse(schema.Query, request.query, 'query')] : []),
+                ...(schema.Body ? [(0, routeHelpers_js_1.parse)(schema.Body, request.body, "body")] : []),
+                ...(schema.Params
+                    ? [(0, routeHelpers_js_1.parse)(schema.Params, request.params, "params")]
+                    : []),
+                ...(schema.Query
+                    ? [(0, routeHelpers_js_1.parse)(schema.Query, request.query, "query")]
+                    : []),
             ]);
             for (const result of results) {
                 if (!result.success) {
                     return reply
                         .code(400)
-                        .type('application/json')
+                        .type("application/json")
                         .send({
-                        message: mapZodError(result.error, result.tag),
+                        message: (0, routeHelpers_js_1.mapZodError)(result.error, result.tag),
                     });
                 }
             }
-            request.body = ((_a = results.find(r => r.tag === 'body')) === null || _a === void 0 ? void 0 : _a.data) || {};
-            request.params = ((_b = results.find(r => r.tag === 'params')) === null || _b === void 0 ? void 0 : _b.data) || {};
-            request.query = ((_c = results.find(r => r.tag === 'query')) === null || _c === void 0 ? void 0 : _c.data) || {};
+            request.body =
+                ((_a = results.find((r) => r.tag === "body")) === null || _a === void 0 ? void 0 : _a.data) || {};
+            request.params =
+                ((_b = results.find((r) => r.tag === "params")) === null || _b === void 0 ? void 0 : _b.data) || {};
+            request.query =
+                ((_c = results.find((r) => r.tag === "query")) === null || _c === void 0 ? void 0 : _c.data) || {};
         },
         preSerialization: (request, reply, payload, done) => {
-            const foundSchema = findStatusCode(reply.statusCode, Object.entries(schema.Reply.shape));
+            const foundSchema = (0, routeHelpers_js_1.findStatusCode)(reply.statusCode, Object.entries(schema.Reply.shape));
             if (!foundSchema) {
                 if (reply.statusCode >= 400)
                     return done(null, payload);
@@ -74,7 +61,7 @@ const createRouteV4 = ({ strict: globalStrict = false } = {}) => (schema, handle
             if (serialized.success) {
                 return done(null, serialized.data);
             }
-            return done(new error_js_1.FastifyZodReplyError(mapZodError(serialized.error, 'reply'), 500));
+            return done(new error_js_1.FastifyZodReplyError((0, routeHelpers_js_1.mapZodError)(serialized.error, "reply"), 500));
         },
     };
 };

package/lib/cjs/sseHelpers.d.ts

@@ -0,0 +1,9 @@
+import { FastifyReply } from "fastify";
+import { z } from "zod/v4";
+import { SSEReplyShape, SSERouteV4Options } from "./sseRouteV4.js";
+export declare function sendSseStream<T extends SSEReplyShape>({ reply, stream, schema, options, }: {
+    reply: FastifyReply;
+    stream: AsyncGenerator<T>;
+    schema: z.ZodType<T>;
+    options?: SSERouteV4Options["sse"];
+}): Promise<never>;

package/lib/cjs/sseHelpers.js

@@ -0,0 +1,111 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSseStream = sendSseStream;
+const node_stream_1 = require("node:stream");
+const error_js_1 = require("./error.js");
+const routeHelpers_js_1 = require("./routeHelpers.js");
+async function sendSseStream({ reply, stream, schema, options = {}, }) {
+    var _a;
+    reply.headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        Vary: "Origin",
+        "X-Accel-Buffering": "no",
+    });
+    const sseStream = node_stream_1.Readable.from(createSSEStream({
+        stream,
+        schema,
+        logger: reply.log,
+        validate: (_a = options.validateStream) !== null && _a !== void 0 ? _a : true,
+        intervalMs: options.keepAliveInterval,
+        onError: options.onError,
+    }));
+    return reply.send(sseStream);
+}
+function createSSEStream(_a) {
+    return __asyncGenerator(this, arguments, function* createSSEStream_1({ stream, schema, logger, validate, onError, intervalMs = 30000, }) {
+        const streamIterator = stream[Symbol.asyncIterator]();
+        let keepAliveTimeout = null;
+        const scheduleKeepAlive = () => new Promise((resolve) => {
+            if (keepAliveTimeout)
+                clearTimeout(keepAliveTimeout);
+            keepAliveTimeout = setTimeout(() => resolve({ isKeepAlive: true }), intervalMs);
+        });
+        let nextChunkPromise = streamIterator.next();
+        try {
+            while (true) {
+                const keepAlivePromise = scheduleKeepAlive();
+                const result = yield __await(Promise.race([nextChunkPromise, keepAlivePromise]));
+                if ("isKeepAlive" in result && result.isKeepAlive) {
+                    yield yield __await(": keep-alive\n\n");
+                    continue;
+                }
+                if ("done" in result) {
+                    if (keepAliveTimeout)
+                        clearTimeout(keepAliveTimeout);
+                    if (result.done)
+                        break;
+                    let itemToSend;
+                    if (validate) {
+                        const validation = schema.safeParse(result.value);
+                        if (!validation.success) {
+                            const errorMessage = (0, routeHelpers_js_1.mapZodError)(validation.error, "stream-item");
+                            logger.error(`SSE Stream validation error: ${errorMessage}`);
+                            if (onError)
+                                onError(new error_js_1.FastifyZodReplyError(errorMessage, 500));
+                            yield yield __await(formatSSEMessage({ event: "error", data: errorMessage }));
+                            nextChunkPromise = streamIterator.next();
+                            continue;
+                        }
+                        itemToSend = validation.data;
+                    }
+                    else {
+                        itemToSend = result.value;
+                    }
+                    yield yield __await(formatSSEMessage(itemToSend));
+                    nextChunkPromise = streamIterator.next();
+                }
+            }
+        }
+        catch (error) {
+            if (onError)
+                onError(error);
+            logger.error(error);
+            if (error instanceof Error && error.name !== "AbortError") {
+                yield yield __await(formatSSEMessage({ event: "error", data: error.message }));
+            }
+        }
+        finally {
+            if (keepAliveTimeout)
+                clearTimeout(keepAliveTimeout);
+        }
+    });
+}
+function formatSSEMessage(message) {
+    let output = "";
+    if (message.id !== undefined) {
+        output += `id: ${String(message.id)}\n`;
+    }
+    if (message.retry !== undefined) {
+        output += `retry: ${message.retry}\n`;
+    }
+    if (message.event) {
+        output += `event: ${message.event}\n`;
+    }
+    output += `data: ${JSON.stringify(message.data)}\n\n`;
+    return output;
+}

package/lib/cjs/sseRouteV4.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod/v4";
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from "./types.js";
+export type SSEReplyShape = {
+    data: unknown;
+    event?: string | undefined;
+    id?: string | number | undefined;
+    retry?: number | undefined;
+};
+export type SSEBaseZodV4Schema = {
+    Body?: z.ZodTypeAny;
+    Params?: z.ZodTypeAny;
+    Query?: z.ZodTypeAny;
+    Headers?: z.ZodTypeAny;
+    Reply: z.ZodObject<{
+        SSE: z.ZodType<SSEReplyShape>;
+        [key: string | number]: z.ZodTypeAny;
+    }>;
+    Security?: RouteSecurity[keyof RouteSecurity][];
+    Tags?: (keyof RouteTag)[];
+};
+type TransformSSETo200<T> = {
+    [K in keyof T as K extends "SSE" ? 200 : K]: T[K];
+};
+export type FastifySSEZodV4Schema<TZodSchema extends SSEBaseZodV4Schema> = {
+    Body: TZodSchema["Body"] extends z.ZodTypeAny ? z.output<TZodSchema["Body"]> : undefined;
+    Params: TZodSchema["Params"] extends z.ZodTypeAny ? z.output<TZodSchema["Params"]> : undefined;
+    Querystring: TZodSchema["Query"] extends z.ZodTypeAny ? z.output<TZodSchema["Query"]> : undefined;
+    Reply: TZodSchema["Reply"] extends z.ZodTypeAny ? TransformSSETo200<z.input<TZodSchema["Reply"]>> : undefined;
+};
+export type SSERouteV4Options = {
+    strict?: boolean | {
+        body: boolean;
+        query: boolean;
+        params: boolean;
+        headers: boolean;
+    };
+    sse?: {
+        keepAliveInterval?: number;
+        onError?: undefined | ((error: unknown) => void);
+        validateStream?: boolean;
+    };
+};
+export type SSEAugmentedAPIHandler<TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema>, RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}> = APIHandler<FastifySchema, RequestAugmentation & {
+    abortController: AbortController;
+}, ReplyAugmentation & {
+    sse<T extends z.input<TSchema["Reply"]>["SSE"]>(options: {
+        stream: AsyncGenerator<T>;
+        onError?: (error: unknown) => void;
+    }): Promise<T>;
+}>;
+export declare function createSSERouteV4<RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}>(globalOptions?: SSERouteV4Options): <TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema> = FastifySSEZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<SSEAugmentedAPIHandler<TSchema, FastifySchema, RequestAugmentation, ReplyAugmentation>>, options?: SSERouteV4Options) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};
+export declare const sseRouteV4: <TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema> = FastifySSEZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<SSEAugmentedAPIHandler<TSchema, FastifySchema, {}, {}>>, options?: SSERouteV4Options) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};
+export {};

package/lib/cjs/sseRouteV4.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sseRouteV4 = void 0;
+exports.createSSERouteV4 = createSSERouteV4;
+const v4_1 = require("zod/v4");
+const routeHelpers_js_1 = require("./routeHelpers.js");
+const sseHelpers_js_1 = require("./sseHelpers.js");
+function createSSERouteV4(globalOptions = {}) {
+    return (schema, handler, options) => {
+        const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== "undefined"
+            ? options === null || options === void 0 ? void 0 : options.strict
+            : typeof globalOptions.strict !== "undefined"
+                ? globalOptions.strict
+                : false;
+        const sseOptions = Object.assign(Object.assign({}, globalOptions.sse), options === null || options === void 0 ? void 0 : options.sse);
+        const responseJsonSchema = v4_1.z.toJSONSchema(schema.Reply, {
+            reused: "inline",
+            target: "draft-7",
+        })["properties"];
+        const responseSSESchema = responseJsonSchema["SSE"];
+        if (!responseJsonSchema || responseSSESchema === undefined) {
+            throw new Error("An SSE endpoint must define a schema for the 200 status code.");
+        }
+        delete responseJsonSchema["SSE"];
+        const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && {
+            body: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Body, (0, routeHelpers_js_1.parseStrict)("body", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Params && {
+            params: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Params, (0, routeHelpers_js_1.parseStrict)("params", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Query && {
+            querystring: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Query, (0, routeHelpers_js_1.parseStrict)("query", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Headers && {
+            headers: v4_1.z.toJSONSchema((0, routeHelpers_js_1.strictifySchema)(schema.Headers, (0, routeHelpers_js_1.parseStrict)("headers", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), { response: Object.assign(Object.assign({}, responseJsonSchema), { 200: {
+                    content: {
+                        "text/event-stream": {
+                            schema: responseSSESchema,
+                        },
+                    },
+                } }) }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
+        return {
+            schema: finalResult,
+            handler,
+            preHandler: async (request, reply) => {
+                var _a, _b, _c;
+                const results = await Promise.all([
+                    ...(schema.Body ? [(0, routeHelpers_js_1.parse)(schema.Body, request.body, "body")] : []),
+                    ...(schema.Params
+                        ? [(0, routeHelpers_js_1.parse)(schema.Params, request.params, "params")]
+                        : []),
+                    ...(schema.Query
+                        ? [(0, routeHelpers_js_1.parse)(schema.Query, request.query, "query")]
+                        : []),
+                ]);
+                for (const result of results) {
+                    if (!result.success) {
+                        return reply
+                            .code(400)
+                            .type("application/json")
+                            .send({
+                            message: (0, routeHelpers_js_1.mapZodError)(result.error, result.tag),
+                        });
+                    }
+                }
+                request.body =
+                    ((_a = results.find((r) => r.tag === "body")) === null || _a === void 0 ? void 0 : _a.data) || {};
+                request.params =
+                    ((_b = results.find((r) => r.tag === "params")) === null || _b === void 0 ? void 0 : _b.data) || {};
+                request.query =
+                    ((_c = results.find((r) => r.tag === "query")) === null || _c === void 0 ? void 0 : _c.data) || {};
+                const abortController = new AbortController();
+                request.socket.on("close", () => abortController.abort());
+                request.abortController = abortController;
+                reply.sse = async (options) => (0, sseHelpers_js_1.sendSseStream)({
+                    reply,
+                    stream: options.stream,
+                    schema: schema.Reply.shape["SSE"],
+                    options: sseOptions,
+                });
+            },
+        };
+    };
+}
+exports.sseRouteV4 = createSSERouteV4({ strict: false });

package/lib/cjs/types.d.ts

@@ -1,6 +1,7 @@
-import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
+import { ContextConfigDefault, FastifyBaseLogger, FastifyInstance, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteShorthandOptions } from "fastify";
+import { ResolveFastifyReplyReturnType } from "fastify/types/type-provider.js";
 export type APIOptions<RouteInterface extends RouteGenericInterface = RouteGenericInterface> = RouteShorthandOptions<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, RouteInterface>;
-export type APIHandler<RouteInterface extends RouteGenericInterface = RouteGenericInterface> = RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, RouteInterface>;
+export type APIHandler<RouteInterface extends RouteGenericInterface = RouteGenericInterface, RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}> = (this: FastifyInstance<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, FastifyBaseLogger, FastifyTypeProviderDefault>, request: FastifyRequest<RouteInterface, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, FastifySchema, FastifyTypeProviderDefault, ContextConfigDefault, FastifyBaseLogger> & RequestAugmentation, reply: FastifyReply<RouteInterface, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault> & ReplyAugmentation) => ResolveFastifyReplyReturnType<FastifyTypeProviderDefault, FastifySchema, RouteInterface>;
 export interface RouteTag {
 }
 export interface RouteSecurity {

package/lib/cjs/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function isObject(item: any): any;
 export declare function mergeDeep<TResult extends object>(target: TResult, ...sources: any[]): TResult;
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/cjs/utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isObject = isObject;
 exports.mergeDeep = mergeDeep;
+exports.sleep = sleep;
 function isObject(item) {
     return (item && typeof item === 'object' && !Array.isArray(item));
 }
@@ -23,3 +24,6 @@ function mergeDeep(target, ...sources) {
     }
     return mergeDeep(target, ...sources);
 }
+async function sleep(ms) {
+    return new Promise((resolve) => { setTimeout(resolve, ms); });
+}

package/lib/esm/index.d.ts

@@ -23,12 +23,13 @@ export type FastifyReplyPluginOptions = {
 export type DecoratedReply = {
     [key in keyof FastifyStatusCode]: <T>(val?: T) => T;
 };
-declare module 'fastify' {
+declare module "fastify" {
     interface FastifyReply extends DecoratedReply {
     }
 }
 declare const _default: import("fastify").FastifyPluginCallback<FastifyReplyPluginOptions, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
 export default _default;
-export * from './error.js';
-export * from './routeV4.js';
-export * from './types.js';
+export * from "./error.js";
+export * from "./routeV4.js";
+export * from "./sseRouteV4.js";
+export * from "./types.js";

package/lib/esm/index.js

@@ -3,28 +3,34 @@ import { createReply } from "./reply.js";
 import { mergeDeep } from "./utils.js";
 const defaultOptions = {
     statusCodes: {
-        ok: { statusCode: 200, payload: { message: 'ok' } },
-        created: { statusCode: 201, payload: { message: 'created' } },
-        accepted: { statusCode: 202, payload: { message: 'accepted' } },
-        noContent: { statusCode: 204, payload: undefined },
-        badRequest: { statusCode: 400, payload: { message: 'badRequest' } },
-        unauthorized: { statusCode: 401, payload: { message: 'unauthorized' } },
-        forbidden: { statusCode: 403, payload: { message: 'forbidden' } },
-        notFound: { statusCode: 404, payload: { message: 'notFound' } },
-        notAcceptable: { statusCode: 406, payload: { message: 'notAcceptable' } },
-        conflict: { statusCode: 409, payload: { message: 'conflict' } },
-        internalServerError: { statusCode: 500, payload: { message: 'internalServerError' } },
-    }
+        ok: { statusCode: 200, payload: { message: "ok" } },
+        created: { statusCode: 201, payload: { message: "created" } },
+        accepted: { statusCode: 202, payload: { message: "accepted" } },
+        noContent: { statusCode: 204, payload: null },
+        badRequest: { statusCode: 400, payload: { message: "badRequest" } },
+        unauthorized: { statusCode: 401, payload: { message: "unauthorized" } },
+        forbidden: { statusCode: 403, payload: { message: "forbidden" } },
+        notFound: { statusCode: 404, payload: { message: "notFound" } },
+        notAcceptable: { statusCode: 406, payload: { message: "notAcceptable" } },
+        conflict: { statusCode: 409, payload: { message: "conflict" } },
+        internalServerError: {
+            statusCode: 500,
+            payload: { message: "internalServerError" },
+        },
+    },
 };
 export default fp(async (fastify, opts) => {
     const finalOptions = mergeDeep(defaultOptions, opts);
     Object.entries(finalOptions.statusCodes).forEach(([key, value]) => {
         fastify.decorateReply(key, createReply(value.statusCode, value.payload));
     });
+    fastify.decorateRequest("abortController");
+    fastify.decorateReply("sse");
 }, {
     fastify: "5.x",
-    name: '@efebia/fastify-zod-reply'
+    name: "@efebia/fastify-zod-reply",
 });
-export * from './error.js';
-export * from './routeV4.js';
-export * from './types.js';
+export * from "./error.js";
+export * from "./routeV4.js";
+export * from "./sseRouteV4.js";
+export * from "./types.js";

package/lib/esm/routeHelpers.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+import { RouteV4Options } from "./routeV4.js";
+export declare const parse: (schema: z.ZodTypeAny, payload: any, tag: string) => Promise<{
+    tag: string;
+    success: true;
+    data: unknown;
+    error?: never;
+} | {
+    tag: string;
+    success: false;
+    data?: never;
+    error: z.ZodError<unknown>;
+}>;
+export declare const strictifySchema: (schema: z.ZodType, strict: boolean) => any;
+export declare const parseStrict: (tag: keyof Exclude<NonNullable<RouteV4Options["strict"]>, boolean>, value: NonNullable<RouteV4Options["strict"]>) => boolean;
+export declare const findStatusCode: (statusCode: number, availableStatusCodes: [string | number, any][]) => [string | number, any] | undefined;
+export declare const mapZodError: (zodError: z.ZodError, prefix: string) => string;

package/lib/esm/routeHelpers.js

@@ -0,0 +1,36 @@
+export const parse = async (schema, payload, tag) => {
+    const result = await schema.safeParseAsync(payload);
+    return Object.assign(Object.assign({}, result), { tag });
+};
+export const strictifySchema = (schema, strict) => {
+    if (!strict)
+        return schema;
+    return "strict" in schema && typeof schema["strict"] === "function"
+        ? schema.strict()
+        : schema;
+};
+export const parseStrict = (tag, value) => {
+    if (typeof value === "boolean")
+        return value;
+    return value[tag];
+};
+export const findStatusCode = (statusCode, availableStatusCodes) => {
+    return availableStatusCodes.find(([key]) => {
+        if (!["number", "string"].includes(typeof key))
+            return false;
+        if (typeof key === "number")
+            return statusCode === key;
+        if (/^[0-9]{3}$/.test(key))
+            return statusCode === parseInt(key);
+        if (/^[0-9]xx$/i.test(key))
+            return statusCode.toString()[0] === key[0];
+    });
+};
+export const mapZodError = (zodError, prefix) => {
+    return zodError.issues
+        .map((issue) => {
+        const pathStr = `Error at ${prefix}->${issue.path.join("->")}`;
+        return issue.message ? `${pathStr}->${issue.message}` : pathStr;
+    })
+        .join("\n");
+};

package/lib/esm/routeV4.d.ts

@@ -1,19 +1,21 @@
-import { z } from 'zod/v4';
-import { APIHandler, APIOptions, RouteSecurity, RouteTag } from './types.js';
+import { z } from "zod/v4";
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from "./types.js";
 export type BaseZodV4Schema = {
     Body?: z.ZodTypeAny;
     Params?: z.ZodTypeAny;
     Query?: z.ZodTypeAny;
     Headers?: z.ZodTypeAny;
-    Reply: z.ZodObject;
-    Security?: (RouteSecurity[keyof RouteSecurity])[];
+    Reply: z.ZodObject<{
+        [key: string | number]: z.ZodTypeAny;
+    }>;
+    Security?: RouteSecurity[keyof RouteSecurity][];
     Tags?: (keyof RouteTag)[];
 };
 export type FastifyZodV4Schema<TZodSchema extends BaseZodV4Schema> = {
-    Body: TZodSchema['Body'] extends z.ZodTypeAny ? z.output<TZodSchema['Body']> : undefined;
-    Params: TZodSchema['Params'] extends z.ZodTypeAny ? z.output<TZodSchema['Params']> : undefined;
-    Querystring: TZodSchema['Query'] extends z.ZodTypeAny ? z.output<TZodSchema['Query']> : undefined;
-    Reply: TZodSchema['Reply'] extends z.ZodTypeAny ? z.input<TZodSchema['Reply']>[keyof z.input<TZodSchema['Reply']>] : undefined;
+    Body: TZodSchema["Body"] extends z.ZodTypeAny ? z.output<TZodSchema["Body"]> : undefined;
+    Params: TZodSchema["Params"] extends z.ZodTypeAny ? z.output<TZodSchema["Params"]> : undefined;
+    Querystring: TZodSchema["Query"] extends z.ZodTypeAny ? z.output<TZodSchema["Query"]> : undefined;
+    Reply: TZodSchema["Reply"] extends z.ZodTypeAny ? z.input<TZodSchema["Reply"]>[keyof z.input<TZodSchema["Reply"]>] : undefined;
 };
 export type RouteV4Options = {
     strict?: boolean | {
@@ -23,9 +25,9 @@ export type RouteV4Options = {
         headers: boolean;
     };
 };
-export declare const createRouteV4: ({ strict: globalStrict }?: RouteV4Options) => <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
+export declare const createRouteV4: <RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}>({ strict: globalStrict }?: RouteV4Options) => <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<APIHandler<FastifySchema, RequestAugmentation, ReplyAugmentation>>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
     handler: APIHandler<FastifySchema>;
 };
-export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
+export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<APIHandler<FastifySchema, {}, {}>>, options?: RouteV4Options) => APIOptions<FastifySchema> & {
     handler: APIHandler<FastifySchema>;
 };

package/lib/esm/routeV4.js

@@ -1,63 +1,50 @@
-import { z } from 'zod/v4';
-import { FastifyZodReplyError } from './error.js';
-const mapZodError = (zodError, prefix) => {
-    return zodError.issues.map(issue => {
-        const pathStr = `Error at ${prefix}->${issue.path.join('->')}`;
-        return issue.message ? `${pathStr}->${issue.message}` : pathStr;
-    }).join('\n');
-};
-const parse = async (schema, payload, tag) => {
-    const result = await schema.safeParseAsync(payload);
-    return Object.assign(Object.assign({}, result), { tag });
-};
-const findStatusCode = (statusCode, availableStatusCodes) => {
-    return availableStatusCodes.find(([key]) => {
-        if (!['number', 'string'].includes(typeof key))
-            return false;
-        if (typeof key === 'number')
-            return statusCode === key;
-        if (/^[0-9]{3}$/.test(key))
-            return statusCode === parseInt(key);
-        if (/^[0-9]xx$/i.test(key))
-            return statusCode.toString()[0] === key[0];
-    });
-};
-const strictifySchema = (schema, strict) => {
-    if (!strict)
-        return schema;
-    return 'strict' in schema && typeof schema['strict'] === 'function' ? schema.strict() : schema;
-};
-const parseStrict = (tag, value) => {
-    if (typeof value === 'boolean')
-        return value;
-    return value[tag];
-};
+import { z } from "zod/v4";
+import { FastifyZodReplyError } from "./error.js";
+import { findStatusCode, mapZodError, parse, parseStrict, strictifySchema, } from "./routeHelpers.js";
 export const createRouteV4 = ({ strict: globalStrict = false } = {}) => (schema, handler, options) => {
-    const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== 'undefined' ? options === null || options === void 0 ? void 0 : options.strict : globalStrict;
-    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: z.toJSONSchema(strictifySchema(schema.Body, parseStrict('body', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Params && { params: z.toJSONSchema(strictifySchema(schema.Params, parseStrict('params', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Query && { querystring: z.toJSONSchema(strictifySchema(schema.Query, parseStrict('query', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), (schema.Headers && { headers: z.toJSONSchema(strictifySchema(schema.Headers, parseStrict('headers', strict)), { reused: 'inline', target: "draft-7", io: 'input' }) })), { response: z.toJSONSchema(schema.Reply.partial(), { reused: 'inline', target: "draft-7" })['properties'] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
+    const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== "undefined" ? options === null || options === void 0 ? void 0 : options.strict : globalStrict;
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && {
+        body: z.toJSONSchema(strictifySchema(schema.Body, parseStrict("body", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Params && {
+        params: z.toJSONSchema(strictifySchema(schema.Params, parseStrict("params", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Query && {
+        querystring: z.toJSONSchema(strictifySchema(schema.Query, parseStrict("query", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), (schema.Headers && {
+        headers: z.toJSONSchema(strictifySchema(schema.Headers, parseStrict("headers", strict)), { reused: "inline", target: "draft-7", io: "input" }),
+    })), { response: z.toJSONSchema(schema.Reply.partial(), {
+            reused: "inline",
+            target: "draft-7",
+        })["properties"] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
     return {
         schema: finalResult,
         handler,
         preHandler: async (request, reply) => {
             var _a, _b, _c;
             const results = await Promise.all([
-                ...(schema.Body ? [parse(schema.Body, request.body, 'body')] : []),
-                ...(schema.Params ? [parse(schema.Params, request.params, 'params')] : []),
-                ...(schema.Query ? [parse(schema.Query, request.query, 'query')] : []),
+                ...(schema.Body ? [parse(schema.Body, request.body, "body")] : []),
+                ...(schema.Params
+                    ? [parse(schema.Params, request.params, "params")]
+                    : []),
+                ...(schema.Query
+                    ? [parse(schema.Query, request.query, "query")]
+                    : []),
             ]);
             for (const result of results) {
                 if (!result.success) {
                     return reply
                         .code(400)
-                        .type('application/json')
+                        .type("application/json")
                         .send({
                         message: mapZodError(result.error, result.tag),
                     });
                 }
             }
-            request.body = ((_a = results.find(r => r.tag === 'body')) === null || _a === void 0 ? void 0 : _a.data) || {};
-            request.params = ((_b = results.find(r => r.tag === 'params')) === null || _b === void 0 ? void 0 : _b.data) || {};
-            request.query = ((_c = results.find(r => r.tag === 'query')) === null || _c === void 0 ? void 0 : _c.data) || {};
+            request.body =
+                ((_a = results.find((r) => r.tag === "body")) === null || _a === void 0 ? void 0 : _a.data) || {};
+            request.params =
+                ((_b = results.find((r) => r.tag === "params")) === null || _b === void 0 ? void 0 : _b.data) || {};
+            request.query =
+                ((_c = results.find((r) => r.tag === "query")) === null || _c === void 0 ? void 0 : _c.data) || {};
         },
         preSerialization: (request, reply, payload, done) => {
             const foundSchema = findStatusCode(reply.statusCode, Object.entries(schema.Reply.shape));
@@ -71,7 +58,7 @@ export const createRouteV4 = ({ strict: globalStrict = false } = {}) => (schema,
             if (serialized.success) {
                 return done(null, serialized.data);
             }
-            return done(new FastifyZodReplyError(mapZodError(serialized.error, 'reply'), 500));
+            return done(new FastifyZodReplyError(mapZodError(serialized.error, "reply"), 500));
         },
     };
 };

package/lib/esm/sseHelpers.d.ts

@@ -0,0 +1,9 @@
+import { FastifyReply } from "fastify";
+import { z } from "zod/v4";
+import { SSEReplyShape, SSERouteV4Options } from "./sseRouteV4.js";
+export declare function sendSseStream<T extends SSEReplyShape>({ reply, stream, schema, options, }: {
+    reply: FastifyReply;
+    stream: AsyncGenerator<T>;
+    schema: z.ZodType<T>;
+    options?: SSERouteV4Options["sse"];
+}): Promise<never>;

package/lib/esm/sseHelpers.js

@@ -0,0 +1,108 @@
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { Readable } from "node:stream";
+import { FastifyZodReplyError } from "./error.js";
+import { mapZodError } from "./routeHelpers.js";
+export async function sendSseStream({ reply, stream, schema, options = {}, }) {
+    var _a;
+    reply.headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        Vary: "Origin",
+        "X-Accel-Buffering": "no",
+    });
+    const sseStream = Readable.from(createSSEStream({
+        stream,
+        schema,
+        logger: reply.log,
+        validate: (_a = options.validateStream) !== null && _a !== void 0 ? _a : true,
+        intervalMs: options.keepAliveInterval,
+        onError: options.onError,
+    }));
+    return reply.send(sseStream);
+}
+function createSSEStream(_a) {
+    return __asyncGenerator(this, arguments, function* createSSEStream_1({ stream, schema, logger, validate, onError, intervalMs = 30000, }) {
+        const streamIterator = stream[Symbol.asyncIterator]();
+        let keepAliveTimeout = null;
+        const scheduleKeepAlive = () => new Promise((resolve) => {
+            if (keepAliveTimeout)
+                clearTimeout(keepAliveTimeout);
+            keepAliveTimeout = setTimeout(() => resolve({ isKeepAlive: true }), intervalMs);
+        });
+        let nextChunkPromise = streamIterator.next();
+        try {
+            while (true) {
+                const keepAlivePromise = scheduleKeepAlive();
+                const result = yield __await(Promise.race([nextChunkPromise, keepAlivePromise]));
+                if ("isKeepAlive" in result && result.isKeepAlive) {
+                    yield yield __await(": keep-alive\n\n");
+                    continue;
+                }
+                if ("done" in result) {
+                    if (keepAliveTimeout)
+                        clearTimeout(keepAliveTimeout);
+                    if (result.done)
+                        break;
+                    let itemToSend;
+                    if (validate) {
+                        const validation = schema.safeParse(result.value);
+                        if (!validation.success) {
+                            const errorMessage = mapZodError(validation.error, "stream-item");
+                            logger.error(`SSE Stream validation error: ${errorMessage}`);
+                            if (onError)
+                                onError(new FastifyZodReplyError(errorMessage, 500));
+                            yield yield __await(formatSSEMessage({ event: "error", data: errorMessage }));
+                            nextChunkPromise = streamIterator.next();
+                            continue;
+                        }
+                        itemToSend = validation.data;
+                    }
+                    else {
+                        itemToSend = result.value;
+                    }
+                    yield yield __await(formatSSEMessage(itemToSend));
+                    nextChunkPromise = streamIterator.next();
+                }
+            }
+        }
+        catch (error) {
+            if (onError)
+                onError(error);
+            logger.error(error);
+            if (error instanceof Error && error.name !== "AbortError") {
+                yield yield __await(formatSSEMessage({ event: "error", data: error.message }));
+            }
+        }
+        finally {
+            if (keepAliveTimeout)
+                clearTimeout(keepAliveTimeout);
+        }
+    });
+}
+function formatSSEMessage(message) {
+    let output = "";
+    if (message.id !== undefined) {
+        output += `id: ${String(message.id)}\n`;
+    }
+    if (message.retry !== undefined) {
+        output += `retry: ${message.retry}\n`;
+    }
+    if (message.event) {
+        output += `event: ${message.event}\n`;
+    }
+    output += `data: ${JSON.stringify(message.data)}\n\n`;
+    return output;
+}

package/lib/esm/sseRouteV4.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod/v4";
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from "./types.js";
+export type SSEReplyShape = {
+    data: unknown;
+    event?: string | undefined;
+    id?: string | number | undefined;
+    retry?: number | undefined;
+};
+export type SSEBaseZodV4Schema = {
+    Body?: z.ZodTypeAny;
+    Params?: z.ZodTypeAny;
+    Query?: z.ZodTypeAny;
+    Headers?: z.ZodTypeAny;
+    Reply: z.ZodObject<{
+        SSE: z.ZodType<SSEReplyShape>;
+        [key: string | number]: z.ZodTypeAny;
+    }>;
+    Security?: RouteSecurity[keyof RouteSecurity][];
+    Tags?: (keyof RouteTag)[];
+};
+type TransformSSETo200<T> = {
+    [K in keyof T as K extends "SSE" ? 200 : K]: T[K];
+};
+export type FastifySSEZodV4Schema<TZodSchema extends SSEBaseZodV4Schema> = {
+    Body: TZodSchema["Body"] extends z.ZodTypeAny ? z.output<TZodSchema["Body"]> : undefined;
+    Params: TZodSchema["Params"] extends z.ZodTypeAny ? z.output<TZodSchema["Params"]> : undefined;
+    Querystring: TZodSchema["Query"] extends z.ZodTypeAny ? z.output<TZodSchema["Query"]> : undefined;
+    Reply: TZodSchema["Reply"] extends z.ZodTypeAny ? TransformSSETo200<z.input<TZodSchema["Reply"]>> : undefined;
+};
+export type SSERouteV4Options = {
+    strict?: boolean | {
+        body: boolean;
+        query: boolean;
+        params: boolean;
+        headers: boolean;
+    };
+    sse?: {
+        keepAliveInterval?: number;
+        onError?: undefined | ((error: unknown) => void);
+        validateStream?: boolean;
+    };
+};
+export type SSEAugmentedAPIHandler<TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema>, RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}> = APIHandler<FastifySchema, RequestAugmentation & {
+    abortController: AbortController;
+}, ReplyAugmentation & {
+    sse<T extends z.input<TSchema["Reply"]>["SSE"]>(options: {
+        stream: AsyncGenerator<T>;
+        onError?: (error: unknown) => void;
+    }): Promise<T>;
+}>;
+export declare function createSSERouteV4<RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}>(globalOptions?: SSERouteV4Options): <TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema> = FastifySSEZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<SSEAugmentedAPIHandler<TSchema, FastifySchema, RequestAugmentation, ReplyAugmentation>>, options?: SSERouteV4Options) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};
+export declare const sseRouteV4: <TSchema extends SSEBaseZodV4Schema, FastifySchema extends FastifySSEZodV4Schema<TSchema> = FastifySSEZodV4Schema<TSchema>>(schema: TSchema, handler: NoInfer<SSEAugmentedAPIHandler<TSchema, FastifySchema, {}, {}>>, options?: SSERouteV4Options) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};
+export {};

package/lib/esm/sseRouteV4.js

@@ -0,0 +1,95 @@
+import { z } from "zod/v4";
+import { mapZodError, parse, parseStrict, strictifySchema, } from "./routeHelpers.js";
+import { sendSseStream } from "./sseHelpers.js";
+export function createSSERouteV4(globalOptions = {}) {
+    return (schema, handler, options) => {
+        const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) !== "undefined"
+            ? options === null || options === void 0 ? void 0 : options.strict
+            : typeof globalOptions.strict !== "undefined"
+                ? globalOptions.strict
+                : false;
+        const sseOptions = Object.assign(Object.assign({}, globalOptions.sse), options === null || options === void 0 ? void 0 : options.sse);
+        const responseJsonSchema = z.toJSONSchema(schema.Reply, {
+            reused: "inline",
+            target: "draft-7",
+        })["properties"];
+        const responseSSESchema = responseJsonSchema["SSE"];
+        if (!responseJsonSchema || responseSSESchema === undefined) {
+            throw new Error("An SSE endpoint must define a schema for the 200 status code.");
+        }
+        delete responseJsonSchema["SSE"];
+        const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && {
+            body: z.toJSONSchema(strictifySchema(schema.Body, parseStrict("body", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Params && {
+            params: z.toJSONSchema(strictifySchema(schema.Params, parseStrict("params", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Query && {
+            querystring: z.toJSONSchema(strictifySchema(schema.Query, parseStrict("query", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), (schema.Headers && {
+            headers: z.toJSONSchema(strictifySchema(schema.Headers, parseStrict("headers", strict)), {
+                reused: "inline",
+                target: "draft-7",
+                io: "input",
+            }),
+        })), { response: Object.assign(Object.assign({}, responseJsonSchema), { 200: {
+                    content: {
+                        "text/event-stream": {
+                            schema: responseSSESchema,
+                        },
+                    },
+                } }) }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
+        return {
+            schema: finalResult,
+            handler,
+            preHandler: async (request, reply) => {
+                var _a, _b, _c;
+                const results = await Promise.all([
+                    ...(schema.Body ? [parse(schema.Body, request.body, "body")] : []),
+                    ...(schema.Params
+                        ? [parse(schema.Params, request.params, "params")]
+                        : []),
+                    ...(schema.Query
+                        ? [parse(schema.Query, request.query, "query")]
+                        : []),
+                ]);
+                for (const result of results) {
+                    if (!result.success) {
+                        return reply
+                            .code(400)
+                            .type("application/json")
+                            .send({
+                            message: mapZodError(result.error, result.tag),
+                        });
+                    }
+                }
+                request.body =
+                    ((_a = results.find((r) => r.tag === "body")) === null || _a === void 0 ? void 0 : _a.data) || {};
+                request.params =
+                    ((_b = results.find((r) => r.tag === "params")) === null || _b === void 0 ? void 0 : _b.data) || {};
+                request.query =
+                    ((_c = results.find((r) => r.tag === "query")) === null || _c === void 0 ? void 0 : _c.data) || {};
+                const abortController = new AbortController();
+                request.socket.on("close", () => abortController.abort());
+                request.abortController = abortController;
+                reply.sse = async (options) => sendSseStream({
+                    reply,
+                    stream: options.stream,
+                    schema: schema.Reply.shape["SSE"],
+                    options: sseOptions,
+                });
+            },
+        };
+    };
+}
+export const sseRouteV4 = createSSERouteV4({ strict: false });

package/lib/esm/types.d.ts

@@ -1,6 +1,7 @@
-import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
+import { ContextConfigDefault, FastifyBaseLogger, FastifyInstance, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteShorthandOptions } from "fastify";
+import { ResolveFastifyReplyReturnType } from "fastify/types/type-provider.js";
 export type APIOptions<RouteInterface extends RouteGenericInterface = RouteGenericInterface> = RouteShorthandOptions<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, RouteInterface>;
-export type APIHandler<RouteInterface extends RouteGenericInterface = RouteGenericInterface> = RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, RouteInterface>;
+export type APIHandler<RouteInterface extends RouteGenericInterface = RouteGenericInterface, RequestAugmentation extends object = {}, ReplyAugmentation extends object = {}> = (this: FastifyInstance<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, FastifyBaseLogger, FastifyTypeProviderDefault>, request: FastifyRequest<RouteInterface, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, FastifySchema, FastifyTypeProviderDefault, ContextConfigDefault, FastifyBaseLogger> & RequestAugmentation, reply: FastifyReply<RouteInterface, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault> & ReplyAugmentation) => ResolveFastifyReplyReturnType<FastifyTypeProviderDefault, FastifySchema, RouteInterface>;
 export interface RouteTag {
 }
 export interface RouteSecurity {

package/lib/esm/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function isObject(item: any): any;
 export declare function mergeDeep<TResult extends object>(target: TResult, ...sources: any[]): TResult;
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/esm/utils.js

@@ -19,3 +19,6 @@ export function mergeDeep(target, ...sources) {
     }
     return mergeDeep(target, ...sources);
 }
+export async function sleep(ms) {
+    return new Promise((resolve) => { setTimeout(resolve, ms); });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efebia/fastify-zod-reply",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "license": "MIT",
   "dependencies": {
     "fastify": "^5.3.0",