Natuurlijk! Hier is een uitgebreide gids voor het maken van een type-veilige gegevensomzetting utility in TypeScript, waarmee je verschillende transformaties voor een `Gebruiker` object kunt afhandelen. Ik zal de stappen, codevoorbeelden en best practices uitleggen. --- ## 1. Stap: Definieer je gegevensmodellen Begin met het specificeren van je gegevensstructuren. Bijvoorbeeld: ```typescript interface Gebruiker { id: number; naam: string; email: string; } ``` Voor transformaties kunnen we ook nieuwe types definiëren, bijvoorbeeld: ```typescript interface GebruikerInDatabase { id: number; naam: string; email: string; laatstAanpassing: Date; } ``` --- ## 2. Stap: Maak een type voor transformaties Definieer een generieke transformatiefunctie die een invoer en uitvoer met verschillende types kan accepteren: ```typescript type Transformatie<I, O> = (input: I) => O; ``` --- ## 3. Stap: Ontwikkel een utility voor transformaties Maak een utility die meerdere transformaties kan toepassen op een object, met behoud van typeveiligheid: ```typescript function applyTransformaties<I, O>( input: I, transformaties: Array<Transformatie<any, any>> ): O { return transformaties.reduce((current, transformatie) => transformatie(current), input) as O; } ``` **Opmerking:** De `as O` cast is nodig omdat TypeScript geen manier heeft om de gecombineerde types automatisch te bepalen zonder meer complexe generics. We kunnen dit verbeteren door een beter type systeem te gebruiken. --- ## 4. Stap 4: Verbeter de typeveiligheid met tuple-types Gebruik tuple-types voor transformaties en een helper om de types automatisch te infereren: ```typescript function composeTransformaties<I, T extends any[]>( input: I, transformaties: [...Transformatie<any, any>[]] ): any { return transformaties.reduce((acc, transformatie) => transformatie(acc), input); } ``` Maar nog beter is het om een **function** te maken die een reeks transformaties accepteert en de types automatisch volgt. --- ## 5. Stap 5: Implementatie met type-safe compose-functie Hier is een voorbeeld van een `compose`-functie die meerdere transformaties combineert en de types automatisch inferreert: ```typescript function compose<I, A>( t1: Transformatie<I, A> ): Transformatie<I, A>; function compose<I, A, B>( t1: Transformatie<I, A>, t2: Transformatie<A, B> ): Transformatie<I, B>; function compose<I, A, B, C>( t1: Transformatie<I, A>, t2: Transformatie<A, B>, t3: Transformatie<B, C> ): Transformatie<I, C>; // Generalisatie function compose(...fns: Transformatie<any, any>[]): Transformatie<any, any> { return (input: any) => fns.reduce((acc, fn) => fn(acc), input); } ``` **Gebruik:** ```typescript const trimNaam: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, naam: user.naam.trim() }); const emailNaarLowercase: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, email: user.email.toLowerCase() }); const transformatieKeten = compose(trimNaam, emailNaarLowercase); const gebruiker: Gebruiker = { id: 1, naam: ' Jan Jansen ', email: 'JAN.JANSEN@EXAMPLE.COM' }; const nieuweGebruiker = transformatieKeten(gebruiker); ``` --- ## 6. Stap 6: Flexibele en herbruikbare utility Wil je een utility die je eenvoudig kunt uitbreiden en hergebruiken? Maak gebruik van generieken en compositie. **Voorbeeld:** ```typescript // Transformatie die de ID verhoogt const verhoogID: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, id: user.id + 1 }); ``` **Gebruik:** ```typescript const transformatie = compose(trimNaam, emailNaarLowercase, verhoogID); const result = transformatie(gebruiker); ``` --- ## 7. Best practices - **Gebruik generieke types** voor maximale flexibiliteit. - **Type inferentie** via overloads van `compose` helpt de juiste types te behouden. - **Immutabiliteit**: werk altijd met nieuwe objecten (`spread operator`) om side-effects te voorkomen. - **Validatie en foutafhandeling**: voeg eventueel validatiestappen toe, afhankelijk van je eisen. - **Documenteer je transformaties** goed, zodat hergebruik en onderhoud makkelijker wordt. --- ## 8. Samenvatting: volledige voorbeeld ```typescript interface Gebruiker { id: number; naam: string; email: string; } type Transformatie<I, O> = (input: I) => O; // Compose functies met overloads function compose<I, A>( t1: Transformatie<I, A> ): Transformatie<I, A>; function compose<I, A, B>( t1: Transformatie<I, A>, t2: Transformatie<A, B> ): Transformatie<I, B>; function compose<I, A, B, C>( t1: Transformatie<I, A>, t2: Transformatie<A, B>, t3: Transformatie<B, C> ): Transformatie<I, C>; function compose(...fns: Transformatie<any, any>[]): Transformatie<any, any> { return (input: any) => fns.reduce((acc, fn) => fn(acc), input); } // Voorbeeld transformaties const trimNaam: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, naam: user.naam.trim() }); const emailNaarLowercase: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, email: user.email.toLowerCase() }); const verhoogID: Transformatie<Gebruiker, Gebruiker> = (user) => ({ ...user, id: user.id + 1 }); // Gebruik const transformatie = compose(trimNaam, emailNaarLowercase, verhoogID); const gebruiker: Gebruiker = { id: 42, naam: ' Jan Jansen ', email: 'JAN.JANSEN@EXAMPLE.COM' }; const nieuweGebruiker = transformatie(gebruiker); console.log(nieuweGebruiker); ``` --- ## Conclusie Door gebruik te maken van generieke types, overloads en functionele composition zorg je dat jouw gegevensomzetting utility flexibel, herbruikbaar en volledig typeveilig blijft in TypeScript. Hierdoor wordt het onderhoud makkelijker en de kans op fouten kleiner. --- Als je verdere vragen hebt of hulp wilt bij het uitbreiden van deze utility, laat het gerust weten!

