@bram-dc/fastify-type-provider-zod 3.1.1 → 3.1.2

package/README.md

@@ -1,3 +1,6 @@
+## Please use the original package [fastify-type-provider-zod](https://www.npmjs.com/package/fastify-type-provider-zod)
+This repository is no longer maintained since all the changed have been merged into the original package.
+
 # Fastify Type Provider Zod
 
 [![NPM Version](https://img.shields.io/npm/v/@bram-dc/fastify-type-provider-zod.svg)](https://www.npmjs.com/package/@bram-dc/fastify-type-provider-zod)

package/dist/src/ResponseValidationError.d.ts

@@ -0,0 +1,10 @@
+import type { z, ZodIssue } from 'zod';
+export type ResponseValidationErrorDetails = {
+    error: ZodIssue[];
+    method: string;
+    url: string;
+};
+export declare class ResponseValidationError extends Error {
+    details: ResponseValidationErrorDetails;
+    constructor(validationResult: z.SafeParseReturnType<unknown, unknown>, method: string, url: string);
+}

package/dist/src/ResponseValidationError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseValidationError = void 0;
+class ResponseValidationError extends Error {
+    constructor(validationResult, method, url) {
+        super("Response doesn't match the schema");
+        this.name = 'ResponseValidationError';
+        this.details = {
+            error: validationResult.error?.issues ?? [],
+            method,
+            url,
+        };
+    }
+}
+exports.ResponseValidationError = ResponseValidationError;

package/dist/src/core.d.ts

@@ -0,0 +1,78 @@
+import type { FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, FastifySchema, FastifySchemaCompiler, FastifyTypeProvider, RawServerBase, RawServerDefault } from 'fastify';
+import type { FastifySerializerCompiler } from 'fastify/types/schema';
+import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import type { z } from 'zod';
+type FreeformRecord = Record<string, any>;
+export interface ZodTypeProvider extends FastifyTypeProvider {
+    validator: this['schema'] extends z.ZodTypeAny ? z.output<this['schema']> : unknown;
+    serializer: this['schema'] extends z.ZodTypeAny ? z.input<this['schema']> : unknown;
+}
+interface Schema extends FastifySchema {
+    hide?: boolean;
+}
+export declare const createJsonSchemaTransform: ({ skipList }: {
+    skipList: readonly string[];
+}) => ({ schema, url }: {
+    schema: Schema;
+    url: string;
+}) => {
+    schema: Schema;
+    url: string;
+} | {
+    schema: FreeformRecord;
+    url: string;
+};
+export declare const jsonSchemaTransform: ({ schema, url }: {
+    schema: Schema;
+    url: string;
+}) => {
+    schema: Schema;
+    url: string;
+} | {
+    schema: FreeformRecord;
+    url: string;
+};
+export declare const createJsonSchemaTransformObject: ({ schemas }: {
+    schemas: Record<string, z.ZodTypeAny>;
+}) => (input: {
+    swaggerObject: Partial<OpenAPIV2.Document>;
+} | {
+    openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>;
+}) => any;
+export declare const validatorCompiler: FastifySchemaCompiler<z.ZodTypeAny>;
+type ReplacerFunction = (this: any, key: string, value: any) => any;
+type ZodSerializerCompilerOptions = {
+    replacer?: ReplacerFunction;
+};
+export declare const createSerializerCompiler: (options?: ZodSerializerCompilerOptions) => FastifySerializerCompiler<z.ZodTypeAny | {
+    properties: z.ZodTypeAny;
+}>;
+export declare const serializerCompiler: FastifySerializerCompiler<z.ZodTypeAny | {
+    properties: z.ZodTypeAny;
+}>;
+/**
+ * FastifyPluginCallbackZod with Zod automatic type inference
+ *
+ * @example
+ * ```typescript
+ * import { FastifyPluginCallbackZod } from "fastify-type-provider-zod"
+ *
+ * const plugin: FastifyPluginCallbackZod = (fastify, options, done) => {
+ *   done()
+ * }
+ * ```
+ */
+export type FastifyPluginCallbackZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginCallback<Options, Server, ZodTypeProvider>;
+/**
+ * FastifyPluginAsyncZod with Zod automatic type inference
+ *
+ * @example
+ * ```typescript
+ * import { FastifyPluginAsyncZod } from "fastify-type-provider-zod"
+ *
+ * const plugin: FastifyPluginAsyncZod = async (fastify, options) => {
+ * }
+ * ```
+ */
+export type FastifyPluginAsyncZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginAsync<Options, Server, ZodTypeProvider>;
+export {};

package/dist/src/core.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializerCompiler = exports.createSerializerCompiler = exports.validatorCompiler = exports.createJsonSchemaTransformObject = exports.jsonSchemaTransform = exports.createJsonSchemaTransform = void 0;
+const errors_1 = require("./errors");
+const ref_1 = require("./ref");
+const zod_to_json_1 = require("./zod-to-json");
+const defaultSkipList = [
+    '/documentation/',
+    '/documentation/initOAuth',
+    '/documentation/json',
+    '/documentation/uiConfig',
+    '/documentation/yaml',
+    '/documentation/*',
+    '/documentation/static/*',
+];
+const createJsonSchemaTransform = ({ skipList }) => {
+    return ({ schema, url }) => {
+        if (!schema) {
+            return {
+                schema,
+                url,
+            };
+        }
+        const { response, headers, querystring, body, params, hide, ...rest } = schema;
+        const transformed = {};
+        if (skipList.includes(url) || hide) {
+            transformed.hide = true;
+            return { schema: transformed, url };
+        }
+        const zodSchemas = { headers, querystring, body, params };
+        for (const prop in zodSchemas) {
+            const zodSchema = zodSchemas[prop];
+            if (zodSchema) {
+                transformed[prop] = (0, zod_to_json_1.convertZodToJsonSchema)(zodSchema);
+            }
+        }
+        if (response) {
+            transformed.response = {};
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const prop in response) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const schema = resolveSchema(response[prop]);
+                const transformedResponse = (0, zod_to_json_1.convertZodToJsonSchema)(schema);
+                transformed.response[prop] = transformedResponse;
+            }
+        }
+        for (const prop in rest) {
+            const meta = rest[prop];
+            if (meta) {
+                transformed[prop] = meta;
+            }
+        }
+        return { schema: transformed, url };
+    };
+};
+exports.createJsonSchemaTransform = createJsonSchemaTransform;
+exports.jsonSchemaTransform = (0, exports.createJsonSchemaTransform)({
+    skipList: defaultSkipList,
+});
+const createJsonSchemaTransformObject = ({ schemas }) => (input) => {
+    if ('swaggerObject' in input) {
+        console.warn('This package currently does not support component references for Swagger 2.0');
+        return input.swaggerObject;
+    }
+    return (0, ref_1.resolveRefs)(input.openapiObject, schemas);
+};
+exports.createJsonSchemaTransformObject = createJsonSchemaTransformObject;
+const validatorCompiler = ({ schema, method, url }) => (data) => {
+    const result = schema.safeParse(data);
+    if (result.error) {
+        return { error: (0, errors_1.createValidationError)(result.error, method, url) };
+    }
+    return { value: result.data };
+};
+exports.validatorCompiler = validatorCompiler;
+function resolveSchema(maybeSchema) {
+    if ('safeParse' in maybeSchema) {
+        return maybeSchema;
+    }
+    if ('properties' in maybeSchema) {
+        return maybeSchema.properties;
+    }
+    throw new errors_1.InvalidSchemaError(JSON.stringify(maybeSchema));
+}
+const createSerializerCompiler = (options) => ({ schema: maybeSchema, method, url }) => (data) => {
+    const schema = resolveSchema(maybeSchema);
+    const result = schema.safeParse(data);
+    if (result.error) {
+        throw new errors_1.ResponseSerializationError(result.error, method, url);
+    }
+    return JSON.stringify(result.data, options?.replacer);
+};
+exports.createSerializerCompiler = createSerializerCompiler;
+exports.serializerCompiler = (0, exports.createSerializerCompiler)({});

