Matching for properties not to exist

[nidomiro]

Is there a way to match for 'property b should not exist'?

My usecase is, that I have an Object where all properties are optional and only one is allowed to be set at a time.
I know I could solve this with the ts-typesystem, but not in my case, as the object is coming from an API-Call.

What I already tried:

Given the Input Object

class Input {
  a?: { a?: string; b?: string };
  b?: String;
}

The pattern:

{ a: P.not(P.nullish)} // Matches regardless the value of b
{ a: P.not(P.nullish), b: P.nullish } // Matches onlyif b is set to undefined or null

With what pattern can I say 'match if a is there, but no other property`?

[gvergnaud]

Hi!
TS-Pattern doesn't have an "exact object" pattern, because TypeScript doesn't have an "exact object" type and I'm trying to keep patterns semantically close to types.

That said, you can use a P.when guard for this:

const hasOneKey = P.when((obj: {}) => Object.keys(obj).length === 1)

P.intersection(hasOneKey, { a: P.not(P.nullish) })

P.intersection let's you check if all patterns in a list match the input value

[gvergnaud]

You could also create a "strictObject" pattern with P.when:

function strictObject<Input, P extends P.Pattern<Input> & {}>(
  pattern: P
): GuardExcludeP<Input, P.narrow<Input, P>, never> {
  const patternKeys = new Set(Object.keys(pattern));
  return P.when(
    (value) =>
      isMatching(pattern, value) &&
      Object.keys(value).every((key) => patternKeys.has(key))
  );
}


const result =  match<{ a?: string; b?: string }>({ a: '', b: '' })
      .with(strictObject({ a: P.string }), () => 'a')
      .with(strictObject({ b: P.string }), () => 'b')
      .otherwise(() => 'c')


expect(result).toBe('c');