Proprietary schemas using native zod methods and Metadata

src/common-helpers.ts

@@ -5,13 +5,13 @@ import { xprod } from "ramda";
 import { z } from "zod";
 import { CommonConfig, InputSource, InputSources } from "./config-type";
 import { InputValidationError, OutputValidationError } from "./errors";
-import { ZodFile } from "./file-schema";
 import { IOSchema } from "./io-schema";
 import { AbstractLogger } from "./logger";
-import { getMeta } from "./metadata";
+import { getMeta, isProprietary } from "./metadata";
 import { AuxMethod, Method } from "./method";
 import { mimeMultipart } from "./mime";
-import { ZodUpload } from "./upload-schema";
+import { ezRawKind } from "./raw-schema";
+import { ezUploadKind } from "./upload-schema";
 
 export type FlatObject = Record<string, unknown>;
 
@@ -237,13 +237,13 @@ export const hasNestedSchema = ({
 export const hasUpload = (subject: IOSchema) =>
   hasNestedSchema({
     subject,
-    condition: (schema) => schema instanceof ZodUpload,
+    condition: (schema) => isProprietary(schema, ezUploadKind),
   });
 
 export const hasRaw = (subject: IOSchema) =>
   hasNestedSchema({
     subject,
-    condition: (schema) => schema instanceof ZodFile,
+    condition: (schema) => isProprietary(schema, ezRawKind),
     maxDepth: 3,
   });
 

src/date-in-schema.ts

@@ -1,64 +1,15 @@
-import {
-  INVALID,
-  ParseInput,
-  ParseReturnType,
-  ZodIssueCode,
-  ZodParsedType,
-  ZodType,
-  ZodTypeDef,
-  addIssueToContext,
-} from "zod";
-import { isValidDate } from "./schema-helpers";
-
-// simple regex for ISO date, supports the following formats:
-// 2021-01-01T00:00:00.000Z
-// 2021-01-01T00:00:00.0Z
-// 2021-01-01T00:00:00Z
-// 2021-01-01T00:00:00
-// 2021-01-01
-export const isoDateRegex =
-  /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?)?Z?$/;
-
-const zodDateInKind = "ZodDateIn";
-
-export interface ZodDateInDef extends ZodTypeDef {
-  typeName: typeof zodDateInKind;
-}
-
-export class ZodDateIn extends ZodType<Date, ZodDateInDef, string> {
-  _parse(input: ParseInput): ParseReturnType<Date> {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.string) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.string,
-        received: ctx.parsedType,
-      });
-      return INVALID;
-    }
-
-    if (!isoDateRegex.test(ctx.data as string)) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_string,
-        validation: "regex",
-      });
-      status.dirty();
-    }
-
-    const date = new Date(ctx.data);
-
-    if (!isValidDate(date)) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_date,
-      });
-      return INVALID;
-    }
-
-    return { status: status.value, value: date };
-  }
-
-  static create = () =>
-    new ZodDateIn({
-      typeName: zodDateInKind,
-    });
-}
+import { z } from "zod";
+import { proprietary } from "./metadata";
+import { isValidDate, isoDateRegex } from "./schema-helpers";
+
+export const ezDateInKind = "DateIn";
+
+export const dateIn = () =>
+  proprietary(
+    ezDateInKind,
+    z
+      .string()
+      .regex(isoDateRegex)
+      .transform((str) => new Date(str))
+      .pipe(z.date().refine(isValidDate)),
+  );

src/date-out-schema.ts

@@ -1,45 +1,14 @@
-import {
-  INVALID,
-  ParseInput,
-  ParseReturnType,
-  ZodIssueCode,
-  ZodParsedType,
-  ZodType,
-  ZodTypeDef,
-  addIssueToContext,
-} from "zod";
+import { z } from "zod";
+import { proprietary } from "./metadata";
 import { isValidDate } from "./schema-helpers";
 
-const zodDateOutKind = "ZodDateOut";
+export const ezDateOutKind = "DateOut";
 
-export interface ZodDateOutDef extends ZodTypeDef {
-  typeName: typeof zodDateOutKind;
-}
-
-export class ZodDateOut extends ZodType<string, ZodDateOutDef, Date> {
-  _parse(input: ParseInput): ParseReturnType<string> {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.date) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.date,
-        received: ctx.parsedType,
-      });
-      return INVALID;
-    }
-
-    if (!isValidDate(ctx.data)) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_date,
-      });
-      return INVALID;
-    }
-
-    return { status: status.value, value: (ctx.data as Date).toISOString() };
-  }
-
-  static create = () =>
-    new ZodDateOut({
-      typeName: zodDateOutKind,
-    });
-}
+export const dateOut = () =>
+  proprietary(
+    ezDateOutKind,
+    z
+      .date()
+      .refine(isValidDate)
+      .transform((date) => date.toISOString()),
+  );

src/documentation-helpers.ts