package/dist/src/errors.d.ts

@@ -0,0 +1,18 @@
+import type { FastifySchemaValidationError } from 'fastify/types/schema';
+import type { ZodError } from 'zod';
+declare const ResponseSerializationError_base: import("@fastify/error").FastifyErrorConstructor<{
+    code: string;
+}, [{
+    cause: ZodError;
+}]>;
+export declare class ResponseSerializationError extends ResponseSerializationError_base {
+    cause: ZodError;
+    method: string;
+    url: string;
+    constructor(cause: ZodError, method: string, url: string);
+}
+export declare const InvalidSchemaError: import("@fastify/error").FastifyErrorConstructor<{
+    code: string;
+}, [string]>;
+export declare const createValidationError: (error: ZodError, method: string, url: string) => FastifySchemaValidationError[];
+export {};

package/dist/src/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationError = exports.InvalidSchemaError = exports.ResponseSerializationError = void 0;
+const error_1 = __importDefault(require("@fastify/error"));
+class ResponseSerializationError extends (0, error_1.default)('FST_ERR_RESPONSE_SERIALIZATION', "Response doesn't match the schema", 500) {
+    constructor(cause, method, url) {
+        super({ cause });
+        this.cause = cause;
+        this.method = method;
+        this.url = url;
+    }
+}
+exports.ResponseSerializationError = ResponseSerializationError;
+exports.InvalidSchemaError = (0, error_1.default)('FST_ERR_INVALID_SCHEMA', 'Invalid schema passed: %s', 500);
+const createValidationError = (error, method, url) => error.errors.map((issue) => ({
+    keyword: issue.code,
+    instancePath: `/${issue.path.join('/')}`,
+    schemaPath: `#/${issue.path.join('/')}/${issue.code}`,
+    params: {
+        issue,
+        zodError: error,
+        method,
+        url,
+    },
+    message: error.message,
+}));
+exports.createValidationError = createValidationError;

