config-schema incorrectly types a Maybe field as T | undefined instead of optional on objects

[gmmorris]

Kibana version: 7.7+ (on master)

Describe the bug:
If you use schema.maybe() on an object , the prop is only marked as T | undefined, but it should be optional (perhaps both, rather than instead).

Steps to reproduce:

1. Define an object like so:

const schemaWithOptional = schema.object({
  prop: schema.maybe(schema.string()),
});
export type SchemaWithOptional = TypeOf<typeof schemaWithOptional>;

2. Look at typescript signature of SchemaWithOptional - the prop field is marked as string | undefined, meaning you can't omit the prop field and have to set it as undefined.

interface SchemaWithOptional {
   prop: string | undefined;
}

Expected behavior:
The type should be:

interface SchemaWithOptional {
   prop?: string;
}

or perhaps:

interface SchemaWithOptional {
   prop?: string | undefined;
}

[elasticmachine]

Pinging @elastic/kibana-platform (Team:Platform)

[pgayvallet]

I think The type should be

interface SchemaWithOptional {
   prop?: string | undefined;
}

However, technically, this requires the parent object schema's Type to be dependant on the children schema types, which I'm not sure is doable in typescript.

Will take a look.

[pgayvallet]

This all goes down to

kibana/packages/kbn-config-schema/src/types/object_type.ts

Line 31 in 9318862

export type ObjectResultType<P extends Props> = Readonly<{ [K in keyof P]: TypeOf<P[K]> }>;

Would need to find a TS way to check if TypeOf<P[K]> extends MaybeType

[pgayvallet]

So, after a few hours hating typescript:

This can be fixed by changing

type ObjectResultType<P extends Props> = Readonly<{ [K in keyof P]: TypeOf<P[K]> }>;

with

type OptionalProperties<Base extends Props> = Pick<
  Base,
  {
    [Key in keyof Base]: undefined extends TypeOf<Base[Key]> ? Key : never;
  }[keyof Base]
>;

type RequiredProperties<Base extends Props> = Pick<
  Base,
  {
    [Key in keyof Base]: undefined extends TypeOf<Base[Key]> ? never : Key;
  }[keyof Base]
>;

export type ObjectResultType<P extends Props> = Readonly<
  { [K in keyof OptionalProperties<P>]?: TypeOf<P[K]> } &
    { [K in keyof RequiredProperties<P>]: TypeOf<P[K]> }
>;

The TypeOf is fixed:

const type = schema.object({
    required: schema.string(),
    optional: schema.maybe(schema.string()),
  });

  type SchemaType = TypeOf<typeof type>;

  let foo: SchemaType = { // no error
    required: 'foo',
  };
  foo = { // no error
    required: 'hello',
    optional: undefined,
  };
  foo = { // no error
    required: 'hello',
    optional: 'bar',
  };

 foo = { // error
    optional: 'bar',
  };
 foo = { // error
  };

However this change causes the router validator (src/core/server/http/router/validator/validator.ts) to just implode, with

This is directly related to this type

kibana/src/core/server/http/router/validator/validator.ts

Lines 83 to 90 in d8f94b1

	// Ugly as hell but we need this conditional typing to have proper type inference
	type RouteValidationResultType<T extends RouteValidationSpec<any> | undefined> = NonNullable<
	T extends RouteValidationFunction<any>
	? ReturnType<T>['value']
	: T extends Type<any>
	? ReturnType<T['validate']>
	: undefined
	>;

However this file is a very sensible piece of TS magic, and I couldn't find a proper way to fix the typings without force casting everywhere.

If someone wants to have a look, feel free.

[gmmorris]

haha sorry if I broke you @pgayvallet