Predicates should just accept a value and return an error message or undefined

[sindresorhus]

Right now you have to push it manually to the context. See: #1 (comment)

[SamVerschueren]

I'm looking at how this could look like. Not entirely sure how we should do this though. The predicate should return itself to be able to chain it, so we can't do something like this.

minLength(length: number) {
    return (value: string) => {
		if (value.length < number) {
			return `Expected string length to be minimum ${number}`;
		}
    };
}

Have to dig deeper if we have nice way of doing this.

[sindresorhus]

Maybe we could use Proxies to make it easier?

[sindresorhus]

Alternatively, we could iterate over each method in our class before using it and wrap it in another function.

[sindresorhus]

Or maybe use TypeScript decorators.

[SamVerschueren]

Was thinking about decorators as well. But I think you would then write your logic in your decorator :p. Going to experiment with proxies first.

@Predicate({
    message: 'Value should be alphanumeric',
    validator: x => /^[0-9\d]+$/i.test(x)
})
get alphanumeric() {
    return this;
}

[sindresorhus]

That looks weird. I was thinking the predicate decorator didn't take any arguments but instead wrapped the following function so it would return this, but I still think Proxy might be easier. I like your separation of message and validation though.

[SamVerschueren]

I tried a bunch of things in the meantime. Not sure we could actually make this work with automatic type definitions.

This is what I got

export class StringPredicate extends Predicate {

	constructor(context?: Context) {
		super('string', context);
	}

	@Validator()
	minLength(number: number) {
		return {
			message: () => `Expected string length to be minimum ${number}`,
			validator: (value: string) => value.length < number
		};
	}
}

The thing is that de type definitions think that I return an object with message and validator although I change the return type with the decorator.
So this actually works perfectly, the only thing is that the type definitions do not match with what we're having at runtime... I'm looking into it, if we can change that behaviour but I don't think we can.
Keep you posted!