package/dist/src/ref.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import type { z } from 'zod';
+export declare const resolveRefs: (openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>, zodSchemas: Record<string, z.ZodTypeAny>) => any;

package/dist/src/ref.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRefs = void 0;
+const zod_to_json_1 = require("./zod-to-json");
+const createComponentMap = (schemas) => {
+    const map = new Map();
+    Object.entries(schemas).forEach(([key, value]) => map.set(JSON.stringify(value), key));
+    return map;
+};
+const createComponentReplacer = (componentMapVK, schemasObject) => 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function componentReplacer(key, value) {
+    if (typeof value !== 'object')
+        return value;
+    // Check if the parent is the schemas object, if so, return the value as is. This is where the schemas are defined.
+    if (this === schemasObject)
+        return value;
+    const stringifiedValue = JSON.stringify(value);
+    if (componentMapVK.has(stringifiedValue))
+        return { $ref: `#/components/schemas/${componentMapVK.get(stringifiedValue)}` };
+    if (value.nullable === true) {
+        const nonNullableValue = { ...value };
+        delete nonNullableValue.nullable;
+        const stringifiedNonNullableValue = JSON.stringify(nonNullableValue);
+        if (componentMapVK.has(stringifiedNonNullableValue))
+            return {
+                anyOf: [
+                    { $ref: `#/components/schemas/${componentMapVK.get(stringifiedNonNullableValue)}` },
+                ],
+                nullable: true,
+            };
+    }
+    return value;
+};
+const resolveRefs = (openapiObject, zodSchemas) => {
+    const schemas = {};
+    for (const key in zodSchemas) {
+        schemas[key] = (0, zod_to_json_1.convertZodToJsonSchema)(zodSchemas[key]);
+    }
+    const document = {
+        ...openapiObject,
+        components: {
+            ...openapiObject.components,
+            schemas: {
+                ...openapiObject.components?.schemas,
+                ...schemas,
+            },
+        },
+    };
+    const componentMapVK = createComponentMap(schemas);
+    const componentReplacer = createComponentReplacer(componentMapVK, document.components.schemas);
+    // Using the componentReplacer function we deep check if the document has any schemas that are the same as the zod schemas provided
+    // When a match is found replace them with a $ref.
+    return JSON.parse(JSON.stringify(document, componentReplacer));
+};
+exports.resolveRefs = resolveRefs;

package/dist/src/zod-to-json.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+export declare const convertZodToJsonSchema: (zodSchema: z.ZodTypeAny) => object & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: object;
+    };
+};

package/dist/src/zod-to-json.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertZodToJsonSchema = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const zodToJsonSchemaOptions = {
+    target: 'openApi3',
+    $refStrategy: 'none',
+};
+const convertZodToJsonSchema = (zodSchema) => {
+    return (0, zod_to_json_schema_1.zodToJsonSchema)(zodSchema, zodToJsonSchemaOptions);
+};
+exports.convertZodToJsonSchema = convertZodToJsonSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bram-dc/fastify-type-provider-zod",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Zod Type Provider for Fastify@5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",