Confirm that two sets of strings are identical, providing detailed error information should they differ

Question

Confirm that two sets of strings are identical, providing detailed error information should they differ

I am currently developing type guards for an API framework and I aim to link the path parameters (a string) with a validation object.

My Desired Outcome:

The structure of my validation object is as follows:

const params = {
  firstArg: someValidationFunction,
  secondArg: someValidationFunction,
}

Here are the expected outcomes for the following strings:

```
/api/some/path/{firstArg}/{secondArg}
```
-> OK (both arguments are present in the string with correct names)
```
/api/some/path/{secondArg}/{firstArg}
```
-> OK (arguments' order does not affect validation)
/api/some/path/{someOtherArg} -> Not OK (both arguments missing and unexpected argument found)

/api/some/path/{firstArg}/{secondArg}/{someOtherArg}

-> Not OK (unexpected argument found)

```
/api/some/path/{firstArg}/secondArg
```
-> Not OK (second argument missing as it lacks curly braces)

Progress So Far:

Referring to this blog post, I have implemented this type helper:

type ExtractPathParams<Path> = Path extends `${infer Segment}/${infer Rest}`
  ? ExtractParam<Segment, ExtractPathParams<Rest>>
  : ExtractParam<Path, {}>;

type ExtractParam<Path, NextPart> = Path extends `{${infer Param}}`
  ? Record<Param, any> & NextPart
  : NextPart;

This helper function retrieves the arguments from the path, and I have been attempting to compare the keys from that with the keys from the validation object. Inspired by this stackoverflow post:

function assert<T extends never>() {}
type Equal<A, B> = Exclude<A, B> | Exclude<B, A>;

type ValidationKeys = keyof params;
const one = '/api/some/path/{firstArg}/{secondArg}';
const two = '/api/some/path/{secondArg}/{firstArg}';
const three = '/api/some/path/{someOtherArg}';
const four = '/api/some/path/{firstArg}/{secondArg}/{someOtherArg}';
const five = '/api/some/path/{firstArg}/secondArg';

assert<Equal<keyof ExtractPathParams<typeof one>, ValidationKeys>>();
assert<Equal<keyof ExtractPathParams<typeof two>, ValidationKeys>>();
// @ts-expect-error
assert<Equal<keyof ExtractPathParams<typeof three>, ValidationKeys>>();
// @ts-expect-error
assert<Equal<keyof ExtractPathParams<typeof four>, ValidationKeys>>();
// @ts-expect-error
assert<Equal<keyof ExtractPathParams<typeof five>, ValidationKeys>>();

While this approach works, I would prefer to receive a type error indicating which keys are missing in the path based on the keys appearing in the ValidationKeys object instead of stating that string is not assignable to never.

Is such an outcome achievable?

typescript typescript-generics

Answer 1

Answer №1

One approach is to create a custom assertEqual() function that directly compares the two type arguments, rather than relying on Exclude, which discards information about the original types:

function assertEqual<T extends U, U extends V, V = T>() { }

This sets up a mutual constraint where T extends U and U extends T. While directly writing this in TypeScript would result in a circular definition, we can achieve similar behavior by establishing relationships between T, U, and V, with V having a default type argument of T. This setup technically avoids circularity because you have the flexibility to specify V as needed.

With this method, you can obtain the desired comparison results:

assertEqual<keyof ExtractPathParams<typeof one>, ValidationKeys>(); // valid
assertEqual<keyof ExtractPathParams<typeof two>, ValidationKeys>(); // valid
assertEqual<keyof ExtractPathParams<typeof three>, ValidationKeys>(); // error!
//          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type '"someOtherArg"' does not satisfy the constraint '"secondArg" | "firstArg"'.
assertEqual<keyof ExtractPathParams<typeof four>, ValidationKeys>(); // error!
//          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type '"secondArg" | "firstArg" | "someOtherArg"' does not satisfy 
// the constraint '"secondArg" | "firstArg"'.
assertEqual<keyof ExtractPathParams<typeof five>, ValidationKeys>(); // error!
//                                                ~~~~~~~~~~~~~~
// Type '"secondArg" | "firstArg"' does not satisfy the constraint '"firstArg"'.

For a hands-on demonstration, check out the code in the Playground link.

Answer 2

One approach is to create a custom assertEqual() function that directly compares the two type arguments, rather than relying on Exclude, which discards information about the original types:

function assertEqual<T extends U, U extends V, V = T>() { }

This sets up a mutual constraint where T extends U and U extends T. While directly writing this in TypeScript would result in a circular definition, we can achieve similar behavior by establishing relationships between T, U, and V, with V having a default type argument of T. This setup technically avoids circularity because you have the flexibility to specify V as needed.

With this method, you can obtain the desired comparison results:

assertEqual<keyof ExtractPathParams<typeof one>, ValidationKeys>(); // valid
assertEqual<keyof ExtractPathParams<typeof two>, ValidationKeys>(); // valid
assertEqual<keyof ExtractPathParams<typeof three>, ValidationKeys>(); // error!
//          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type '"someOtherArg"' does not satisfy the constraint '"secondArg" | "firstArg"'.
assertEqual<keyof ExtractPathParams<typeof four>, ValidationKeys>(); // error!
//          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type '"secondArg" | "firstArg" | "someOtherArg"' does not satisfy 
// the constraint '"secondArg" | "firstArg"'.
assertEqual<keyof ExtractPathParams<typeof five>, ValidationKeys>(); // error!
//                                                ~~~~~~~~~~~~~~
// Type '"secondArg" | "firstArg"' does not satisfy the constraint '"firstArg"'.

For a hands-on demonstration, check out the code in the Playground link.

Confirm that two sets of strings are identical, providing detailed error information should they differ

Answer №1

Similar questions

Innovative Functions of HTML5 LocalStorage for JavaScript and TypeScript Operations

Using TypeScript with React and Material-UI: Issue with undefined theme in createStyles()

Can I modify a global array by updating a dynamically created array in the ngOnInit method of Angular?

What is the best way to structure tabular data with metadata using TypeScript?

Using Fixed Patterns and Combining Types in an Interface

Arranging an array of objects based on a specific keyword and its corresponding value

What could be causing the content in my select box to change only when additional select boxes are introduced?

Implement FieldResolver in TypeGraphQL for an array of objects

Vue Basic Components 'T' has not been declared

The class 'GeoJSON' is mistakenly extending the base class 'FeatureGroup'

Cannot locate AngularJS + Typescript controller

Pause for a few moments prior to initializing Bootstrap and Angular 2

Having trouble accessing Vuex's getter property within a computed property

typescript event handling with oninput

What steps do I need to take in order for TypeScript source files to appear in the node inspector?

Passing a generic type as a parameter in a generic class in TypeScript

The type 'angular' does not have a property of this kind

What is the method to assert that two arguments are equal within a function?

TSX is throwing an error: "No matching overload found for this call."

Enhancing Code Completion Feature for Multiline Strings in Visual Studio Code