@efebia/fastify-zod-reply 1.3.0 → 1.4.1

package/lib/cjs/error.d.ts

@@ -2,3 +2,72 @@ export declare class FastifyZodReplyError extends Error {
     statusCode: number;
     constructor(message?: string, statusCode?: number);
 }
+export declare const createError: (statusCode: number) => (message: string | {
+    message: string;
+}) => FastifyZodReplyError;
+type FastifyZodReplyErrorObjectItem = {
+    statusCode: number;
+    payload: string | {
+        message: string;
+    };
+};
+declare const DEFAULT_OBJECT: {
+    readonly badRequest: {
+        readonly statusCode: 400;
+        readonly payload: {
+            readonly message: "badRequest";
+        };
+    };
+    readonly unauthorized: {
+        readonly statusCode: 401;
+        readonly payload: {
+            readonly message: "unauthorized";
+        };
+    };
+    readonly forbidden: {
+        readonly statusCode: 403;
+        readonly payload: {
+            readonly message: "forbidden";
+        };
+    };
+    readonly notFound: {
+        readonly statusCode: 404;
+        readonly payload: {
+            readonly message: "notFound";
+        };
+    };
+    readonly notAcceptable: {
+        readonly statusCode: 406;
+        readonly payload: {
+            readonly message: "notAcceptable";
+        };
+    };
+    readonly conflict: {
+        readonly statusCode: 409;
+        readonly payload: {
+            readonly message: "conflict";
+        };
+    };
+    readonly internalServerError: {
+        readonly statusCode: 500;
+        readonly payload: {
+            readonly message: "internalServerError";
+        };
+    };
+};
+type ReverseFastifyZodReplyErrorObjectItem<TOverrides extends Record<string, FastifyZodReplyErrorObjectItem>> = {
+    [key in keyof TOverrides as TOverrides[key]['statusCode']]: {
+        label: key;
+        payload: TOverrides[key]['payload'];
+    };
+};
+type Deduplicate<TOverrides extends Record<string, FastifyZodReplyErrorObjectItem>> = {
+    [key in keyof typeof DEFAULT_OBJECT as typeof DEFAULT_OBJECT[key]['statusCode'] extends keyof ReverseFastifyZodReplyErrorObjectItem<TOverrides> ? never : key]: typeof DEFAULT_OBJECT[key];
+} & TOverrides;
+type FastifyZodReplyErrorObject<TOverrides extends Record<string, FastifyZodReplyErrorObjectItem>> = {
+    [key in keyof Deduplicate<TOverrides>]: (arg?: string | {
+        message: string;
+    }) => FastifyZodReplyError;
+};
+export declare const buildHTTPErrorObject: <const TRecord extends Record<string, FastifyZodReplyErrorObjectItem>>(overrides?: TRecord) => FastifyZodReplyErrorObject<TRecord>;
+export {};

package/lib/cjs/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FastifyZodReplyError = void 0;
+exports.buildHTTPErrorObject = exports.createError = exports.FastifyZodReplyError = void 0;
 class FastifyZodReplyError extends Error {
     constructor(message, statusCode) {
         super(message);
@@ -8,3 +8,39 @@ class FastifyZodReplyError extends Error {
     }
 }
 exports.FastifyZodReplyError = FastifyZodReplyError;
+const createError = (statusCode) => (message) => {
+    const customError = new FastifyZodReplyError("", statusCode);
+    if (typeof message === "string")
+        customError.message = message;
+    else
+        customError.message = message.message;
+    return customError;
+};
+exports.createError = createError;
+const DEFAULT_OBJECT = {
+    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" },
+    },
+};
+const buildHTTPErrorObject = (overrides) => {
+    return Object.fromEntries([...Object.entries(overrides !== null && overrides !== void 0 ? overrides : {})
+            .concat(Object.entries(DEFAULT_OBJECT))
+            .reduce((acc, [label, value]) => {
+            if (acc.get(value.statusCode))
+                return acc;
+            acc.set(value.statusCode, { label, obj: value });
+            return acc;
+        }, new Map())
+            .entries()].map(([statusCode, value]) => {
+        const baseErrorFn = (0, exports.createError)(statusCode);
+        return [value.label, (arg) => baseErrorFn(arg !== null && arg !== void 0 ? arg : value.obj.payload)];
+    }));
+};
+exports.buildHTTPErrorObject = buildHTTPErrorObject;

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 { buildHTTPErrorObject, FastifyZodReplyError } from "./error.js";
+export * from "./routeV4.js";
+export * from "./sseRouteV4.js";
+export * from "./types.js";

package/lib/cjs/index.js

@@ -17,33 +17,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyZodReplyError = exports.buildHTTPErrorObject = void 0;
 const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 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);
+var error_js_1 = require("./error.js");
+Object.defineProperty(exports, "buildHTTPErrorObject", { enumerable: true, get: function () { return error_js_1.buildHTTPErrorObject; } });
+Object.defineProperty(exports, "FastifyZodReplyError", { enumerable: true, get: function () { return error_js_1.FastifyZodReplyError; } });
 __exportStar(require("./routeV4.js"), exports);
+__exportStar(require("./sseRouteV4.js"), exports);
 __exportStar(require("./types.js"), exports);

package/lib/cjs/reply.d.ts

@@ -1,8 +1,4 @@
 import { FastifyReply } from "fastify";
-import { FastifyZodReplyError } from "./error.js";
 type ReplyFunction<T> = T extends (...args: any[]) => any ? (this: FastifyReply, ...args: Parameters<T>) => ReturnType<T> : never;
 export declare const createReply: (statusCode: number, defaultPayload: object) => ReplyFunction<any>;
-export declare const createError: (statusCode: number) => (message: string | {
-    message: string;
-}) => FastifyZodReplyError;
 export {};

package/lib/cjs/reply.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createError = exports.createReply = void 0;
+exports.createReply = void 0;
 const error_js_1 = require("./error.js");
 const createReply = (statusCode, defaultPayload) => {
     return function (payload) {
         const finalPayload = payload !== null && payload !== void 0 ? payload : defaultPayload;
         if (typeof finalPayload === 'string')
-            throw (0, exports.createError)(statusCode)(finalPayload);
+            throw (0, error_js_1.createError)(statusCode)(finalPayload);
         if (typeof finalPayload !== 'undefined')
             this.type("application/json");
         this.code(statusCode);
@@ -14,12 +14,3 @@ const createReply = (statusCode, defaultPayload) => {
     };
 };
 exports.createReply = createReply;
-const createError = (statusCode) => (message) => {
-    const customError = new error_js_1.FastifyZodReplyError("", statusCode);
-    if (typeof message === "string")
-        customError.message = message;
-    else
-        customError.message = message.message;
-    return customError;
-};
-exports.createError = createError;

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 {};