Zod 3.20 stability and refactor

packages/test-app/package.json

@@ -26,10 +26,10 @@
     "trpc-panel": "^1.0.0",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.1.0",
-    "zod": "^3.19.1"
+    "zod": "3.20.2"
   },
   "scripts": {
-    "dev": "SERVER_URL=\"http://localhost\" TRPC_PATH=\"trpc\" DEV_PORT=\"4000\" SIMULATE_DELAY=\"true\" nodemon ./src/server.ts",
+    "dev": "LIVE_RELOAD=\"true\" SERVER_URL=\"http://localhost\" TRPC_PATH=\"trpc\" DEV_PORT=\"4000\" SIMULATE_DELAY=\"true\" nodemon ./src/server.ts",
     "build": "npx tsc --project tsconfig.json",
     "start": "node ./lib/server"
   },

packages/trpc-panel/package.json

@@ -28,7 +28,6 @@
   },
   "peerDependencies": {
     "@trpc/server": "^10.0.0",
-    "react": "^18.2.0",
     "zod": "^3.19.1"
   },
   "devDependencies": {

packages/trpc-panel/rollup.config.js

@@ -48,9 +48,17 @@ export default [
             typescript(),
             replace({
                 "process.env.NODE_ENV": JSON.stringify("production"),
+                preventAssignment: false,
             }),
             babel({
-                presets: ["@babel/preset-react"],
+                presets: [
+                    [
+                        "@babel/preset-react",
+                        {
+                            development: isWatching,
+                        },
+                    ],
+                ],
             }),
             commonjs(),
             copy({
@@ -62,7 +70,6 @@ export default [
                 ],
             }),
             !isWatching && terser(),
-            visualizer(),
         ],
     },
 ];

packages/trpc-panel/src/index.ts

@@ -1,3 +1 @@
-export { parseNode as parseRouter } from "./parse/parse-router";
-export { mapZodObjectToNode as mapZodObject } from "./parse/input-mappers/zod";
 export { renderTrpcPanel as renderTrpcPanel } from "./render";

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodArrayDef.tsx

@@ -0,0 +1,13 @@
+import { ZodArrayDef } from "zod";
+import { ArrayNode, ParseFunction } from "../../../parsed-node-types";
+import { zodSelectorFunction } from "../selector";
+
+export const parseZodArrayDef: ParseFunction<ZodArrayDef, ArrayNode> = (def, refs) => {
+    const {type} = def
+    const childType = zodSelectorFunction(type._def, refs)
+    return {
+        type: "array",
+        childType,
+        ...refs
+    };
+}

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodBooleanFieldDef.ts

@@ -0,0 +1,6 @@
+import { ZodBooleanDef } from "zod";
+import { BooleanNode, ParseFunction } from "../../../parsed-node-types";
+
+export const parseZodBooleanFieldDef: ParseFunction<ZodBooleanDef, BooleanNode> = (_, ref)=>{
+    return { type: "boolean", ...ref };
+}

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodDiscriminatedUnionDef.ts

@@ -0,0 +1,67 @@
+import { AnyZodObject, ZodFirstPartyTypeKind } from "zod";
+import {
+    DiscriminatedUnionNode,
+    ParseFunction,
+} from "../../../parsed-node-types";
+import { zodSelectorFunction } from "../selector";
+
+type OptionsMap = Map<string, AnyZodObject>;
+
+type ZodDiscriminatedUnionThreePointTwenty = {
+    optionsMap: OptionsMap;
+    discriminator: string;
+};
+
+type ZodDiscriminatedUnionPreThreePointTwenty = {
+    options: OptionsMap;
+    discriminator: string;
+};
+
+export type ZodDiscriminatedUnionDefUnversioned =
+    | ZodDiscriminatedUnionPreThreePointTwenty
+    | ZodDiscriminatedUnionThreePointTwenty;
+
+function isZodThreePointTwenty(
+    def: ZodDiscriminatedUnionDefUnversioned
+): def is ZodDiscriminatedUnionThreePointTwenty {
+    return "optionsMap" in def;
+}
+
+function makeDefConsistent(def: ZodDiscriminatedUnionDefUnversioned): {
+    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+    discriminator: string;
+    options: Map<string, AnyZodObject>;
+} {
+    const optionsMap = isZodThreePointTwenty(def)
+        ? def.optionsMap
+        : def.options;
+    return {
+        typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+        discriminator: def.discriminator,
+        options: optionsMap,
+    };
+}
+
+export const parseZodDiscriminatedUnionDef: ParseFunction<
+    ZodDiscriminatedUnionDefUnversioned,
+    DiscriminatedUnionNode
+> = (def, refs) => {
+    const defConsistent = makeDefConsistent(def);
+    const entries = Array.from(defConsistent.options.entries());
+    const nodeEntries = entries.map(([discriminatorValue, zodObj]) => [
+        discriminatorValue,
+        zodSelectorFunction(zodObj._def, refs),
+    ]);
+    // Not sure why this is here but seems important
+    // if (nodeEntries.some((e) => e[1] === null)) return null;
+
+    const nodesMap = Object.fromEntries(nodeEntries);
+
+    return {
+        type: "discriminated-union",
+        discriminatedUnionValues: entries.map(([n]) => n),
+        discriminatedUnionChildrenMap: nodesMap,
+        discriminatorName: def.discriminator,
+        ...refs,
+    };
+};

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodEnumDef.ts

