From 4feae9cd93707a9f4ae42ab868c211957bc89f9b Mon Sep 17 00:00:00 2001
From: Chris Wilkinson <c.wilkinson@elifesciences.org>
Date: Fri, 1 Apr 2022 09:34:05 +0100
Subject: [PATCH] Treat struct properties that have type undefined as optional

---
 docs/modules/Codec.ts.md   |  8 +++++--
 docs/modules/Decoder.ts.md | 48 ++++++++++++++++++++++++++++++++++----
 docs/modules/Encoder.ts.md |  2 +-
 dtslint/ts3.5/Codec.ts     | 24 ++++++++++++++++---
 dtslint/ts3.5/Decoder.ts   | 14 +++++++++--
 dtslint/ts3.5/Encoder.ts   |  5 +++-
 src/Codec.ts               | 17 +++++++++++---
 src/Decoder.ts             | 18 ++++++++++----
 src/Encoder.ts             | 11 +++++++--
 9 files changed, 124 insertions(+), 23 deletions(-)

diff --git a/docs/modules/Codec.ts.md b/docs/modules/Codec.ts.md
index 0f5feca2..1a7c6388 100644
--- a/docs/modules/Codec.ts.md
+++ b/docs/modules/Codec.ts.md
@@ -147,7 +147,11 @@ Added in v2.2.3
 ```ts
 export declare function fromStruct<P extends Record<string, Codec<any, any, any>>>(
   properties: P
-): Codec<{ [K in keyof P]: InputOf<P[K]> }, { [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }>
+): Codec<
+  ToOptional<{ [K in keyof P]: InputOf<P[K]> }>,
+  ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>,
+  ToOptional<{ [K in keyof P]: TypeOf<P[K]> }>
+>
 ```
 
 Added in v2.2.15
@@ -280,7 +284,7 @@ Added in v2.2.3
 ```ts
 export declare function struct<P extends Record<string, Codec<unknown, any, any>>>(
   properties: P
-): Codec<unknown, { [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }>
+): Codec<unknown, ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>, ToOptional<{ [K in keyof P]: TypeOf<P[K]> }>>
 ```
 
 Added in v2.2.15
diff --git a/docs/modules/Decoder.ts.md b/docs/modules/Decoder.ts.md
index 347edd76..96db1cf1 100644
--- a/docs/modules/Decoder.ts.md
+++ b/docs/modules/Decoder.ts.md
@@ -232,7 +232,21 @@ Added in v2.2.8
 ```ts
 export declare const fromStruct: <P extends Record<string, Decoder<any, any>>>(
   properties: P
-) => Decoder<{ [K in keyof P]: K.InputOf<'Either', P[K]> }, { [K in keyof P]: K.TypeOf<'Either', P[K]> }>
+) => Decoder<
+  { [K in keyof P]: K.InputOf<'Either', P[K]> },
+  Merge<
+    Pick<
+      { [K in keyof P]: K.TypeOf<'Either', P[K]> },
+      Exclude<keyof P, UndefinedProperties<{ [K in keyof P]: K.TypeOf<'Either', P[K]> }>>
+    > &
+      Partial<
+        Pick<
+          { [K in keyof P]: K.TypeOf<'Either', P[K]> },
+          UndefinedProperties<{ [K in keyof P]: K.TypeOf<'Either', P[K]> }>
+        >
+      >
+  >
+>
 ```
 
 Added in v2.2.15
@@ -371,7 +385,13 @@ Added in v2.2.7
 ```ts
 export declare const struct: <A>(
   properties: { [K in keyof A]: Decoder<unknown, A[K]> }
-) => Decoder<unknown, { [K in keyof A]: A[K] }>
+) => Decoder<
+  unknown,
+  Merge<
+    Pick<{ [K in keyof A]: A[K] }, Exclude<keyof A, UndefinedProperties<{ [K in keyof A]: A[K] }>>> &
+      Partial<Pick<{ [K in keyof A]: A[K] }, UndefinedProperties<{ [K in keyof A]: A[K] }>>>
+  >
+>
 ```
 
 Added in v2.2.15
