# core/loaders/system.loader.ts

> 72 lines of code and 23 definitions.

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

Listed in [core/loaders](https://banes-lab.com/api/source/docs/core/loaders.md), after [core/loaders/syntax.loader.ts](https://banes-lab.com/source/docs/core/loaders/syntax.loader.ts.md).

## Definitions

- `recordField` (lexical_declaration, line 21)
- `groupOf` (lexical_declaration, line 26)
- `componentsOf` (lexical_declaration, line 31)
- `boundariesOf` (lexical_declaration, line 40)
- `stringField` (lexical_declaration, line 16)
- `dispatchOf` (lexical_declaration, line 57)
- `buildSystemModel` (lexical_declaration, line 72, exported)
- `declaredTools` (lexical_declaration, line 49)
- `SYSTEM_NAME` (lexical_declaration, line 10)
- `SERVICE_KIND` (lexical_declaration, line 11)
- `GROUP_PREFIX` (lexical_declaration, line 12)
- `POSIX_SEPARATOR` (lexical_declaration, line 13)
- `RECORDS_KEY` (lexical_declaration, line 14)
- `field` (lexical_declaration, line 22)
- `[head]` (lexical_declaration, line 27)
- `groups` (lexical_declaration, line 41)
- `manifest` (lexical_declaration, line 50)
- `registry` (lexical_declaration, line 58)
- `records` (lexical_declaration, line 59)
- `declared` (lexical_declaration, line 60)
- `tool` (lexical_declaration, line 63)
- `ecosystem` (lexical_declaration, line 64)
- `dirs` (lexical_declaration, line 73, exported)

## Contained in

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

## Uses

- [core/loaders/base.loader.ts](https://banes-lab.com/source/docs/core/loaders/base.loader.ts.md)
- [core/predicates/record.predicate.ts](https://banes-lab.com/source/docs/core/predicates/record.predicate.ts.md)

## Linked from

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

## Source

```typescript
import { DISPATCH_TABLE, RUNTIME_DEFERRED } from "#configuration/strings/system.strings";
import type { DispatchEdge, SystemComponent, SystemModel, TrustBoundary } from "#types/system.types";
import { ROOT, absolutePath } from "@ssot/paths";
import { PACKAGE_FILE } from "#configuration/constants/document.constants";
import { isPlainRecord } from "#core/predicates/record.predicate";
import { join } from "node:path";
import { readJsonSafe } from "#core/loaders/base.loader";
import { workspaceMembers } from "#core/loaders/package.loader";

const SYSTEM_NAME = "banes-lab";
const SERVICE_KIND = "service";
const GROUP_PREFIX = "group-";
const POSIX_SEPARATOR = "/";
const RECORDS_KEY = "records";

const stringField = function stringField(value: unknown, key: string): string {
    const field = isPlainRecord(value) ? value[key] : undefined;
    return typeof field === "string" ? field : "";
};

const recordField = function recordField(value: unknown, key: string): Readonly<Record<string, unknown>> {
    const field = isPlainRecord(value) ? value[key] : undefined;
    return isPlainRecord(field) ? field : {};
};

const groupOf = function groupOf(dir: string): string {
    const [head] = dir.split(POSIX_SEPARATOR);
    return head ?? dir;
};

const componentsOf = function componentsOf(dirs: readonly string[]): SystemComponent[] {
    return dirs.map((dir) => ({
        boundary: groupOf(dir),
        id: dir,
        kind: SERVICE_KIND,
        label: stringField(readJsonSafe(join(ROOT, dir, PACKAGE_FILE)), "name"),
    }));
};

const boundariesOf = function boundariesOf(dirs: readonly string[]): TrustBoundary[] {
    const groups = [...new Set(dirs.map(groupOf))].toSorted((left, right) => left.localeCompare(right));
    return groups.map((group) => ({
        components: dirs.filter((dir) => groupOf(dir) === group),
        id: `${GROUP_PREFIX}${group}`,
        label: group,
    }));
};

const declaredTools = function declaredTools(): ReadonlySet<string> {
    const manifest = readJsonSafe(join(ROOT, PACKAGE_FILE));
    return new Set([
        ...Object.keys(recordField(manifest, "dependencies")),
        ...Object.keys(recordField(manifest, "devDependencies")),
    ]);
};

const dispatchOf = function dispatchOf(): DispatchEdge[] {
    const registry = readJsonSafe(absolutePath("govlab.quality.data.registry"));
    const records = isPlainRecord(registry) && Array.isArray(registry[RECORDS_KEY]) ? registry[RECORDS_KEY] : [];
    const declared = declaredTools();
    return records
        .flatMap((record: unknown): DispatchEdge[] => {
            const tool = stringField(record, "tool");
            const ecosystem = stringField(record, "ecosystem");
            return tool.length === 0 || ecosystem.length === 0 || !declared.has(tool)
                ? []
                : [{ key: ecosystem, table: DISPATCH_TABLE, target: tool }];
        })
        .toSorted((left, right) => (left.key + left.target).localeCompare(right.key + right.target));
};

export const buildSystemModel = function buildSystemModel(): SystemModel {
    const dirs = workspaceMembers(ROOT);
    return {
        components: componentsOf(dirs),
        dispatch: dispatchOf(),
        name: SYSTEM_NAME,
        runtimeDeferred: RUNTIME_DEFERRED,
        trustBoundaries: boundariesOf(dirs),
    };
};
```