Revert merge changes

colinhacks · Feb 8, 2023 · 06c237c · 06c237c
1 parent b8d731f
commit 06c237c
Show file tree

Hide file tree

Showing 9 changed files with 361 additions and 138 deletions.
diff --git a/deno/lib/__tests__/catch.test.ts b/deno/lib/__tests__/catch.test.ts
@@ -48,7 +48,7 @@ test("catch with transform", () => {
   );
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string>(true);
 });
@@ -64,7 +64,7 @@ test("catch on existing optional", () => {
   );
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string | undefined>(true);
 });
@@ -73,7 +73,7 @@ test("optional on catch", () => {
   const stringWithDefault = z.string().catch("asdf").optional();
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string | undefined>(true);
 });
@@ -107,7 +107,7 @@ test("nested", () => {
     inner: "asdf",
   });
   type input = z.input<typeof outer>;
-  util.assertEqual<input, { inner: string }>(true);
+  util.assertEqual<input, unknown>(true);
   type out = z.output<typeof outer>;
   util.assertEqual<out, { inner: string }>(true);
   expect(outer.parse(undefined)).toEqual({ inner: "asdf" });

diff --git a/deno/lib/__tests__/object.test.ts b/deno/lib/__tests__/object.test.ts
@@ -229,7 +229,9 @@ test("inferred merged object type with optional properties", async () => {
     .object({ a: z.string(), b: z.string().optional() })
     .merge(z.object({ a: z.string().optional(), b: z.string() }));
   type Merged = z.infer<typeof Merged>;
-  util.assertEqual<Merged, { a?: string; b: string }>(true);
+  util.assertEqual<Merged, { a: string | undefined; b: string }>(true);
+  // todo
+  // util.assertEqual<Merged, { a?: string; b: string }>(true);
 });
 
 test("inferred unioned object type with optional properties", async () => {

diff --git a/deno/lib/types.ts b/deno/lib/types.ts
@@ -1849,25 +1849,7 @@ export namespace objectUtil {
   };
 }
 
-export type extendShape<A, B> = Omit<A, keyof B> & B;
-
-const AugmentFactory =
-  <Def extends ZodObjectDef>(def: Def) =>
-  <Augmentation extends ZodRawShape>(
-    augmentation: Augmentation
-  ): ZodObject<
-    extendShape<ReturnType<Def["shape"]>, Augmentation>,
-    Def["unknownKeys"],
-    Def["catchall"]
-  > => {
-    return new ZodObject({
-      ...def,
-      shape: () => ({
-        ...def.shape(),
-        ...augmentation,
-      }),
-    }) as any;
-  };
+export type extendShape<A, B> = util.flatten<Omit<A, keyof B> & B>;
 
 export type UnknownKeysParam = "passthrough" | "strict" | "strip";
 
@@ -1882,18 +1864,27 @@ export interface ZodObjectDef<
   unknownKeys: UnknownKeys;
 }
 
+export type mergeTypes<A, B> = {
+  [k in keyof A | keyof B]: k extends keyof B
+    ? B[k]
+    : k extends keyof A
+    ? A[k]
+    : never;
+};
+
+export type processType<T extends object> = util.flatten<
+  objectUtil.addQuestionMarks<T>
+>;
 export type baseObjectOutputType<Shape extends ZodRawShape> =
-  objectUtil.flatten<
-    objectUtil.addQuestionMarks<{
-      [k in keyof Shape]: Shape[k]["_output"];
-    }>
-  >;
+  objectUtil.addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]["_output"];
+  }>;
 
 export type objectOutputType<
   Shape extends ZodRawShape,
   Catchall extends ZodTypeAny
 > = ZodTypeAny extends Catchall
-  ? baseObjectOutputType<Shape>
+  ? objectUtil.flatten<baseObjectOutputType<Shape>>
   : objectUtil.flatten<
       baseObjectOutputType<Shape> & { [k: string]: Catchall["_output"] }
     >;
@@ -2128,28 +2119,99 @@ export class ZodObject<
    */
   nonstrict = this.passthrough;
 
