@efebia/fastify-zod-reply 1.0.1 → 1.0.3

package/lib/cjs/index.d.ts

@@ -17,7 +17,7 @@ export interface FastifyStatusCode {
 }
 export type FastifyReplyPluginOptions = {
     statusCodes?: {
-        [key in keyof FastifyStatusCode]: FastifyStatusCode[key];
+        [key in keyof FastifyStatusCode]?: FastifyStatusCode[key];
     };
 };
 export type DecoratedReply = {
@@ -31,3 +31,5 @@ declare const _default: import("fastify").FastifyPluginCallback<FastifyReplyPlug
 export default _default;
 export * from './error.js';
 export * from './route.js';
+export * from './routeV4.js';
+export * from './types.js';

package/lib/cjs/index.js

@@ -46,3 +46,5 @@ exports.default = (0, fastify_plugin_1.default)(async (fastify, opts) => {
 });
 __exportStar(require("./error.js"), exports);
 __exportStar(require("./route.js"), exports);
+__exportStar(require("./routeV4.js"), exports);
+__exportStar(require("./types.js"), exports);

package/lib/cjs/route.d.ts

@@ -1,11 +1,5 @@
-import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
 import { z } from 'zod';
-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 interface RouteTag {
-}
-export interface RouteSecurity {
-}
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from './types.js';
 export type BaseZodSchema = {
     Body?: z.ZodTypeAny;
     Params?: z.ZodTypeAny;

package/lib/cjs/route.js

@@ -20,7 +20,7 @@ const findStatusCode = (statusCode, availableStatusCodes) => {
     });
 };
 const route = (schema, handler) => {
-    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Body) })), (schema.Params && { params: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Params) })), (schema.Query && { querystring: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Query) })), (schema.Headers && { headers: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Headers) })), { response: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Reply.partial(), {
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Body, { $refStrategy: 'none' }) })), (schema.Params && { params: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Params, { $refStrategy: 'none' }) })), (schema.Query && { querystring: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Query, { $refStrategy: 'none' }) })), (schema.Headers && { headers: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Headers, { $refStrategy: 'none' }) })), { response: (0, zod_to_json_schema_1.zodToJsonSchema)(schema.Reply.partial(), {
             $refStrategy: 'none',
             strictUnions: true,
         })['properties'] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
@@ -58,9 +58,7 @@ const route = (schema, handler) => {
             if (serialized.success) {
                 return done(null, serialized.data);
             }
-            return done(null, {
-                message: mapZodError(serialized.error, 'reply'),
-            });
+            return done(new Error(mapZodError(serialized.error, 'reply')));
         },
     };
 };

package/lib/cjs/routeV4.d.ts

@@ -0,0 +1,20 @@
+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])[];
+    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;
+};
+export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};

package/lib/cjs/routeV4.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeV4 = void 0;
+const v4_1 = require("zod/v4");
+const mapZodError = (zodError, prefix) => zodError.issues.map(issue => `Error at ${prefix}->${issue.path.join('->')}`).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 routeV4 = (schema, handler) => {
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: v4_1.z.toJSONSchema(schema.Body, { reused: 'inline' }) })), (schema.Params && { params: v4_1.z.toJSONSchema(schema.Params, { reused: 'inline' }) })), (schema.Query && { querystring: v4_1.z.toJSONSchema(schema.Query, { reused: 'inline' }) })), (schema.Headers && { headers: v4_1.z.toJSONSchema(schema.Headers, { reused: 'inline' }) })), { response: v4_1.z.toJSONSchema(schema.Reply.partial(), { reused: 'inline' })['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')] : []),
+            ]);
+            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) || {};
+        },
+        preSerialization: (request, reply, payload, done) => {
+            const foundSchema = findStatusCode(reply.statusCode, Object.entries(schema.Reply.shape));
+            if (!foundSchema) {
+                request.log.warn(`[@efebia/fastify-zod-reply]: Reply schema of: ${request.routeOptions.url} does not have the specified status code: ${reply.statusCode}`);
+                return done(null, payload);
+            }
+            const serialized = foundSchema[1].safeParse(payload);
+            if (serialized.success) {
+                return done(null, serialized.data);
+            }
+            return done(new Error(mapZodError(serialized.error, 'reply')));
+        },
+    };
+};
+exports.routeV4 = routeV4;

package/lib/cjs/types.d.ts

@@ -0,0 +1,7 @@
+import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
+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 interface RouteTag {
+}
+export interface RouteSecurity {
+}

package/lib/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/index.d.ts

