fastify-type-provider-zod/dist/esm/core.js

Zod Type Provider for Fastify@5

import { z } from "zod/v4";
import { InvalidSchemaError, ResponseSerializationError, createValidationError } from "./errors.js";
import { zodSchemaToJson, zodRegistryToJson } from "./zod-to-json.js";
const defaultSkipList = [
  "/documentation/",
  "/documentation/initOAuth",
  "/documentation/json",
  "/documentation/uiConfig",
  "/documentation/yaml",
  "/documentation/*",
  "/documentation/static/*"
];
const createJsonSchemaTransform = ({
  skipList = defaultSkipList,
  schemaRegistry = z.globalRegistry
}) => {
  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] = zodSchemaToJson(zodSchema, schemaRegistry, "input");
      }
    }
    if (response) {
      transformed.response = {};
      for (const prop in response) {
        const zodSchema = resolveSchema(response[prop]);
        transformed.response[prop] = zodSchemaToJson(zodSchema, schemaRegistry, "output");
      }
    }
    for (const prop in rest) {
      const meta = rest[prop];
      if (meta) {
        transformed[prop] = meta;
      }
    }
    return { schema: transformed, url };
  };
};
const jsonSchemaTransform = createJsonSchemaTransform({});
const createJsonSchemaTransformObject = ({
  schemaRegistry = z.globalRegistry
}) => (input) => {
  var _a;
  if ("swaggerObject" in input) {
    console.warn("This package currently does not support component references for Swagger 2.0");
    return input.swaggerObject;
  }
  const inputSchemas = zodRegistryToJson(schemaRegistry, "input");
  const outputSchemas = zodRegistryToJson(schemaRegistry, "output");
  for (const key in outputSchemas) {
    if (inputSchemas[key]) {
      throw new Error(
        `Collision detected for schema "${key}". The is already an input schema with the same name.`
      );
    }
  }
  return {
    ...input.openapiObject,
    components: {
      ...input.openapiObject.components,
      schemas: {
        ...(_a = input.openapiObject.components) == null ? void 0 : _a.schemas,
        ...inputSchemas,
        ...outputSchemas
      }
    }
  };
};
const jsonSchemaTransformObject = createJsonSchemaTransformObject({});
const validatorCompiler = ({ schema }) => (data) => {
  const result = schema.safeParse(data);
  if (result.error) {
    return { error: createValidationError(result.error) };
  }
  return { value: result.data };
};
function resolveSchema(maybeSchema) {
  if ("safeParse" in maybeSchema) {
    return maybeSchema;
  }
  if ("properties" in maybeSchema) {
    return maybeSchema.properties;
  }
  throw new 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 ResponseSerializationError(method, url, { cause: result.error });
  }
  return JSON.stringify(result.data, options == null ? void 0 : options.replacer);
};
const serializerCompiler = createSerializerCompiler({});
export {
  createJsonSchemaTransform,
  createJsonSchemaTransformObject,
  createSerializerCompiler,
  jsonSchemaTransform,
  jsonSchemaTransformObject,
  serializerCompiler,
  validatorCompiler
};
//# sourceMappingURL=core.js.map