Die TypeScript-Intervention: Durchbrechen Sie Ihre Sucht nach Laufzeitprüfungen mit Byzantium

Schauen Sie, wir müssen über Ihre Sucht nach Typprüfung sprechen. Ja, Sie – derjenige mit 47 Instanzen von Prüfungen in Ihrer Authentifizierungs-Middleware. Der Entwickler, der mehr Testfälle als tatsächlichen Code schreibt. Derjenige, der TypeScript so behandelt, als wären es nur ausgefallene JSDoc-Kommentare.

Die Intervention

Lass mich dir ein Bild malen: Es ist Mittag, du trinkst deine vierte Tasse Kaffee und behebst ein Produktionsproblem. Die Protokolle zeigen, dass ein Benutzer Ihre fünfzehn Ebenen der Laufzeitvalidierung irgendwie überwunden hat. Sie haben mehr Unit-Tests, als Twitter aktive Benutzer hat, aber irgendwie, irgendwie, ist es jemandem gelungen, eine Zahl an die Stelle zu senden, an der sich eine Zeichenfolge befinden sollte.

„Aber das ist unmöglich!“ Sie weinen und scrollen durch Ihren Testabdeckungsbericht, der makellose 100 % zeigt. „Das habe ich überprüft!“

Hast du das aber? Hast du wirklich? Oder haben Sie einfach dreimal denselben Scheck ausgestellt:

1. Einmal in TypeScript-Schnittstellen
2. Wieder in Ihrer Validierungs-Middleware
3. Und noch einmal in Ihren Unit-Tests

Hören Sie auf zu testen, was TypeScript bereits weiß

Hier ist eine revolutionäre Idee: Was wäre, wenn wir einfach... dem Compiler vertrauen würden? Ich weiß, wildes Konzept. Aber hör mir zu.

interface ValidRabbit {
    username: string;
    password: string;
}
interface InvalidRabbit {
    username: number;
    password: string;
}


type ValidateRabbit<Rabbit> = Assert<
    //assert that Rabbit is of type {username, password}
    Is.Type<
        User,
        {
            username: string;
            password: string;
        }
    >,
    //custom compile time exceptions
    "Trix are for kids. Provide a username and password.",
    User
>;

// Ha! Silly Rabbit...
function checkRabbit<T>(rabbit: ValidateRabbit<T>) {
    // .... protect your trix
}

declare const rabbit1: ValidRabbit;
declare const rabbit2: InvalidRabbit;

checkRabbit(rabbit1);
checkRabbit(rabbit2);
/**        ~~~~~~~~~
 *           └───── Type Exception! "...Provide a username and password"
 */

„Aber was ist mit der Produktion?“

Ich kann Sie jetzt hören: „Aber was ist, wenn jemand ungültiges JSON an meine API sendet?“

Zuallererst: Wer hat dir wehgetan? Zweitens: Ja, validieren Sie Ihre API-Grenzen. Aber sobald diese Daten in Ihre TypeScript-Domäne gelangen, ist es Zeit loszulassen. Lassen Sie den Compiler Ihr Türsteher sein.

Das bringt Byzanz zu Ihrer Treuhandparty:

// Define your trust boundaries
type APIRequest<Request> = Assert<
    And<
    Is.On<Request, "body">,
    Or<Is.In<Request["method"], "POST">, Is.In<Request["method"], "PUT">>
>;,
    "Someone's being naughty with our API"
>;

// Now everything inside is type-safe
function handleRequest<R>(req: APIRequest<R>) {
    // If it compiles, it's valid
    // If it's valid, it compiles
    // This is the way
}

Das DevOps-Team wird Sie (ausnahmsweise) lieben

Stellen Sie sich Folgendes vor: Ihre CI/CD-Pipeline ist in Minuten statt in Stunden fertig. Ihre Produktionsprotokolle sind nicht mit Typfehlern gefüllt. Ihre AWS-Rechnung sieht nicht wie eine Telefonnummer aus.

Wie? Weil Byzantium Ihre Typprüfung in die Kompilierungszeit verlagert. Nicht mehr:

• Tausende von Unit-Tests ausführen, die nur Typen überprüfen
• Es werden CPU-Zyklen verbraucht, wobei immer wieder dieselben Typen überprüft werden
• Um 3 Uhr morgens aufgewacht, weil jemand undefiniert an eine Funktion übergeben hat, die eindeutig angab, dass sie einen String benötigt

// Before: Your CPU crying for help
function validateUserMiddleware(req, res, next) {
    try {
        validateId(req.params.id)        // CPU cycle
        validateBody(req.body)           // CPU cycle
        validatePermissions(req.user)    // CPU cycle
        validateToken(req.headers.auth)  // CPU cycle
        // Your CPU is now considering a career change
        next()
    } catch (e) {
        res.status(400).json({ error: e.message })
    }
}

