# core/loaders/quality.loader.ts

> 137 lines of code and 29 definitions.

Tree: GovLab Quality
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/quality#file-quality-core-loaders-quality-loader-ts
Source text: https://banes-lab.com/source/quality/core/loaders/quality.loader.ts.txt

Listed in [core/loaders](https://banes-lab.com/api/source/quality/core/loaders.md), after [core/loaders/producer.loader.ts](https://banes-lab.com/source/quality/core/loaders/producer.loader.ts.md) and before [core/loaders/rule.loader.ts](https://banes-lab.com/source/quality/core/loaders/rule.loader.ts.md).

## Definitions

- `loadQualityData` (lexical_declaration, line 143, exported)
- `readRecords` (lexical_declaration, line 21)
- `loadConcepts` (lexical_declaration, line 50)
- `loadRules` (lexical_declaration, line 135)
- `asScalar` (lexical_declaration, line 60)
- `asStringRecord` (lexical_declaration, line 64)
- `normTool` (lexical_declaration, line 125)
- `normKnob` (lexical_declaration, line 70)
- `normConcern` (lexical_declaration, line 79)
- `CONCERNS_FILE` (lexical_declaration, line 16)
- `TOOLS_FILE` (lexical_declaration, line 17)
- `GENERATED_JSON` (lexical_declaration, line 18)
- `DEFAULT_EXEMPLAR_LANG` (lexical_declaration, line 19)
- `asExemplar` (lexical_declaration, line 25)
- `before` (lexical_declaration, line 29)
- `after` (lexical_declaration, line 30)
- `toConcept` (lexical_declaration, line 37)
- `concept` (lexical_declaration, line 38)
- `exemplar` (lexical_declaration, line 43)
- `file` (lexical_declaration, line 51)
- `declared` (lexical_declaration, line 80)
- `value` (lexical_declaration, line 81)
- `concern` (lexical_declaration, line 82)
- `{ configOptions, knobPerTool, valueDerivation }` (lexical_declaration, line 90)
- `normRule` (lexical_declaration, line 103)
- `rule` (lexical_declaration, line 104)
- `canonical` (lexical_declaration, line 114)
- `knobs` (lexical_declaration, line 118)
- `dir` (lexical_declaration, line 136)

## Contained in

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

## Uses

- [core/parsers/record.parser.ts](https://banes-lab.com/source/quality/core/parsers/record.parser.ts.md)
- [core/selectors/record.selector.ts](https://banes-lab.com/source/quality/core/selectors/record.selector.ts.md)

## Used by

- [core/emitters/eslint.emitter.ts](https://banes-lab.com/source/quality/core/emitters/eslint.emitter.ts.md)
- [core/emitters/stylelint.emitter.ts](https://banes-lab.com/source/quality/core/emitters/stylelint.emitter.ts.md)
- [core/resolvers/canon.resolver.ts](https://banes-lab.com/source/quality/core/resolvers/canon.resolver.ts.md)
- [core/selectors/concept.selector.ts](https://banes-lab.com/source/quality/core/selectors/concept.selector.ts.md)

## Linked from

- [core/emitters](https://banes-lab.com/anatomy/quality/folder-quality-core-emitters.md)
- [core/loaders](https://banes-lab.com/anatomy/quality/folder-quality-core-loaders.md)
- [core/parsers](https://banes-lab.com/anatomy/quality/folder-quality-core-parsers.md)
- [core/resolvers](https://banes-lab.com/anatomy/quality/folder-quality-core-resolvers.md)
- [core/selectors](https://banes-lab.com/anatomy/quality/folder-quality-core-selectors.md)

## Source

```typescript
import type {
    Exemplar,
    QualityConcept,
    QualityConcernRecord,
    QualityData,
    QualityRuleRecord,
    QualityToolRecord,
    ToolKnob,
} from "#types/catalog.types";
import { existsSync, readFileSync, readdirSync } from "node:fs";
import { isRecord, numberField, recordsAt, stringArrayField, stringField } from "#core/selectors/record.selector";
import { absolutePath } from "@ssot/paths";
import { jsonRecord } from "#core/parsers/record.parser";
import path from "node:path";

const CONCERNS_FILE = "concerns.generated.json";
const TOOLS_FILE = "tools.generated.json";
const GENERATED_JSON = ".generated.json";
const DEFAULT_EXEMPLAR_LANG = "ts";

const readRecords = function readRecords(file: string): Record<string, unknown>[] {
    return recordsAt(jsonRecord(readFileSync(file, "utf8")), "records");
};

const asExemplar = function asExemplar(value: unknown): Exemplar | null {
    if (!isRecord(value)) {
        return null;
    }
    const before = stringField(value, "before");
    const after = stringField(value, "after");
    if (before.length === 0 && after.length === 0) {
        return null;
    }
    return { after, before, lang: stringField(value, "lang") || DEFAULT_EXEMPLAR_LANG };
};

const toConcept = function toConcept(raw: Record<string, unknown>): QualityConcept | null {
    const concept: QualityConcept = {
        dimension: stringField(raw, "dimension"),
        id: stringField(raw, "id"),
        total: numberField(raw, "total", 0),
    };
    const exemplar = asExemplar(raw["exemplar"]);
    if (exemplar !== null) {
        concept.exemplar = exemplar;
    }
    return concept.id ? concept : null;
};

const loadConcepts = function loadConcepts(): QualityConcept[] {
    const file = absolutePath("govlab.quality.generated.concepts");
    if (!existsSync(file)) {
        return [];
    }
    return recordsAt(jsonRecord(readFileSync(file, "utf8")), "concepts")
        .map(toConcept)
        .filter((concept): concept is QualityConcept => concept !== null);
};

const asScalar = function asScalar(value: unknown): boolean | number | string | null {
    return typeof value === "number" || typeof value === "string" || typeof value === "boolean" ? value : null;
};

const asStringRecord = function asStringRecord(value: Record<string, unknown>): Record<string, string> {
    return Object.fromEntries(
        Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
    );
};

const normKnob = function normKnob(raw: Record<string, unknown>): ToolKnob {
    return {
        default: asScalar(raw["default"]),
        knob: stringField(raw, "knob"),
        threshold: raw["threshold"] === true,
        type: stringField(raw, "type"),
    };
};

const normConcern = function normConcern(raw: Record<string, unknown>): QualityConcernRecord {
    const declared = raw["value"];
    const value = typeof declared === "number" || typeof declared === "boolean" ? declared : true;
    const concern: QualityConcernRecord = {
        name: stringField(raw, "name"),
        numeric: typeof value === "number",
        ruleCount: numberField(raw, "ruleCount", 0),
        severity: stringField(raw, "severity") || "error",
        toolCount: numberField(raw, "toolCount", 0),
        value,
    };
    const { configOptions, knobPerTool, valueDerivation } = raw;
    if (typeof valueDerivation === "string") {
        concern.valueDerivation = valueDerivation;
    }
    if (isRecord(knobPerTool)) {
        concern.knobPerTool = asStringRecord(knobPerTool);
    }
    if (Array.isArray(configOptions)) {
        concern.configOptions = stringArrayField(raw, "configOptions");
    }
    return concern;
};

const normRule = function normRule(raw: Record<string, unknown>): QualityRuleRecord {
    const rule: QualityRuleRecord = {
        category: stringField(raw, "category"),
        concern: stringField(raw, "concern"),
        ecosystem: stringField(raw, "ecosystem"),
        name: stringField(raw, "name"),
        ruleId: stringField(raw, "ruleId"),
        ruleName: stringField(raw, "ruleName"),
        tool: stringField(raw, "tool"),
        url: stringField(raw, "url"),
    };
    const canonical = stringArrayField(raw, "canonical");
    if (canonical.length > 0) {
        rule.canonical = canonical;
    }
    const knobs = recordsAt(raw, "knobs");
    if (knobs.length > 0) {
        rule.knobs = knobs.map(normKnob);
    }
    return rule;
};

const normTool = function normTool(raw: Record<string, unknown>): QualityToolRecord {
    return {
        detectionOnly: raw["detectionOnly"] === true,
        ecosystem: stringField(raw, "ecosystem"),
        knobCount: numberField(raw, "knobCount", 0),
        name: stringField(raw, "name"),
        ruleCount: numberField(raw, "ruleCount", 0),
    };
};

const loadRules = function loadRules(): QualityRuleRecord[] {
    const dir = absolutePath("govlab.quality.ecosystemRules");
    return readdirSync(dir)
        .filter((name) => name.endsWith(GENERATED_JSON))
        .toSorted((a, b) => a.localeCompare(b))
        .flatMap((name) => readRecords(path.join(dir, name)).map(normRule));
};

export const loadQualityData = function loadQualityData(): QualityData {
    return {
        concepts: loadConcepts(),
        concerns: readRecords(absolutePath("govlab.quality.generated", CONCERNS_FILE)).map(normConcern),
        rules: loadRules(),
        tools: readRecords(absolutePath("govlab.quality.generated", TOOLS_FILE)).map(normTool),
    };
};
```