# core/validators/architecture.validator.ts

> 48 lines of code and 7 definitions.

Tree: GovLab Context
Language: typescript
Layer: processing
Canonical: https://banes-lab.com/anatomy/context#file-context-core-validators-architecture-validator-ts
Source text: https://banes-lab.com/source/context/core/validators/architecture.validator.ts.txt

Listed in [core/validators](https://banes-lab.com/api/source/context/core/validators.md), after [core/validators/alias.validator.ts](https://banes-lab.com/source/context/core/validators/alias.validator.ts.md) and before [core/validators/check.validator.ts](https://banes-lab.com/source/context/core/validators/check.validator.ts.md).

## Definitions

- `unreachableAntiPatternsOf` (lexical_declaration, line 25, exported)
- `unresolvedExpressionsOf` (lexical_declaration, line 13, exported)
- `invalidSeveritiesOf` (lexical_declaration, line 48, exported)
- `crossFaceCollisions` (lexical_declaration, line 43, exported)
- `ExpressionFaces` (type_alias_declaration, line 11)
- `conflictsTargets` (lexical_declaration, line 26, exported)
- `archIdSet` (lexical_declaration, line 44, exported)

## Contained in

- [core/validators](https://banes-lab.com/anatomy/context/folder-context-core-validators.md)

## Uses

- [configuration/strings/validation.strings.ts](https://banes-lab.com/source/context/configuration/strings/validation.strings.ts.md)
- [core/converters/identifier.converter.ts](https://banes-lab.com/source/context/core/converters/identifier.converter.ts.md)
- [core/resolvers/reference.resolver.ts](https://banes-lab.com/source/context/core/resolvers/reference.resolver.ts.md)

## Used by

- [core/validators/ontology.validator.ts](https://banes-lab.com/source/context/core/validators/ontology.validator.ts.md)

## Linked from

- [configuration/strings](https://banes-lab.com/anatomy/context/folder-context-configuration-strings.md)
- [core/converters](https://banes-lab.com/anatomy/context/folder-context-core-converters.md)
- [core/resolvers](https://banes-lab.com/anatomy/context/folder-context-core-resolvers.md)
- [core/validators](https://banes-lab.com/anatomy/context/folder-context-core-validators.md)

## Source

```typescript
import { CONDITIONAL_SEVERITY, NEGATIVE_KIND } from "#configuration/constants/architecture.constants";
import type { ArchRelations } from "#types/architecture.types";
import type { InvalidSeverity } from "#types/validation.types";
import type { Lexicon } from "#types/lexicon.types";
import { PAG_PREFIX } from "#configuration/constants/reference.constants";
import type { TargetResolverFaces } from "#types/reference.types";
import { conditionalSeverityNeeded } from "#configuration/strings/validation.strings";
import { resolveTarget } from "#core/resolvers/reference.resolver";
import { slugify } from "#core/converters/identifier.converter";

type ExpressionFaces = TargetResolverFaces & { arch: { all: () => { expressedBy?: readonly string[]; id: string }[] } };

export const unresolvedExpressionsOf = function unresolvedExpressionsOf(
    faces: ExpressionFaces,
): { from: string; target: string }[] {
    return faces.arch
        .all()
        .flatMap((principle) =>
            (principle.expressedBy ?? [])
                .filter((target) => !target.startsWith(PAG_PREFIX) || !resolveTarget(faces, target))
                .map((target) => ({ from: principle.id, target })),
        );
};

export const unreachableAntiPatternsOf = function unreachableAntiPatternsOf(arch: ArchRelations): string[] {
    const conflictsTargets = new Set(
        arch
            .all()
            .flatMap((principle) => principle.conflicts_with)
            .map((target) => slugify(target)),
    );
    return arch
        .all()
        .filter((principle) => principle.type === NEGATIVE_KIND)
        .filter(
            (principle) =>
                !conflictsTargets.has(slugify(principle.id)) && !conflictsTargets.has(slugify(principle.name)),
        )
        .map((principle) => principle.id)
        .toSorted((a, b) => a.localeCompare(b));
};

export const crossFaceCollisions = function crossFaceCollisions(arch: ArchRelations, lex: Lexicon): string[] {
    const archIdSet = new Set(arch.ids());
    return lex.ids().filter((id) => archIdSet.has(id));
};

export const invalidSeveritiesOf = function invalidSeveritiesOf(arch: ArchRelations): InvalidSeverity[] {
    return arch
        .all()
        .filter((principle) => principle.mandatoryFor !== undefined && principle.severity !== CONDITIONAL_SEVERITY)
        .map((principle) => ({ id: principle.id, reason: conditionalSeverityNeeded(CONDITIONAL_SEVERITY) }));
};
```