@@ -17,7 +17,7 @@ export interface FastifyStatusCode {
 }
 export type FastifyReplyPluginOptions = {
     statusCodes?: {
-        [key in keyof FastifyStatusCode]: FastifyStatusCode[key];
+        [key in keyof FastifyStatusCode]?: FastifyStatusCode[key];
     };
 };
 export type DecoratedReply = {
@@ -31,3 +31,5 @@ declare const _default: import("fastify").FastifyPluginCallback<FastifyReplyPlug
 export default _default;
 export * from './error.js';
 export * from './route.js';
+export * from './routeV4.js';
+export * from './types.js';

package/lib/esm/index.js

@@ -27,3 +27,5 @@ export default fp(async (fastify, opts) => {
 });
 export * from './error.js';
 export * from './route.js';
+export * from './routeV4.js';
+export * from './types.js';

package/lib/esm/route.d.ts

@@ -1,11 +1,5 @@
-import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
 import { z } from 'zod';
-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 interface RouteTag {
-}
-export interface RouteSecurity {
-}
+import { APIHandler, APIOptions, RouteSecurity, RouteTag } from './types.js';
 export type BaseZodSchema = {
     Body?: z.ZodTypeAny;
     Params?: z.ZodTypeAny;

package/lib/esm/route.js

@@ -17,7 +17,7 @@ const findStatusCode = (statusCode, availableStatusCodes) => {
     });
 };
 export const route = (schema, handler) => {
-    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: zodToJsonSchema(schema.Body) })), (schema.Params && { params: zodToJsonSchema(schema.Params) })), (schema.Query && { querystring: zodToJsonSchema(schema.Query) })), (schema.Headers && { headers: zodToJsonSchema(schema.Headers) })), { response: zodToJsonSchema(schema.Reply.partial(), {
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: zodToJsonSchema(schema.Body, { $refStrategy: 'none' }) })), (schema.Params && { params: zodToJsonSchema(schema.Params, { $refStrategy: 'none' }) })), (schema.Query && { querystring: zodToJsonSchema(schema.Query, { $refStrategy: 'none' }) })), (schema.Headers && { headers: zodToJsonSchema(schema.Headers, { $refStrategy: 'none' }) })), { response: zodToJsonSchema(schema.Reply.partial(), {
             $refStrategy: 'none',
             strictUnions: true,
         })['properties'] }), (schema.Security && { security: schema.Security })), (schema.Tags && { tags: schema.Tags }));
@@ -55,9 +55,7 @@ export const route = (schema, handler) => {
             if (serialized.success) {
                 return done(null, serialized.data);
             }
-            return done(null, {
-                message: mapZodError(serialized.error, 'reply'),
-            });
+            return done(new Error(mapZodError(serialized.error, 'reply')));
         },
     };
 };

package/lib/esm/routeV4.d.ts

@@ -0,0 +1,20 @@
+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])[];
+    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;
+};
+export declare const routeV4: <TSchema extends BaseZodV4Schema, FastifySchema extends FastifyZodV4Schema<TSchema> = FastifyZodV4Schema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};

package/lib/esm/routeV4.js

@@ -0,0 +1,58 @@
+import { z } from 'zod/v4';
+const mapZodError = (zodError, prefix) => zodError.issues.map(issue => `Error at ${prefix}->${issue.path.join('->')}`).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];
+    });
+};
+export const routeV4 = (schema, handler) => {
+    const finalResult = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (schema.Body && { body: z.toJSONSchema(schema.Body, { reused: 'inline' }) })), (schema.Params && { params: z.toJSONSchema(schema.Params, { reused: 'inline' }) })), (schema.Query && { querystring: z.toJSONSchema(schema.Query, { reused: 'inline' }) })), (schema.Headers && { headers: z.toJSONSchema(schema.Headers, { reused: 'inline' }) })), { response: z.toJSONSchema(schema.Reply.partial(), { reused: 'inline' })['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')] : []),
+            ]);
+            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) || {};
+        },
+        preSerialization: (request, reply, payload, done) => {
+            const foundSchema = findStatusCode(reply.statusCode, Object.entries(schema.Reply.shape));
+            if (!foundSchema) {
+                request.log.warn(`[@efebia/fastify-zod-reply]: Reply schema of: ${request.routeOptions.url} does not have the specified status code: ${reply.statusCode}`);
+                return done(null, payload);
+            }
+            const serialized = foundSchema[1].safeParse(payload);
+            if (serialized.success) {
+                return done(null, serialized.data);
+            }
+            return done(new Error(mapZodError(serialized.error, 'reply')));
+        },
+    };
+};

package/lib/esm/types.d.ts

@@ -0,0 +1,7 @@
+import { type RawReplyDefaultExpression, type RawRequestDefaultExpression, type RawServerDefault, type RouteGenericInterface, type RouteHandlerMethod, type RouteShorthandOptions } from 'fastify';
+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 interface RouteTag {
+}
+export interface RouteSecurity {
+}

package/lib/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@efebia/fastify-zod-reply",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "license": "MIT",
   "dependencies": {
     "fastify": "^5.3.0",
     "fastify-plugin": "^5.0.1",
-    "zod": "^3.24.2",
+    "zod": "^3.25.47",
     "zod-to-json-schema": "^3.24.5"
   },
   "files": [