Zal ik je helpen een type-veilige gegevensomzetting utility te bouwen in TypeScript! Hier is een complete implementatie met gedetailleerde stappen en best practices. ## Stap 1: Basis Type Definitie ```typescript // types.ts export interface Gebruiker { id: number; naam: string; email: string; geboortedatum: string; // ISO string createdAt: string; // ISO string isActief: boolean; metadata?: Record<string, unknown>; } // Transformatie types export type GebruikerTransformatie<T> = (gebruiker: Gebruiker) => T; export type AsyncGebruikerTransformatie<T> = (gebruiker: Gebruiker) => Promise<T>; ``` ## Stap 2: Core Transformatie Utility ```typescript // gebruiker-transformaties.ts import { Gebruiker, GebruikerTransformatie, AsyncGebruikerTransformatie } from './types'; export class GebruikerTransformatieUtility { private transformaties: Array<GebruikerTransformatie<unknown> | AsyncGebruikerTransformatie<unknown>> = []; // Methode om transformaties toe te voegen met type veiligheid voegTransformatieToe<T>(transformatie: GebruikerTransformatie<T>): GebruikerTransformatieUtility { this.transformaties.push(transformatie); return this; // Voor method chaining } voegAsyncTransformatieToe<T>(transformatie: AsyncGebruikerTransformatie<T>): GebruikerTransformatieUtility { this.transformaties.push(transformatie); return this; } // Synchrone transformatie transformeer(gebruiker: Gebruiker): unknown[] { return this.transformaties.map(transformatie => { if (this.isAsyncTransformatie(transformatie)) { throw new Error('Async transformatie gevonden in synchrone context'); } return transformatie(gebruiker); }); } // Asynchrone transformatie async transformeerAsync(gebruiker: Gebruiker): Promise<unknown[]> { const resultaten: unknown[] = []; for (const transformatie of this.transformaties) { if (this.isAsyncTransformatie(transformatie)) { resultaten.push(await transformatie(gebruiker)); } else { resultaten.push(transformatie(gebruiker)); } } return resultaten; } private isAsyncTransformatie( transformatie: GebruikerTransformatie<unknown> | AsyncGebruikerTransformatie<unknown> ): transformatie is AsyncGebruikerTransformatie<unknown> { return transformatie.constructor.name === 'AsyncFunction' || transformatie.toString().includes('async'); } } ``` ## Stap 3: Vooraf Gedefinieerde Transformations ```typescript // vooraf-gedefinieerde-transformaties.ts import { Gebruiker } from './types'; // Basis transformaties export const naarNaamEmail = (gebruiker: Gebruiker): { naam: string; email: string } => ({ naam: gebruiker.naam, email: gebruiker.email }); export const naarLeeftijd = (gebruiker: Gebruiker): { leeftijd: number } => { const geboorteJaar = new Date(gebruiker.geboortedatum).getFullYear(); const huidigJaar = new Date().getFullYear(); return { leeftijd: huidigJaar - geboorteJaar }; }; export const naarActieveStatus = (gebruiker: Gebruiker): { isActief: boolean; status: string } => ({ isActief: gebruiker.isActief, status: gebruiker.isActief ? 'Actief' : 'Inactief' }); // Complexe transformatie met validatie export const naarGebruikerSamenvatting = (gebruiker: Gebruiker): { id: number; volledigeNaam: string; email: string; leeftijd: number; status: string; } => { const leeftijd = new Date().getFullYear() - new Date(gebruiker.geboortedatum).getFullYear(); return { id: gebruiker.id, volledigeNaam: gebruiker.naam.trim(), email: gebruiker.email.toLowerCase(), leeftijd, status: gebruiker.isActief ? 'Actief' : 'Inactief' }; }; // Async transformatie (bijv. voor API calls) export const naarVerrijkteGebruiker = async (gebruiker: Gebruiker): Promise<{ gebruiker: Gebruiker; extraData: { avatarUrl: string; laatsteLogin: string } }> => { // Simuleer async operatie const extraData = await fetchExtraGebruikerData(gebruiker.id); return { gebruiker, extraData: { avatarUrl: `https://avatar.service/${gebruiker.email}`, laatsteLogin: extraData.laatsteLogin } }; }; async function fetchExtraGebruikerData(gebruikerId: number): Promise<{ laatsteLogin: string }> { // Simuleer API call return new Promise(resolve => { setTimeout(() => { resolve({ laatsteLogin: new Date().toISOString() }); }, 100); }); } ``` ## Stap 4: Type-Safe Builder Pattern ```typescript // type-safe-builder.ts import { Gebruiker } from './types'; type TransformatieResultaat<T> = { [K in keyof T]: T[K]; }; export class TypeSafeGebruikerTransformer<T = {}> { private transformaties: Array<(gebruiker: Gebruiker) => any> = []; voegTransformatieToe<U>( transformatie: (gebruiker: Gebruiker) => U ): TypeSafeGebruikerTransformer<T & U> { this.transformaties.push(transformatie); return this as any; } transformeer(gebruiker: Gebruiker): TransformatieResultaat<T> { return this.transformaties.reduce((resultaat, transformatie) => { return { ...resultaat, ...transformatie(gebruiker) }; }, {} as T); } // Batch transformatie transformeerMeerdere(gebruikers: Gebruiker[]): TransformatieResultaat<T>[] { return gebruikers.map(gebruiker => this.transformeer(gebruiker)); } } ``` ## Stap 5: Gebruiksvoorbeelden ```typescript // gebruik-voorbeelden.ts import { GebruikerTransformatieUtility } from './gebruiker-transformaties'; import { TypeSafeGebruikerTransformer } from './type-safe-builder'; import { naarNaamEmail, naarLeeftijd, naarActieveStatus, naarGebruikerSamenvatting, naarVerrijkteGebruiker } from './vooraf-gedefinieerde-transformaties'; // Voorbeeld gebruiker const voorbeeldGebruiker: Gebruiker = { id: 1, naam: "Jan Jansen", email: "jan@voorbeeld.nl", geboortedatum: "1990-05-15", createdAt: "2023-01-01T10:00:00Z", isActief: true, metadata: { voorkeuren: { thema: "donker" } } }; // 1. Basis gebruik utility const utility = new GebruikerTransformatieUtility() .voegTransformatieToe(naarNaamEmail) .voegTransformatieToe(naarLeeftijd) .voegTransformatieToe(naarActieveStatus); const resultaten = utility.transformeer(voorbeeldGebruiker); console.log(resultaten); // 2. Async transformatie async function asyncVoorbeeld() { const asyncUtility = new GebruikerTransformatieUtility() .voegTransformatieToe(naarGebruikerSamenvatting) .voegAsyncTransformatieToe(naarVerrijkteGebruiker); const asyncResultaten = await asyncUtility.transformeerAsync(voorbeeldGebruiker); console.log(asyncResultaten); } // 3. Type-safe builder pattern const typeSafeTransformer = new TypeSafeGebruikerTransformer() .voegTransformatieToe(naarNaamEmail) .voegTransformatieToe(naarLeeftijd) .voegTransformatieToe(naarActieveStatus); // TypeScript weet nu het exacte return type! const typeSafeResultaat = typeSafeTransformer.transformeer(voorbeeldGebruiker); console.log(typeSafeResultaat.naam); // TypeScript autocomplete werkt! console.log(typeSafeResultaat.leeftijd); // TypeScript autocomplete werkt! console.log(typeSafeResultaat.status); // TypeScript autocomplete werkt! // 4. Batch transformatie const gebruikers: Gebruiker[] = [ voorbeeldGebruiker, { ...voorbeeldGebruiker, id: 2, naam: "Piet Pietersen" } ]; const batchResultaten = typeSafeTransformer.transformeerMeerdere(gebruikers); console.log(batchResultaten); ``` ## Stap 6: Geavanceerde Features & Best Practices ```typescript // geavanceerde-features.ts import { Gebruiker } from './types'; // 1. Transformatie met error handling export const createVeiligeTransformatie = <T>( transformatie: (gebruiker: Gebruiker) => T, fallback: T ): ((gebruiker: Gebruiker) => T) => { return (gebruiker: Gebruiker) => { try { return transformatie(gebruiker); } catch (error) { console.error('Transformatie mislukt:', error); return fallback; } }; }; // 2. Transformatie compositie export const composeTransformaties = <T, U, V>( eerste: (gebruiker: Gebruiker) => T, tweede: (input: T) => U, derde: (input: U) => V ): ((gebruiker: Gebruiker) => V) => { return (gebruiker: Gebruiker) => derde(tweede(eerste(gebruiker))); }; // 3. Conditional transformatie export const createConditionalTransformatie = <T>( conditie: (gebruiker: Gebruiker) => boolean, waarTransformatie: (gebruiker: Gebruiker) => T, onwaarTransformatie: (gebruiker: Gebruiker) => T ): ((gebruiker: Gebruiker) => T) => { return (gebruiker: Gebruiker) => { return conditie(gebruiker) ? waarTransformatie(gebruiker) : onwaarTransformatie(gebruiker); }; }; // 4. Validatie transformatie export const metValidatie = <T>( transformatie: (gebruiker: Gebruiker) => T, validator: (resultaat: T) => boolean ): ((gebruiker: Gebruiker) => T) => { return (gebruiker: Gebruiker) => { const resultaat = transformatie(gebruiker); if (!validator(resultaat)) { throw new Error('Transformatie resultaat voldoet niet aan validatie'); } return resultaat; }; }; ``` ## Best Practices 1. **Type Safety**: Gebruik generics voor maximale type veiligheid 2. **Immutability**: Transformeer data zonder de originele data te muteren 3. **Error Handling**: Implementeer robuuste error handling 4. **Composability**: Maak transformaties herbruikbaar en composeerbaar 5. **Performance**: Gebruik efficiente data structuren voor grote datasets 6. **Testing**: Schrijf unit tests voor alle transformaties 7. **Documentation**: Documenteer complexe transformaties met JSDoc ```typescript // testing-voorbeeld.ts import { describe, it, expect } from 'vitest'; // of jest describe('GebruikerTransformatieUtility', () => { it('moet meerdere transformaties correct uitvoeren', () => { const utility = new GebruikerTransformatieUtility() .voegTransformatieToe(naarNaamEmail) .voegTransformatieToe(naarLeeftijd); const resultaten = utility.transformeer(voorbeeldGebruiker); expect(resultaten).toHaveLength(2); expect(resultaten[0]).toEqual({ naam: voorbeeldGebruiker.naam, email: voorbeeldGebruiker.email }); }); }); ``` Deze implementatie biedt een flexibele, type-veilige foundation voor gebruikerstransformaties die je kunt uitbreiden naar jouw specifieke use cases!