@@ -22,18 +22,14 @@ import {
   FlatObject,
   getExamples,
   hasCoercion,
-  hasRaw,
   hasTopLevelTransformingEffect,
   isCustomHeader,
   makeCleanId,
   tryToTransform,
   ucFirst,
 } from "./common-helpers";
 import { InputSource, TagsConfig } from "./config-type";
-import { ZodDateIn, isoDateRegex } from "./date-in-schema";
-import { ZodDateOut } from "./date-out-schema";
 import { DocumentationError } from "./errors";
-import { ZodFile } from "./file-schema";
 import { IOSchema } from "./io-schema";
 import {
   LogicalContainer,
@@ -42,14 +38,15 @@ import {
 } from "./logical-container";
 import { copyMeta } from "./metadata";
 import { Method } from "./method";
+import { ez } from "./proprietary-schemas";
+import { isoDateRegex } from "./schema-helpers";
 import {
   HandlingRules,
   HandlingVariant,
   SchemaHandler,
   walkSchema,
 } from "./schema-walker";
 import { Security } from "./security";
-import { ZodUpload } from "./upload-schema";
 
 /* eslint-disable @typescript-eslint/no-use-before-define */
 
@@ -130,7 +127,7 @@ export const depictAny: Depicter<z.ZodAny> = () => ({
   format: "any",
 });
 
-export const depictUpload: Depicter<ZodUpload> = (ctx) => {
+export const depictUpload: Depicter<z.ZodType> = (ctx) => {
   assert(
     !ctx.isResponse,
     new DocumentationError({
@@ -144,11 +141,14 @@ export const depictUpload: Depicter<ZodUpload> = (ctx) => {
   };
 };
 
-export const depictFile: Depicter<ZodFile> = ({
-  schema: { isBinary, isBase64, isBuffer },
-}) => ({
+export const depictFile: Depicter<z.ZodType> = ({ schema }) => ({
   type: "string",
-  format: isBuffer || isBinary ? "binary" : isBase64 ? "byte" : "file",
+  format:
+    schema instanceof z.ZodString
+      ? schema._def.checks.find((check) => check.kind === "regex")
+        ? "byte"
+        : "file"
+      : "binary",
 });
 
 export const depictUnion: Depicter<z.ZodUnion<z.ZodUnionOptions>> = ({
@@ -245,7 +245,7 @@ export const depictObject: Depicter<z.AnyZodObject> = ({
  * */
 export const depictNull: Depicter<z.ZodNull> = () => ({ type: "null" });
 
-export const depictDateIn: Depicter<ZodDateIn> = (ctx) => {
+export const depictDateIn: Depicter<z.ZodType> = (ctx) => {
   assert(
     !ctx.isResponse,
     new DocumentationError({
@@ -264,7 +264,7 @@ export const depictDateIn: Depicter<ZodDateIn> = (ctx) => {
   };
 };
 
-export const depictDateOut: Depicter<ZodDateOut> = (ctx) => {
+export const depictDateOut: Depicter<z.ZodType> = (ctx) => {
   assert(
     ctx.isResponse,
     new DocumentationError({
@@ -587,6 +587,9 @@ export const depictLazy: Depicter<z.ZodLazy<z.ZodTypeAny>> = ({
   );
 };
 
+export const depictRaw: Depicter<z.ZodType> = ({ next }) =>
+  next({ schema: ez.file("buffer") });
+
 export const depictExamples = (
   schema: z.ZodTypeAny,
   isResponse: boolean,
@@ -744,8 +747,6 @@ export const depicters: HandlingRules<
   ZodNumber: depictNumber,
   ZodBigInt: depictBigInt,
   ZodBoolean: depictBoolean,
-  ZodDateIn: depictDateIn,
-  ZodDateOut: depictDateOut,
   ZodNull: depictNull,
   ZodArray: depictArray,
   ZodTuple: depictTuple,
@@ -754,8 +755,6 @@ export const depicters: HandlingRules<
   ZodLiteral: depictLiteral,
   ZodIntersection: depictIntersection,
   ZodUnion: depictUnion,
-  ZodFile: depictFile,
-  ZodUpload: depictUpload,
   ZodAny: depictAny,
   ZodDefault: depictDefault,
   ZodEnum: depictEnum,
@@ -770,6 +769,11 @@ export const depicters: HandlingRules<
   ZodPipeline: depictPipeline,
   ZodLazy: depictLazy,
   ZodReadonly: depictReadonly,
+  File: depictFile,
+  Upload: depictUpload,
+  DateOut: depictDateOut,
+  DateIn: depictDateIn,
+  Raw: depictRaw,
 };
 
 export const onEach: Depicter<z.ZodTypeAny, "each"> = ({
@@ -1048,7 +1052,7 @@ export const depictRequest = ({
   const bodyDepiction = excludeExamplesFromDepiction(
     excludeParamsFromDepiction(
       walkSchema({
-        schema: hasRaw(schema) ? ZodFile.create().buffer() : schema,
+        schema,
         isResponse: false,
         rules: depicters,
         onEach,