@efebia/fastify-zod-reply 0.0.1

package/lib/error.d.ts

@@ -0,0 +1,4 @@
+export declare class FastifyZodReplyError extends Error {
+    statusCode: number;
+    constructor(message?: string, statusCode?: number);
+}

package/lib/error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyZodReplyError = void 0;
+class FastifyZodReplyError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode !== null && statusCode !== void 0 ? statusCode : -1;
+    }
+}
+exports.FastifyZodReplyError = FastifyZodReplyError;

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+export type StatusCode<TCode> = {
+    statusCode: TCode;
+    payload: any;
+};
+export interface FastifyStatusCode {
+    ok: StatusCode<200>;
+    created: StatusCode<201>;
+    accepted: StatusCode<202>;
+    noContent: StatusCode<204>;
+    badRequest: StatusCode<400>;
+    unauthorized: StatusCode<401>;
+    forbidden: StatusCode<403>;
+    notFound: StatusCode<404>;
+    notAcceptable: StatusCode<406>;
+    conflict: StatusCode<409>;
+    internalServerError: StatusCode<500>;
+}
+export type FastifyReplyPluginOptions = {
+    statusCodes?: {
+        [key in keyof FastifyStatusCode]: FastifyStatusCode[key];
+    };
+};
+export type DecoratedReply = {
+    [key in keyof FastifyStatusCode]: <T>(val?: T) => T;
+};
+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;

package/lib/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const reply_1 = require("./reply");
+const utils_1 = require("./utils");
+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: { message: 'noContent' } },
+        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_1.mergeDeep)(defaultOptions, opts);
+    Object.entries(finalOptions.statusCodes).forEach(([key, value]) => {
+        fastify.decorateReply(key, (0, reply_1.createReply)(value.statusCode, value.payload));
+    });
+}, {
+    fastify: "4.x",
+    name: '@efebia/fastify-zod-reply'
+});

package/lib/reply.d.ts

@@ -0,0 +1,8 @@
+import { FastifyReply } from "fastify";
+import { FastifyZodReplyError } from "./error";
+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/reply.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createError = exports.createReply = void 0;
+const error_1 = require("./error");
+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);
+        this.type("application/json");
+        this.code(statusCode);
+        return finalPayload;
+    };
+};
+exports.createReply = createReply;
+const createError = (statusCode) => (message) => {
+    const customError = new error_1.FastifyZodReplyError("", statusCode);
+    if (typeof message === "string")
+        customError.message = message;
+    else
+        customError.message = message.message;
+    return customError;
+};
+exports.createError = createError;

package/lib/route.d.ts

@@ -0,0 +1,26 @@
+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 {
+}
+export type BaseZodSchema = {
+    Body?: z.ZodTypeAny;
+    Params?: z.ZodTypeAny;
+    Query?: z.ZodTypeAny;
+    Headers?: z.ZodTypeAny;
+    Reply: z.AnyZodObject;
+    Security?: (RouteSecurity[keyof RouteSecurity])[];
+    Tags?: (keyof RouteTag)[];
+};
+export type FastifyZodSchema<TZodSchema extends BaseZodSchema> = {
+    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.infer<TZodSchema['Reply']>] : undefined;
+};
+export declare const route: <TSchema extends BaseZodSchema, FastifySchema extends FastifyZodSchema<TSchema> = FastifyZodSchema<TSchema>>(schema: TSchema, handler: APIHandler<FastifySchema>) => APIOptions<FastifySchema> & {
+    handler: APIHandler<FastifySchema>;
+};

package/lib/route.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.route = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const mapZodError = (zodError, prefix) => zodError.errors.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 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(), {
+            $refStrategy: 'none',
+            strictUnions: true,
+        })['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(null, {
+                message: mapZodError(serialized.error, 'reply'),
+            });
+        },
+    };
+};
+exports.route = route;

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isObject(item: any): any;
+export declare function mergeDeep<TResult extends object>(target: TResult, ...sources: any[]): TResult;

package/lib/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.mergeDeep = mergeDeep;
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+function mergeDeep(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@efebia/fastify-zod-reply",
+  "version": "0.0.1",
+  "license": "MIT",
+  "dependencies": {
+    "fastify-plugin": "^4.5.1",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "files": [
+    "/lib"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "main": "./lib",
+  "devDependencies": {
+    "fastify": "^4.29.0",
+    "typescript": "^5.8.3"
+  }
+}