// After: Your CPU sending you a thank you note
type ValidRequest = Assert<
    And<
        Is.On<Request, 'params.id'>,
        Is.On<Request, 'body'>,
        Is.On<Request, 'user'>,
        Is.On<Request, 'headers.auth'>
    >,
    "Invalid request shape"
>;

function handleRequest(req: ValidRequest) {
    // Just business logic, no trust issues
}

„Aber ich liebe es, Tests zu schreiben!“

Großartig! Schreiben Sie Tests für Dinge, die tatsächlich getestet werden müssen:

• Geschäftslogik
• Integrationspunkte
• Benutzerworkflows
• Komplexe Algorithmen

Wissen Sie, was nicht getestet werden muss? Ob ein String tatsächlich ein String ist. Lassen Sie TypeScript diese existenzielle Krise bewältigen.

Real Talk: Die Vorteile

1. Schnellere Entwicklung

   • Kein Schreiben derselben Validierung mehr auf drei verschiedene Arten
   • Fehler zur Kompilierungszeit abfangen, nicht um 3 Uhr morgens
   • Verbringen Sie Zeit mit Funktionen, nicht mit Validierungs-Boilerplate

2. Bessere Leistung

   • Kein Laufzeitaufwand für die Typprüfung
   • Kleinere Bundle-Größen (keine Validierungsbibliotheken)
   • Glückliche CPUs, glückliches Leben

3. Verbesserte Sicherheit

   • Garantien auf Typebene können nicht umgangen werden
   • Kein „Ups, ich habe vergessen, das zu bestätigen“ mehr
   • Vollständige Abdeckung standardmäßig

4. DevOps-Träume

   • Schnellere CI/CD-Pipelines
   • Geringere Infrastrukturkosten
   • Weniger Produktionsvorfälle
   • Zufriedeneres SRE-Team (Ergebnisse können variieren)

Erste Schritte

interface ValidRabbit {
    username: string;
    password: string;
}
interface InvalidRabbit {
    username: number;
    password: string;
}


type ValidateRabbit<Rabbit> = Assert<
    //assert that Rabbit is of type {username, password}
    Is.Type<
        User,
        {
            username: string;
            password: string;
        }
    >,
    //custom compile time exceptions
    "Trix are for kids. Provide a username and password.",
    User
>;

// Ha! Silly Rabbit...
function checkRabbit<T>(rabbit: ValidateRabbit<T>) {
    // .... protect your trix
}

declare const rabbit1: ValidRabbit;
declare const rabbit2: InvalidRabbit;

checkRabbit(rabbit1);
checkRabbit(rabbit2);
/**        ~~~~~~~~~
 *           └───── Type Exception! "...Provide a username and password"
 */

Die Wahl liegt bei Ihnen

Sie können weiterhin in Angst leben, Laufzeitprüfungen für alles schreiben und TypeScript wie optionale Eingabe für JavaScript behandeln.

Oder Sie kommen 2024 zu uns, wo wir unserem Compiler vertrauen und ihn seine Arbeit machen lassen.

Denken Sie daran: Jedes Mal, wenn Sie eine Laufzeit-Typprüfung schreiben, schreit irgendwo ein TypeScript-Compiler.

Abschluss

Byzantium ist nicht nur eine weitere Bibliothek – es ist eine Lösung für Ihre Vertrauensprobleme mit Typen. Es ist an der Zeit, die Laufzeitprüfungen hinter sich zu lassen und die Leistungsfähigkeit von Garantien zur Kompilierungszeit zu nutzen.

Ihre CPU wird es Ihnen danken. Ihr DevOps-Team wird es Ihnen danken. Ihre Benutzer werden es Ihnen danken (indem sie keine typbezogenen Fehler finden).

Und das Wichtigste: Sie werden sich um 3 Uhr morgens bedanken, wenn Sie tief und fest schlafen, anstatt Tippfehler in der Produktion zu debuggen.

---

P.S. Wenn Sie immer noch nicht überzeugt sind, versuchen Sie zu zählen, wie viele Laufzeittypprüfungen Sie in Ihrer Codebasis haben. Dann multiplizieren Sie das mit Ihrem Stundensatz. So viel Zeit verbringen Sie damit, TypeScript nicht zu vertrauen.

P.P.S. Bei der Erstellung dieses Blogbeitrags wurden keine Personen geschädigt. Allerdings wurden mehrere Laufzeitprüfungen endgültig eingestellt.

*P.P.P.S. Wenn Sie einen Beitrag leisten möchten, schauen Sie auf meinem Github vorbei und klonen Sie das Repo. Alles ist noch frisch, also viele Möglichkeiten, etwas beizutragen.

Dokumente und Paket verfügbar auf JSR.io

Das obige ist der detaillierte Inhalt vonDie TypeScript-Intervention: Durchbrechen Sie Ihre Sucht nach Laufzeitprüfungen mit Byzantium. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!