Is there any way to assert that an optional value is not Nil in compile time?

[jotacoroe2y]

Hi,

we usually have steps in our E2E tests where we want to assert on a list of objects with optional properties:

For example this is one of our steps, using the containAtLeastOneItemThat expectation:

Then(
  '{actor} should see the following localized attributes in {string} CMSSite',
  async (actor: Actor, cmsSiteId: string, table: DataTable) => {
    const [cmsSiteAttributes] = table.hashes() as {
      language: string;
      localizedAttribute: keyof CMSSiteLocalizedAttributes;
      uid: string;
      value: string;
    }[];

    await actor.attemptsTo(
      Ensure.eventually(
        CmsSite.withAGivenIdentifier(cmsSiteId),
        and(
          property('localizedAttributes', isPresent()),
          property(
            'localizedAttributes',
            property(
              'results',
              containAtLeastOneItemThat(
                property(
                  cmsSiteAttributes.localizedAttribute,
                  equals(cmsSiteAttributes.value),
                ),
              ),
            ),
          ),
        ),
      ),
    );
  },
);

Where localizedAttributes key is typed as optional:

export interface ICmsSite {
  (... more keys ...)
  localizedAttributes?: { results: CMSSiteLocalizedAttributes[] };
  (... more keys ...)
}

export interface CMSSiteLocalizedAttributes {
  language: string;
  name: string;
}

This works fine in runtime, but in compile time I'll have the following error:

TS2345: Argument of type  Expectation<object>  is not assignable to parameter of type:
Expectation<{     results: { language: string, name: string }[]; } | undefined>
Property  results  is missing in type  {}  but required in type  { results: { language: string, name: string }[]; }

---

What I'm expecting here is that isPresent() expectation resolves in compile time in order to treat the property localizedAttributes as a required one. Something similar that you could expect from an assertion function.
But this doesn't happen.

Is there a more correct way to execute the proposed example in order to achieve the expected output?

Regards,