@@ -0,0 +1,10 @@
+import { ZodEnumDef } from "zod";
+import { EnumNode, ParseFunction } from "../../../parsed-node-types";
+
+export const parseZodEnumDef: ParseFunction<ZodEnumDef, EnumNode> = (
+    def,
+    refs
+) => {
+    const values = def.values as string[];
+    return { type: "enum", enumValues: values, ...refs };
+};

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodLiteralDef.tsx

@@ -0,0 +1,10 @@
+import { ZodLiteralDef } from "zod";
+import { LiteralNode, ParseFunction } from "../../../parsed-node-types";
+
+export const parseZodLiteralDef: ParseFunction<ZodLiteralDef, LiteralNode> = (def, refs)=>{
+    return {
+        type :'literal',
+        value: def.value,
+        ...refs,
+    }
+}

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodNumberDef.ts

@@ -0,0 +1,13 @@
+import { NumberNode, ParseFunction } from "../../../parsed-node-types";
+import { ZodNumberDef } from "zod";
+
+export const parseZodNumberDef: ParseFunction<ZodNumberDef, NumberNode> = (
+    _,
+    references
+) => {
+    return {
+        type: "number",
+        path: references.path,
+        optional: references.optional,
+    };
+};

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodObjectDef.ts

@@ -0,0 +1,29 @@
+import { ZodObjectDef } from "zod";
+import {
+    ObjectNode,
+    ParsedInputNode,
+    ParseFunction,
+    UnsupportedNode,
+} from "../../../parsed-node-types";
+import { zodSelectorFunction } from "../selector";
+
+export const parseZodObjectDef: ParseFunction<
+    ZodObjectDef,
+    ObjectNode | UnsupportedNode
+> = (def, refs) => {
+    const shape = def.shape();
+    const children: { [propertyName: string]: ParsedInputNode } = {};
+    for (var propertyName of Object.keys(shape)) {
+        const node = zodSelectorFunction(shape[propertyName]!._def, {
+            ...refs,
+            path: refs.path.concat([propertyName]),
+        });
+        children[propertyName] = node;
+    }
+    return {
+        type: "object",
+        children,
+        path: refs.path,
+        optional: refs.optional,
+    };
+};

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodOptionalDef.tsx

@@ -0,0 +1,12 @@
+import { ZodOptionalDef } from "zod";
+import { ParsedInputNode, ParseFunction } from "../../../parsed-node-types";
+import { zodSelectorFunction } from "../selector";
+
+
+export const parseZodOptionalDef: ParseFunction<ZodOptionalDef, ParsedInputNode & {optional: true}> = (def, refs)=>{
+    const parsedInner = zodSelectorFunction(def.innerType._def, refs)
+    return {
+        ...parsedInner,
+        optional: true,
+    }
+}

packages/trpc-panel/src/parse/input-mappers/zod/parsers/parseZodStringDef.ts

@@ -0,0 +1,10 @@
+import { ParseFunction, StringNode } from "../../../parsed-node-types";
+import { ZodStringDef } from "zod";
+
+export const parseZodStringDef: ParseFunction<ZodStringDef, StringNode> = (_, refs)=>{
+    return {
+        type: 'string',
+        path: refs.path,
+        optional: refs.optional
+    }
+}