How to create a type for a comma delimited string of arbitrary item count

I have an object of filter values:

const values = {
  search,
  users,
  categories,
  sorting,
}

From this I want to derive a type called FilterSelection that extends strings. Here are some
examples of valid and invalid FilterSelections:

exampleFilterSelections = {
  valid: [
    "all",
    "search,users,sorting",
    "-search",
    "-search,-users",
  ], 
  invalid: [
    "any",
    "search,-users",
    "users,users",
    "accounts",
  ]
}

Its trivial to get individual options:

type IncludedFilter = keyof typeof values
type ExcludedFilter = `-${SelectedFilter}`

Then if I can define FilterInclussions and FilterExclusions, I can simply combine them

type FilterSelection = FilterInclusions | FilterExclusions | "all"

However I'm not sure how to define either of these types.

type FilterInclusions = 
  | IncludedFilter 
  | `${IncludedFilter},${IncludedFilter}`
  | `${IncludedFilter},${IncludedFilter},${IncludedFilter}`
  | `${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter}`
  | `${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter}`
  | `${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter},${IncludedFilter}`
  // etc...

But this seems wordy. Is there a better less manual way to do this?

There's unfortunately no scalable way to write a specific FilterSelection type in TypeScript. You'd need to write it as an explicit union
of every allowable string literal type, because there's no specific type that abstracts over your desired rules. (TypeScript lacks regular-expression-validated string types as discussed in microsoft/TypeScript#41160, and pattern template literals as implemented in microsoft/TypeScript#40598 only allow patterns like "any string" or "any numeric string" or even "any uppercase string".) Union types can only hold up to about 100,000 members, so if your union is larger than that you'll have a bad time. Since the list of all possible permutations of a set of strings grows super-exponentially in the size of the set, you'll quickly run into the limit for just a handful of input strings.

So we're giving up on a specific type for FilterSelection.

The best we can do is write a generic type like ValidateFilterSelection<T> that acts like a constraint on T, so that T extends ValidateFilterSelection<T> if and only if T is a valid filter selection. And then we can make a generic helper function like

const filterSelection = <T extends string>(
  t: ValidateFilterSelection<T>
) => t as T;

So that you can have the compiler infer T instead of requiring that you write it out manually. So instead of const f: FilterSelection = "categories,users", you'd write const f = filterSelection("categories,users") which looks the same if you squint at it right. So the hope is that it would behave like this:

const f = filterSelection("categories,users"); // okay

const g = filterSelection("categories,-users"); // error
// ---------------------> ~~~~~~~~~~~~~~~~~~~
// Argument of type '"categories,-users"' is not assignable to 
// parameter of type ....

And if you want to write an array of them you can make a helper function that maps ValidateFilterSeclection<T> over a tuple type, so it behaves like:

const filterSelections = <T extends string[]>(
  t: [...{ [I in keyof T]: ValidateFilterSelection<T[I]> }]
) => t as T;
   
let exampleFilterSelections = filterSelections([
  "all", // okay
  "search,users,sorting", // okay
  "-search", // okay
  "-search,-users", // okay
  "search,categories,sorting,users" // okay
  "any", // error
  "search,-users", // error
  "accounts", // error
]);

So the question is: how do we write ValidateFilterSelection<T>?

Here's one approach:

type ValidateSelection<V extends string, T extends string, A extends string = ""> =
  T extends V ? `${A}${A extends "" ? "" : ","}${T}` :
  T extends `${infer F extends V},${infer R}` ? ValidateSelection<
    Exclude<V, F>, R, `${A}${A extends "" ? "" : ","}${F}`
  > : `${A}${A extends "" ? "" : ","}${V}`

type IncludedFilter = "search" | "users" | "categories" | "sorting"
type ExcludedFilter = `-${IncludedFilter}`

type ValidateFilterSelection<T extends string> =
  ValidateSelection<IncludedFilter, T> |
  ValidateSelection<ExcludedFilter, T> |
  "all";

Let's talk about ValidateSelection<V, T>:

The type ValidateSelection<V, T> takes a union of valid string pieces V, and a candidate string type T and returns T if it's a valid joining of some of those pieces with commas. If T is invalid, then it returns a valid version "close" to T in some sense, so that error messages are hopefully somewhat useful (i.e., "you wrote that but you should probably have written this instead.) So ValidateSelection<"a"|"b"|"c", "a,b"> should be "a,b", but ValidateSelection<"a"|"b"|"c", "b,b"> should be something else, like "b,a" | "b,c".

It's a tail-recursive conditional type that splits T into pieces, can accumulates the result in the type parameter A; if T is already one of the valid V pieces, then we return A concatenated with T. Otherwise if T starts F (a valid V piece) followed by a comma and R (the rest of the string), then we recurse into ValidateSelection with Exclude<V, F> as the new V, and with R as the new T, and with A concatenated with F as the new A. And finally, if T does not start with a valid V, then we return A concatenated with V. This last bit is what is responsible for the "close" result. With Validate<"a"|"b"|"c", "b,b">, it recurses into Validate<"a"|"c", "b", "b">, and finally becomes "b,a" | "b, c".

And then ValidateFilterSelection<T> is just the union of ValidateSelection<IncludedFilter, T>, ValidateSelection<ExcludedFilter, T>, and "all", so T extends ValidateFilterSelection<T> if and only if either T extends ValidateSelection<IncludedFilter, T> for the include filters, or T extends ValidateSelection<ExcludedFilter, T> for the exclude filters, or T extends "all".

Let's see how it works, although there's just one more change::

const filterSelection = <T extends string>(
  t: ValidateFilterSelection<T> & {} // <-- & {} here
) => t as T;

const filterSelections = <T extends string[]>(
  t: [...{ [I in keyof T]: ValidateFilterSelection<T[I]> & {} }]
) => t as T;

I added & {} which doesn't change the types, but it will cause the error message to expand into a union of string literals instead of talking about the ValidateFilterSelection name.

And testing:

const f = filterSelection("categories,users"); // okay
const g = filterSelection("categories,-users"); // error
// ---------------------> ~~~~~~~~~~~~~~~~~~~
// Argument of type '"categories,-users"' is not assignable
// to parameter of type '"-search" | "-users" | "-categories" | "-sorting" | 
// "all" | "categories,users" | "categories,search" | "categories,sorting"'      

let exampleFilterSelections = filterSelections([
  "all", // okay
  "search,users,sorting", // okay
  "-search", // okay
  "-search,-users", // okay
  "search,categories,sorting,users" // okay
  "any", // error
  // Type '"any"' is not assignable to type '"search" | "users" 
  // | "categories" | "sorting" | "-search" | "-users" | 
  // "-categories" | "-sorting" | "all"'.
  "search,-users", // error
  // Type '"search,-users"' is not assignable to type '"-search" | "-users" | "-categories"
  // | "-sorting" | "all" | "search,users" | "search,categories" |
  //  "search,sorting"'. Did you mean '"search,users"'?
  "accounts", // error
  // Type '"accounts"' is not assignable to type '"search" | "users" |
  // "categories" | "sorting" | "-search" | "-users" | 
  // "-categories" | "-sorting" | "all"'.
])

Looks good. Valid strings are accepted and invalid ones are rejected, and the error messages make reasonable-ish suggestions (maybe "search,-users" shouldn't mention "-sorting", but the Did you mean '"search,users"'? is nice).

Playground link to code