Generic node property validator util

[guyo13]

Just discovered this amazing project and started hacking at it to create DSLs for my projects and clients!

I created a small validator util which can validate for uniqueness of property values over a typed array of AstNodes.
It is adapted from the example in the tutorials but the nice thing is that both the node type and its property are typed which facilitates development.

Here is the code

import type {
  AstNode,
  Properties,
  ValidationAcceptor,
  ValidationSeverity,
} from "langium";

type ErrorFormatter<
  N extends AstNode,
  P extends keyof N & Properties<N>,
> = (data: { propertyValue: N[P] }) => string;

export function uniquePropertyValidator<
  N extends AstNode,
  P extends keyof N & Properties<N>,
>(
  nodes: Array<N>,
  propertyName: P,
  accept: ValidationAcceptor,
  formatter: ErrorFormatter<N, P>,
  severity: ValidationSeverity = "error",
) {
  if (nodes.length) {
    const reported = new Set();
    nodes.forEach((node) => {
      const propertyValue = node[propertyName];
      if (reported.has(propertyValue)) {
        accept(severity, formatter({ propertyValue }), {
          node: node,
          property: propertyName,
        });
      }
      reported.add(propertyValue);
    });
  }
}

Example usage in a validator:

export class MyLangValidator {
  checkUniqueGreetName(model: Model, accept: ValidationAcceptor): void {
    uniquePropertyValidator(
      model.greets,
      "name",
      accept,
      ({ propertyValue }) =>
        `Greet name should be unique. Greet '${propertyValue}' already defined.`,
    );
  }
}

Wdyt? Is the type constraint on P accurate? Maybe its worth to start some validation utils library as part of the monorepo.

[guyo13]

For anyone interested, I created a utility library that contains this function. @guyo13/langium-utils
will probably add more utilities as I continue building :)

[msujew]

Hey @guyo13,

looks pretty interesting. I haven't tried this out, but I'm wondering whether the Properties<N> in P extends keyof N & Properties<N> is a bit redundant. I believe keyof N already contains all keys that are part of Properties<N>, so creating their intersection adds no further keys. In my mind Properties<N> is supposed to be a subset of keyof N.