@@ -433,7 +453,21 @@ Use `fromStruct` instead.
 ```ts
 export declare const fromType: <P extends Record<string, Decoder<any, any>>>(
   properties: P
-) => Decoder<{ [K in keyof P]: K.InputOf<'Either', P[K]> }, { [K in keyof P]: K.TypeOf<'Either', P[K]> }>
+) => Decoder<
+  { [K in keyof P]: K.InputOf<'Either', P[K]> },
+  Merge<
+    Pick<
+      { [K in keyof P]: K.TypeOf<'Either', P[K]> },
+      Exclude<keyof P, UndefinedProperties<{ [K in keyof P]: K.TypeOf<'Either', P[K]> }>>
+    > &
+      Partial<
+        Pick<
+          { [K in keyof P]: K.TypeOf<'Either', P[K]> },
+          UndefinedProperties<{ [K in keyof P]: K.TypeOf<'Either', P[K]> }>
+        >
+      >
+  >
+>
 ```
 
 Added in v2.2.8
@@ -447,7 +481,13 @@ Use `struct` instead.
 ```ts
 export declare const type: <A>(
   properties: { [K in keyof A]: Decoder<unknown, A[K]> }
-) => Decoder<unknown, { [K in keyof A]: A[K] }>
+) => Decoder<
+  unknown,
+  Merge<
+    Pick<{ [K in keyof A]: A[K] }, Exclude<keyof A, UndefinedProperties<{ [K in keyof A]: A[K] }>>> &
+      Partial<Pick<{ [K in keyof A]: A[K] }, UndefinedProperties<{ [K in keyof A]: A[K] }>>>
+  >
+>
 ```
 
 Added in v2.2.7
diff --git a/docs/modules/Encoder.ts.md b/docs/modules/Encoder.ts.md
index 153decb6..8208a586 100644
--- a/docs/modules/Encoder.ts.md
+++ b/docs/modules/Encoder.ts.md
@@ -167,7 +167,7 @@ Added in v2.2.3
 ```ts
 export declare function struct<P extends Record<string, Encoder<any, any>>>(
   properties: P
-): Encoder<{ [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }>
+): Encoder<ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>, { [K in keyof P]: TypeOf<P[K]> }>
 ```
 
 Added in v2.2.15
diff --git a/dtslint/ts3.5/Codec.ts b/dtslint/ts3.5/Codec.ts
index 677e7fe0..257a183e 100644
--- a/dtslint/ts3.5/Codec.ts
+++ b/dtslint/ts3.5/Codec.ts
@@ -1,12 +1,14 @@
 import * as _ from '../../src/Codec'
 
+declare const Optional: <I, O, A>(codec: _.Codec<I, O, A>) => _.Codec<I | undefined, O | undefined, A | undefined>
+
 declare const NumberFromString: _.Codec<string, string, number>
 
 //
 // fromStruct
 //
 
-// $ExpectType Codec<{ a: unknown; b: { c: string; }; }, { a: string; b: { c: string; }; }, { a: string; b: { c: number; }; }>
+// $ExpectType Codec<{ b: { c: string; }; a?: unknown; }, { a: string; b: { c: string; }; }, { a: string; b: { c: number; }; }>
 _.fromStruct({
   a: _.string,
   b: _.fromStruct({
@@ -14,6 +16,14 @@ _.fromStruct({
   })
 })
 
+// $ExpectType Codec<{ b: { c?: string | undefined; }; a?: unknown; }, { b: { c?: string | undefined; }; a?: string | undefined; }, { b: { c?: number | undefined; }; a?: string | undefined; }>
+_.fromStruct({
+  a: Optional(_.string),
+  b: _.fromStruct({
+    c: Optional(NumberFromString)
+  })
+})
+
 //
 // struct
 //
@@ -26,6 +36,14 @@ _.struct({
   })
 })
 
