@efebia/fastify-zod-reply 0.0.1 → 0.0.2

package/lib/{index.js → cjs/index.js}

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (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 reply_js_1 = require("./reply.js");
+const utils_js_1 = require("./utils.js");
 const defaultOptions = {
     statusCodes: {
         ok: { statusCode: 200, payload: { message: 'ok' } },
@@ -22,9 +22,9 @@ const defaultOptions = {
     }
 };
 exports.default = (0, fastify_plugin_1.default)(async (fastify, opts) => {
-    const finalOptions = (0, utils_1.mergeDeep)(defaultOptions, opts);
+    const finalOptions = (0, utils_js_1.mergeDeep)(defaultOptions, opts);
     Object.entries(finalOptions.statusCodes).forEach(([key, value]) => {
-        fastify.decorateReply(key, (0, reply_1.createReply)(value.statusCode, value.payload));
+        fastify.decorateReply(key, (0, reply_js_1.createReply)(value.statusCode, value.payload));
     });
 }, {
     fastify: "4.x",

package/lib/{reply.d.ts → cjs/reply.d.ts}

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

package/lib/{reply.js → cjs/reply.js}

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

package/lib/esm/error.d.ts

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

package/lib/esm/error.js

@@ -0,0 +1,6 @@
+export class FastifyZodReplyError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode !== null && statusCode !== void 0 ? statusCode : -1;
+    }
+}

package/lib/esm/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/esm/index.js

@@ -0,0 +1,27 @@
+import fp from "fastify-plugin";
+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: { 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' } },
+    }
+};
+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: "4.x",
+    name: '@efebia/fastify-zod-reply'
+});

package/lib/esm/reply.d.ts

@@ -0,0 +1,8 @@
+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/esm/reply.js

@@ -0,0 +1,19 @@
+import { FastifyZodReplyError } from "./error.js";
+export const createReply = (statusCode, defaultPayload) => {
+    return function (payload) {
+        const finalPayload = payload !== null && payload !== void 0 ? payload : defaultPayload;
+        if (typeof finalPayload === 'string')
+            throw createError(statusCode)(finalPayload);
+        this.type("application/json");
+        this.code(statusCode);
+        return finalPayload;
+    };
+};
+export const createError = (statusCode) => (message) => {
+    const customError = new FastifyZodReplyError("", statusCode);
+    if (typeof message === "string")
+        customError.message = message;
+    else
+        customError.message = message.message;
+    return customError;
+};

package/lib/esm/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/esm/route.js

@@ -0,0 +1,63 @@
+import { zodToJsonSchema } from '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];
+    });
+};
+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(), {
+            $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'),
+            });
+        },
+    };
+};

package/lib/esm/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/esm/utils.js

@@ -0,0 +1,21 @@
+export function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+export 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

@@ -1,8 +1,9 @@
 {
   "name": "@efebia/fastify-zod-reply",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "dependencies": {
+    "fastify": "^4.29.0",
     "fastify-plugin": "^4.5.1",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.5"
@@ -11,11 +12,20 @@
     "/lib"
   ],
   "scripts": {
-    "build": "tsc"
+    "build:esm": "tsc --module nodenext --moduleResolution nodenext --outDir lib/esm",
+    "build:cjs": "tsc --module commonjs --moduleResolution node --outDir lib/cjs",
+    "build": "yarn build:esm && yarn build:cjs"
   },
-  "main": "./lib",
+  "main": "./lib/esm/index.js",
+  "types": "./lib/esm/index.d.ts",
+  "type": "module",
   "devDependencies": {
-    "fastify": "^4.29.0",
     "typescript": "^5.8.3"
+  },
+  "exports": {
+    ".": {
+      "require": "./lib/cjs/index.js",
+      "import": "./lib/esm/index.js"
+    }
   }
 }