-  augment = AugmentFactory<ZodObjectDef<T, UnknownKeys, Catchall>>(this._def);
-  extend = AugmentFactory<ZodObjectDef<T, UnknownKeys, Catchall>>(this._def);
+  // augment = AugmentFactory<ZodObjectDef<T, UnknownKeys, Catchall>>(this._def);
+  // extend = AugmentFactory<ZodObjectDef<T, UnknownKeys, Catchall>>(this._def);
+  extend<
+    Augmentation extends ZodRawShape,
+    // NewShape extends extendShape<T, Augmentation>,
+    // OldOutput = util.flatten<Omit<Output, keyof Augmentation>>,
+    // AugOutput = baseObjectOutputType<Augmentation>,
+    // NewOutput = OldOutput & AugOutput,
+    NewOutput extends util.flatten<{
+      [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+        ? Augmentation[k]["_output"]
+        : k extends keyof Output
+        ? Output[k]
+        : never;
+    }>,
+    // OldInput = util.flatten<Omit<Input, keyof Augmentation>>,
+    // AugInput = baseObjectInputType<Augmentation>,
+    // NewInput = OldInput & AugInput
+    NewInput extends util.flatten<{
+      [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+        ? Augmentation[k]["_input"]
+        : k extends keyof Input
+        ? Input[k]
+        : never;
+    }>
+    // AKeys extends string | number | symbol = keyof Augmentation,
 
-  setKey<Key extends string, Schema extends ZodTypeAny>(
-    key: Key,
-    schema: Schema
-  ): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall> {
-    return this.augment({ [key]: schema }) as any;
+    // AKeys extends string | number | symbol = keyof Augmentation
+  >(
+    augmentation: Augmentation
+  ): ZodObject<
+    extendShape<T, Augmentation>,
+    UnknownKeys,
+    Catchall,
+    NewOutput,
+    NewInput
+  > {
+    return new ZodObject({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...augmentation,
+      }),
+    }) as any;
   }
+  /**
+   * @deprecated Use `.extend` instead
+   *  */
+  augment = this.extend;
 
   /**
    * Prior to zod@1.0.12 there was a bug in the
    * inferred type of merged objects. Please
    * upgrade if you are experiencing issues.
    */
-  merge<Incoming extends AnyZodObject>(
+  // merge<Incoming extends AnyZodObject>(merging: Incoming) {
+  //   return this.extend(merging.shape as Incoming["shape"]);
+  // }
+  merge<
+    Incoming extends AnyZodObject,
+    Augmentation extends Incoming["shape"],
+    // NewShape extends extendShape<T, Augmentation>,
+    // OldOutput = util.flatten<Omit<Output, keyof Augmentation>>,
+    // AugOutput = baseObjectOutputType<Augmentation>,
+    // NewOutput = OldOutput & AugOutput,
+    NewOutput extends {
+      [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+        ? Augmentation[k]["_output"]
+        : k extends keyof Output
+        ? Output[k]
+        : never;
+    },
+    // OldInput = util.flatten<Omit<Input, keyof Augmentation>>,
+    // AugInput = baseObjectInputType<Augmentation>,
+    // NewInput = OldInput & AugInput
+    NewInput extends {
+      [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+        ? Augmentation[k]["_input"]
+        : k extends keyof Input
+        ? Input[k]
+        : never;
+    }
+    // AKeys extends string | number | symbol = keyof Augmentation,
+
+    // AKeys extends string | number | symbol = keyof Augmentation
+  >(
     merging: Incoming
-  ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
-  ZodObject<
+  ): ZodObject<
     extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
     Incoming["_def"]["unknownKeys"],
-    Incoming["_def"]["catchall"]
+    Incoming["_def"]["catchall"],
+    NewOutput,
+    NewInput
   > {
     // const mergedShape = objectUtil.mergeShapes(
     //   this._def.shape(),
@@ -2165,6 +2227,34 @@ export class ZodObject<
     return merged;
   }
 
+  setKey<Key extends string, Schema extends ZodTypeAny>(
+    key: Key,
+    schema: Schema
+  ): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall> {
+    return this.augment({ [key]: schema }) as any;
+  }
+  // merge<Incoming extends AnyZodObject>(
+  //   merging: Incoming
+  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
+  // ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"]
+  // > {
+  //   // const mergedShape = objectUtil.mergeShapes(
+  //   //   this._def.shape(),
+  //   //   merging._def.shape()
+  //   // );
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+
   catchall<Index extends ZodTypeAny>(
     index: Index
   ): ZodObject<T, UnknownKeys, Index> {

diff --git a/playground.ts b/playground.ts
@@ -1,17 +1,55 @@
 import { z } from "./src";
 
-const schema = z.object({
-  a: z.string(),
-  b: z.string().catch("b"),
-});
+const aaa = z.object({ a: z.string(), b: z.number() });
+const bbb = aaa.extend({ b: z.string() });
 
-const result = schema.safeParse({
-  a: {},
-  b: 3,
-});
+const Type1 = z.object({ a: z.string() }).merge(z.object({ a: z.number() }));
+type test1 = z.infer<typeof Type1>;
 
-console.log(result);
+const Type2 = Type1.merge(z.object({ b: z.string() }));
+type test2 = z.infer<typeof Type2>;
 
-const r = z.any().transform((val) => String(val));
-type In = z.input<typeof r>;
-type Out = z.output<typeof r>;
+const Type3 = Type2.merge(z.object({ c: z.string() }));
+type test3 = z.infer<typeof Type3>;
+
+const Type4 = Type3.merge(z.object({ Type3: z.string() }));
+type test4 = z.infer<typeof Type4>;
+
+const Type5 = Type4.merge(z.object({ Type4: z.string() }));
+type test5 = z.infer<typeof Type5>;
+
+const Type6 = Type5.merge(z.object({ Type5: z.string() }));
+type test6 = z.infer<typeof Type6>;
+
+const Type7 = Type6.merge(z.object({ Type6: z.string() }));
+type test7 = z.infer<typeof Type7>;
+
+const Type8 = Type7.merge(z.object({ Type7: z.string() }));
+type test8 = z.infer<typeof Type8>;
+
+const Type9 = Type8.merge(z.object({ Type8: z.string() }));
+type test9 = z.infer<typeof Type9>;
+
+const Type10 = Type9.merge(z.object({ Type9: z.string() }));
+type test10 = z.infer<typeof Type10>;
+
+const Type11 = Type10.merge(z.object({ Type10: z.string() }));
+type test11 = z.infer<typeof Type11>;
+
+const Type12 = Type11.merge(z.object({ Type11: z.string() }));
+type test12 = z.infer<typeof Type12>;
+
+const Type13 = Type12.merge(z.object({ Type12: z.string() }));
+type test13 = z.infer<typeof Type13>;
+
+const Type14 = Type13.merge(z.object({ Type13: z.string() }));
+type test14 = z.infer<typeof Type14>;
+
+const Type15 = Type14.merge(z.object({ Type14: z.string() }));
+type test15 = z.infer<typeof Type15>;
+
+const Type16 = Type14.merge(z.object({ Type15: z.string() }));
+type test16 = z.infer<typeof Type16>;
+
+const arg = Type16.parse("asdf");
+arg;
diff --git a/src/__tests__/catch.test.ts b/src/__tests__/catch.test.ts
@@ -47,7 +47,7 @@ test("catch with transform", () => {
   );
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string>(true);
 });
@@ -63,7 +63,7 @@ test("catch on existing optional", () => {
   );
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string | undefined>(true);
 });
@@ -72,7 +72,7 @@ test("optional on catch", () => {
   const stringWithDefault = z.string().catch("asdf").optional();
 
   type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
+  util.assertEqual<inp, unknown>(true);
   type out = z.output<typeof stringWithDefault>;
   util.assertEqual<out, string | undefined>(true);
 });
@@ -106,7 +106,7 @@ test("nested", () => {
     inner: "asdf",
   });
   type input = z.input<typeof outer>;
-  util.assertEqual<input, { inner: string }>(true);
+  util.assertEqual<input, unknown>(true);
   type out = z.output<typeof outer>;
   util.assertEqual<out, { inner: string }>(true);
   expect(outer.parse(undefined)).toEqual({ inner: "asdf" });