+// $ExpectType Codec<unknown, { b: { c?: number | undefined; }; a?: string | undefined; }, { b: { c?: number | undefined; }; a?: string | undefined; }>
+_.struct({
+  a: Optional(_.string),
+  b: _.struct({
+    c: Optional(_.number),
+  }),
+})
+
 //
 // fromPartial
 //
@@ -96,7 +114,7 @@ _.tuple(_.string, _.number, _.boolean)
 // fromSum
 //
 
-// $ExpectType Codec<{ _tag: unknown; a: unknown; } | { _tag: unknown; b: string; }, { _tag: "A"; a: string; } | { _tag: "B"; b: string; }, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+// $ExpectType Codec<{ a?: unknown; _tag?: unknown; } | { b: string; _tag?: unknown; }, { a: string; _tag: "A"; } | { b: string; _tag: "B"; }, { a: string; _tag: "A"; } | { b: number; _tag: "B"; }>
 _.fromSum('_tag')({
   A: _.fromStruct({ _tag: _.literal('A'), a: _.string }),
   B: _.fromStruct({ _tag: _.literal('B'), b: NumberFromString })
@@ -109,7 +127,7 @@ _.fromSum('_tag')({
 const S1 = _.struct({ _tag: _.literal('A'), a: _.string })
 const S2 = _.struct({ _tag: _.literal('B'), b: _.number })
 
-// $ExpectType Codec<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+// $ExpectType Codec<unknown, { a: string; _tag: "A"; } | { b: number; _tag: "B"; }, { a: string; _tag: "A"; } | { b: number; _tag: "B"; }>
 _.sum('_tag')({ A: S1, B: S2 })
 // // $ExpectError
 // _.sum('_tag')({ A: S1, B: S1 })
diff --git a/dtslint/ts3.5/Decoder.ts b/dtslint/ts3.5/Decoder.ts
index 94e80ca7..fd2d03ca 100644
--- a/dtslint/ts3.5/Decoder.ts
+++ b/dtslint/ts3.5/Decoder.ts
@@ -3,6 +3,8 @@ import * as DE from '../../src/DecodeError'
 import * as _ from '../../src/Decoder'
 import * as FS from '../../src/FreeSemigroup'
 
+declare const Optional: <I, A>(decoder: _.Decoder<I, A>) => _.Decoder<I, A | undefined>
+
 declare const NumberFromString: _.Decoder<string, number>
 
 //
@@ -43,6 +45,14 @@ _.struct({
   })
 })
 
+// $ExpectType Decoder<unknown, { b: { c?: number | undefined; }; a?: string | undefined; }>
+_.struct({
+  a: Optional(_.string),
+  b: _.struct({
+    c: Optional(_.number)
+  })
+})
+
 //
 // fromPartial
 //
@@ -113,7 +123,7 @@ _.tuple(_.string, _.number, _.boolean)
 // fromSum
 //
 
-// $ExpectType Decoder<{ _tag: unknown; a: unknown; } | { _tag: unknown; b: string; }, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+// $ExpectType Decoder<{ _tag: unknown; a: unknown; } | { _tag: unknown; b: string; }, { a: string; _tag: "A"; } | { b: number; _tag: "B"; }>
 _.fromSum('_tag')({
   A: _.fromStruct({ _tag: _.literal('A'), a: _.string }),
   B: _.fromStruct({ _tag: _.literal('B'), b: NumberFromString })
@@ -126,7 +136,7 @@ _.fromSum('_tag')({
 const S1 = _.struct({ _tag: _.literal('A'), a: _.string })
 const S2 = _.struct({ _tag: _.literal('B'), b: _.number })
 
-// $ExpectType Decoder<unknown, { _tag: "A"; a: string; } | { _tag: "B"; b: number; }>
+// $ExpectType Decoder<unknown, { a: string; _tag: "A"; } | { b: number; _tag: "B"; }>
 _.sum('_tag')({ A: S1, B: S2 })
 // $ExpectError
 _.sum('_tag')({ A: S1, B: S1 })
diff --git a/dtslint/ts3.5/Encoder.ts b/dtslint/ts3.5/Encoder.ts
index 8bb901d4..327aae9f 100644
--- a/dtslint/ts3.5/Encoder.ts
+++ b/dtslint/ts3.5/Encoder.ts
@@ -1,6 +1,8 @@
 import * as E from '../../src/Encoder'
 import { pipe } from 'fp-ts/lib/pipeable'
 
+declare const Optional: <O, A>(encoder: E.Encoder<O, A>) => E.Encoder<O | undefined, A | undefined>
+
 const NumberToString: E.Encoder<string, number> = {
   encode: String
 }
@@ -30,6 +32,7 @@ E.nullable(NumberToString) // $ExpectType Encoder<string | null, number | null>
 // struct
 //
 E.struct({ a: E.struct({ b: NumberToString }) }) // $ExpectType Encoder<{ a: { b: string; }; }, { a: { b: number; }; }>
+E.struct({ a: Optional(E.struct({ b: Optional(NumberToString) })) }) // $ExpectType Encoder<{ a?: { b?: string | undefined; } | undefined; }, { a: { b: number | undefined; } | undefined; }>
 
 //
 // partial
@@ -65,7 +68,7 @@ const S1 = E.struct({ _tag: E.id<'A'>(), a: NumberToString })
 const S2 = E.struct({ _tag: E.id<'B'>(), b: BooleanToNumber })
 const sum = E.sum('_tag')
 
-// $ExpectType Encoder<{ _tag: "A"; a: string; } | { _tag: "B"; b: number; }, { _tag: "A"; a: number; } | { _tag: "B"; b: boolean; }>
+// $ExpectType Encoder<{ a: string; _tag: "A"; } | { b: number; _tag: "B"; }, { _tag: "A"; a: number; } | { _tag: "B"; b: boolean; }>
 sum({ A: S1, B: S2 })
 
 const S3 = E.struct({ _tag: E.id<'C'>(), c: E.id<string>() })
diff --git a/src/Codec.ts b/src/Codec.ts
index fe43c2aa..bcc1da6b 100644
--- a/src/Codec.ts
+++ b/src/Codec.ts
@@ -148,8 +148,12 @@ export function nullable<I, O, A>(or: Codec<I, O, A>): Codec<null | I, null | O,
  */
 export function fromStruct<P extends Record<string, Codec<any, any, any>>>(
   properties: P
-): Codec<{ [K in keyof P]: InputOf<P[K]> }, { [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }> {
-  return make(D.fromStruct(properties) as any, E.struct(properties))
+): Codec<
+  ToOptional<{ [K in keyof P]: InputOf<P[K]> }>,
+  ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>,
+  ToOptional<{ [K in keyof P]: TypeOf<P[K]> }>
+> {
+  return make(D.fromStruct(properties) as any, E.struct(properties) as any)
 }
 
 /**
@@ -167,7 +171,7 @@ export const fromType = fromStruct
  */
 export function struct<P extends Record<string, Codec<unknown, any, any>>>(
   properties: P
-): Codec<unknown, { [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }> {
+): Codec<unknown, ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>, ToOptional<{ [K in keyof P]: TypeOf<P[K]> }>> {
   return pipe(UnknownRecord, compose(fromStruct(properties as any))) as any
 }
 
@@ -385,3 +389,10 @@ export type OutputOf<C> = E.OutputOf<C>
  * @since 2.2.3
  */
 export type TypeOf<C> = E.TypeOf<C>
+
+type UndefinedProperties<T> = {
+  [P in keyof T]-?: undefined extends T[P] ? P : never
+}[keyof T]
+type ToOptional<T> = Merge<Pick<T, Exclude<keyof T, UndefinedProperties<T>>> & Partial<Pick<T, UndefinedProperties<T>>>>
+type Identity<T> = T
+type Merge<T> = T extends any ? Identity<{ [k in keyof T]: T[k] }> : never
diff --git a/src/Decoder.ts b/src/Decoder.ts
index f98ff1d2..7751774b 100644
--- a/src/Decoder.ts
+++ b/src/Decoder.ts
@@ -232,8 +232,8 @@ export const nullable: <I, A>(or: Decoder<I, A>) => Decoder<null | I, null | A>
  */
 export const fromStruct = <P extends Record<string, Decoder<any, any>>>(
   properties: P
-): Decoder<{ [K in keyof P]: InputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }> =>
-  K.fromStruct(M)((k, e) => FS.of(DE.key(k, DE.required, e)))(properties)
+): Decoder<{ [K in keyof P]: InputOf<P[K]> }, ToOptional<{ [K in keyof P]: TypeOf<P[K]> }>> =>
+  K.fromStruct(M)((k, e) => FS.of(DE.key(k, DE.required, e)))(properties) as any
 
 /**
  * Use `fromStruct` instead.
@@ -250,7 +250,8 @@ export const fromType = fromStruct
  */
 export const struct = <A>(
   properties: { [K in keyof A]: Decoder<unknown, A[K]> }
-): Decoder<unknown, { [K in keyof A]: A[K] }> => pipe(UnknownRecord as any, compose(fromStruct(properties)))
+): Decoder<unknown, ToOptional<{ [K in keyof A]: A[K] }>> =>
+  pipe(UnknownRecord as any, compose(fromStruct(properties))) as any
 
 /**
  * Use `struct` instead.
@@ -488,8 +489,8 @@ export const Schemable: S.Schemable2C<URI, unknown> = {
   number,
   boolean,
   nullable,
-  type,
-  struct,
+  type: type as S.Schemable2C<URI, unknown>['type'], // tslint:disable-line:deprecation
+  struct: struct as S.Schemable2C<URI, unknown>['struct'],
   partial,
   record,
   array,
@@ -609,3 +610,10 @@ export const draw = (e: DecodeError): string => toForest(e).map(drawTree).join('
 export const stringify: <A>(e: E.Either<DecodeError, A>) => string =
   /*#__PURE__*/
   E.fold(draw, (a) => JSON.stringify(a, null, 2))
+
+type UndefinedProperties<T> = {
+  [P in keyof T]-?: undefined extends T[P] ? P : never
+}[keyof T]
+type ToOptional<T> = Merge<Pick<T, Exclude<keyof T, UndefinedProperties<T>>> & Partial<Pick<T, UndefinedProperties<T>>>>
+type Identity<T> = T
+type Merge<T> = T extends any ? Identity<{ [k in keyof T]: T[k] }> : never
diff --git a/src/Encoder.ts b/src/Encoder.ts
index 8cf7a085..b28cb9de 100644
--- a/src/Encoder.ts
+++ b/src/Encoder.ts
@@ -45,14 +45,14 @@ export function nullable<O, A>(or: Encoder<O, A>): Encoder<null | O, null | A> {
  */
 export function struct<P extends Record<string, Encoder<any, any>>>(
   properties: P
-): Encoder<{ [K in keyof P]: OutputOf<P[K]> }, { [K in keyof P]: TypeOf<P[K]> }> {
+): Encoder<ToOptional<{ [K in keyof P]: OutputOf<P[K]> }>, { [K in keyof P]: TypeOf<P[K]> }> {
   return {
     encode: (a) => {
       const o: Record<keyof P, any> = {} as any
       for (const k in properties) {
         o[k] = properties[k].encode(a[k])
       }
-      return o
+      return o as any
     }
   }
 }
@@ -260,3 +260,10 @@ export type TypeOf<E> = E extends Encoder<any, infer A> ? A : never
  * @since 2.2.3
  */
 export type OutputOf<E> = E extends Encoder<infer O, any> ? O : never
+
+type UndefinedProperties<T> = {
+  [P in keyof T]-?: undefined extends T[P] ? P : never
+}[keyof T]
+type ToOptional<T> = Merge<Pick<T, Exclude<keyof T, UndefinedProperties<T>>> & Partial<Pick<T, UndefinedProperties<T>>>>
+type Identity<T> = T
+type Merge<T> = T extends any ? Identity<{ [k in keyof T]: T[k] }> : never