# core/loaders/detector.loader.ts

> 28 lines of code and 6 definitions.

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

Listed in [core/loaders](https://banes-lab.com/api/source/secrets/core/loaders.md).

## Definitions

- `loadDetectors` (lexical_declaration, line 10, exported)
- `folder` (lexical_declaration, line 11, exported)
- `files` (lexical_declaration, line 12, exported)
- `detectors` (lexical_declaration, line 20, exported)
- `missing` (lexical_declaration, line 21, exported)
- `detectedKinds` (lexical_declaration, line 28, exported)

## Contained in

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

## Uses

- [configuration/strings/detector.strings.ts](https://banes-lab.com/source/secrets/configuration/strings/detector.strings.ts.md)

## Linked from

- [configuration/strings](https://banes-lab.com/anatomy/secrets/folder-secrets-configuration-strings.md)

## Source

```typescript
import { DETECTOR_KINDS, DETECTOR_SUFFIX } from "#configuration/constants/detector.constants";
import type { Detector } from "#types/detector.types";
import { absolutePath } from "@ssot/paths";
import { join } from "node:path";
import { missingDetectors } from "#configuration/strings/detector.strings";
import { pathToFileURL } from "node:url";
import { readdirSync } from "node:fs";
import { registeredDetectors } from "#core/registries/detector.registry";

export const loadDetectors = async function loadDetectors(): Promise<readonly Detector[]> {
    const folder = absolutePath("project.secrets.detectors");
    const files = readdirSync(folder)
        .filter((name) => name.endsWith(DETECTOR_SUFFIX))
        .toSorted((left, right) => left.localeCompare(right));
    await Promise.all(
        files.map(async (name) => {
            await import(pathToFileURL(join(folder, name)).href);
        }),
    );
    const detectors = registeredDetectors();
    const missing = DETECTOR_KINDS.filter((kind) => !detectors.some((detector) => detector.kind === kind));
    if (missing.length > 0) {
        throw new Error(missingDetectors(missing));
    }
    return detectors;
};

export const detectedKinds = function detectedKinds(value: string, detectors: readonly Detector[]): readonly string[] {
    return detectors.filter((detector) => detector.detects(value)).map((detector) => detector.kind);
};
```