1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// Simplified model of production connection pool (e.g., pg-pool, HikariCP)
 
interface Connection {
    query(sql: string, params?: any[]): Promise<QueryResult>;
    isAlive(): boolean;
    reset(): Promise<void>;
    close(): Promise<void>;
}
 
interface PoolConfig {
    host: string;
    port: number;
    database: string;
    user: string;
    password: string;
    minConnections: number;   // Keep this many warm
    maxConnections: number;   // Never exceed this
    idleTimeoutMs: number;    // Close idle connections after this
    acquireTimeoutMs: number; // Max wait time for connection
}
 
class ConnectionPool {
    private available: Connection[] = [];
    private inUse: Set<Connection> = new Set();
    private waitQueue: Array<{
        resolve: (conn: Connection) => void;
        reject: (err: Error) => void;
        timeout: NodeJS.Timeout;
    }> = [];
    
    constructor(private config: PoolConfig) {
        // Pre-warm minimum connections
        this.warmUp();
        // Start idle connection reaper
        this.startReaper();
    }
    
    private async warmUp(): Promise<void> {
        for (let i = 0; i < this.config.minConnections; i++) {
            const conn = await this.createConnection();
            this.available.push(conn);
        }
    }
    
    private async createConnection(): Promise<Connection> {
        // Expensive operation - TCP connect, auth, etc.
        return connectToDatabase({
            host: this.config.host,
            port: this.config.port,
            database: this.config.database,
            user: this.config.user,
            password: this.config.password,
        });
    }
    
    async acquire(): Promise<Connection> {
        // Try to get available connection
        while (this.available.length > 0) {
            const conn = this.available.pop()!;
            if (conn.isAlive()) {
                this.inUse.add(conn);
                return conn;
            }
            // Dead connection - discard and continue
            await conn.close().catch(() => {});
        }
        
        // No available connections - can we create new?
        const totalConnections = this.available.length + this.inUse.size;
        if (totalConnections < this.config.maxConnections) {
            const conn = await this.createConnection();
            this.inUse.add(conn);
            return conn;
        }
        
        // At max - wait for return
        return new Promise((resolve, reject) => {
            const timeout = setTimeout(() => {
                const index = this.waitQueue.findIndex(w => w.resolve === resolve);
                if (index !== -1) {
                    this.waitQueue.splice(index, 1);
                }
                reject(new Error('Connection acquire timeout'));
            }, this.config.acquireTimeoutMs);
            
            this.waitQueue.push({ resolve, reject, timeout });
        });
    }
    
    async release(conn: Connection): Promise<void> {
        if (!this.inUse.has(conn)) {
            throw new Error('Connection not owned by this pool');
        }
        
        this.inUse.delete(conn);
        
        // Reset connection state before returning to pool
        await conn.reset();
        
        // If someone is waiting, give to them
        if (this.waitQueue.length > 0) {
            const waiter = this.waitQueue.shift()!;
            clearTimeout(waiter.timeout);
            this.inUse.add(conn);
            waiter.resolve(conn);
            return;
        }
        
        // Otherwise return to available
        this.available.push(conn);
    }
    
    // Helper for automatic release
    async withConnection<T>(fn: (conn: Connection) => Promise<T>): Promise<T> {
        const conn = await this.acquire();
        try {
            return await fn(conn);
        } finally {
            await this.release(conn);
        }
    }
    
    private startReaper(): void {
        setInterval(() => {
            const now = Date.now();
            // Close idle connections beyond minimum
            while (
                this.available.length > this.config.minConnections &&
                /* connection is idle too long */
                true
            ) {
                const conn = this.available.shift()!;
                conn.close().catch(() => {});
            }
        }, 30000);
    }
}
 
// Usage - clean abstraction
const pool = new ConnectionPool(config);
 
// Auto-release pattern
const users = await pool.withConnection(async (conn) => {
    return conn.query('SELECT * FROM users WHERE active = $1', [true]);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Game engine entity spawning system - Prototype + Factory
 
interface EntityPrototype {
    clone(): Entity;
    warmUp(): Promise<void>;  // Pre-load resources
}
 
class Entity {
    mesh: Mesh;
    material: Material;
    animations: Map<string, Animation>;
    components: Component[];
    
    constructor(
        mesh: Mesh,
        material: Material,
        animations: Map<string, Animation>,
        components: Component[]
    ) {
        this.mesh = mesh;
        this.material = material;
        this.animations = new Map(animations);  // Shallow copy OK - immutable
        this.components = components.map(c => c.clone());  // Deep copy - mutable state
    }
    
    setPosition(pos: Vector3): void { /* ... */ }
    setRotation(rot: Quaternion): void { /* ... */ }
}
 
// Pre-configured prototype - resources loaded once
class GoblinPrototype implements EntityPrototype {
    private mesh: Mesh | null = null;
    private material: Material | null = null;
    private animations: Map<string, Animation> = new Map();
    private baseComponents: Component[] = [];
    
    async warmUp(): Promise<void> {
        // Load heavy resources ONCE
        this.mesh = await loadMesh('assets/goblin/goblin.obj');
        this.material = await loadMaterial('assets/goblin/goblin.mat');
        
        const animBundle = await loadAnimations('assets/goblin/animations.bundle');
        for (const anim of animBundle) {
            this.animations.set(anim.name, anim);
        }
        
        // Configure base components
        this.baseComponents = [
            new HealthComponent(100),
            new AIComponent(new GoblinBehaviorTree()),
            new CombatComponent({ attackDamage: 15, attackSpeed: 1.2 }),
        ];
    }
    
    clone(): Entity {
        if (!this.mesh) throw new Error('Prototype not warmed up');
        
        // Fast! No loading, just copy/reference
        return new Entity(
            this.mesh,        // Shared (immutable)
            this.material,    // Shared (immutable)
            this.animations,  // Shallow copy (immutable)
            this.baseComponents  // Deep copied in Entity constructor
        );
    }
}
 
// Factory provides clean API and manages prototypes
class EntityFactory {
    private prototypes: Map<string, EntityPrototype> = new Map();
    private loading: Map<string, Promise<void>> = new Map();
    
    async registerPrototype(type: string, prototype: EntityPrototype): Promise<void> {
        if (this.loading.has(type)) {
            await this.loading.get(type);
            return;
        }
        
        const warmUpPromise = prototype.warmUp();
        this.loading.set(type, warmUpPromise);
        
        await warmUpPromise;
        this.prototypes.set(type, prototype);
        this.loading.delete(type);
    }
    
    spawn(type: string, position: Vector3, rotation?: Quaternion): Entity {
        const prototype = this.prototypes.get(type);
        if (!prototype) {
            throw new Error(`Unknown entity type: ${type}. Did you call registerPrototype?`);
        }
        
        const entity = prototype.clone();
        entity.setPosition(position);
        if (rotation) {
            entity.setRotation(rotation);
        }
        return entity;
    }
    
    // Batch spawn for particle systems, etc.
    spawnMany(type: string, count: number, positionFn: (i: number) => Vector3): Entity[] {
        const prototype = this.prototypes.get(type);
        if (!prototype) throw new Error(`Unknown: ${type}`);
        
        const entities: Entity[] = [];
        for (let i = 0; i < count; i++) {
            const entity = prototype.clone();
            entity.setPosition(positionFn(i));
            entities.push(entity);
        }
        return entities;
    }
}
 
// Usage in game loop
async function initializeGame() {
    const entityFactory = new EntityFactory();
    
    // Register prototypes at load time
    await Promise.all([
        entityFactory.registerPrototype('goblin', new GoblinPrototype()),
        entityFactory.registerPrototype('orc', new OrcPrototype()),
        entityFactory.registerPrototype('arrow', new ProjectilePrototype('arrow')),
        entityFactory.registerPrototype('fireball', new ProjectilePrototype('fireball')),
    ]);
    
    return entityFactory;
}
 
// In gameplay - spawning is now FAST
function onEnemyWaveTriggered(factory: EntityFactory, waveConfig: WaveConfig) {
    for (const spawn of waveConfig.spawns) {
        const entity = factory.spawn(spawn.type, spawn.position);
        world.addEntity(entity);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// React's createElement - Factory Method in disguise
 
// The conceptual interface
interface ReactElement<P = any> {
    type: string | ComponentType<P>;
    props: P;
    key: string | null;
}
 
interface ComponentType<P = {}> {
    (props: P): ReactElement | null;  // Function component
}
 
// React.createElement - a factory method
function createElement<P>(
    type: string | ComponentType<P>,
    props: P | null,
    ...children: ReactNode[]
): ReactElement<P> {
    return {
        type,
        props: {
            ...props,
            children: children.length > 0 ? children : undefined,
        } as P,
        key: props?.key ?? null,
    };
}
 
// Higher-Order Component - Factory that creates enhanced factories
function withLogger<P extends object>(
    WrappedComponent: ComponentType<P>
): ComponentType<P> {
    return function LoggedComponent(props: P): ReactElement {
        console.log(`Rendering ${WrappedComponent.name}`, props);
        
        // Factory method - returns element, doesn't know implementation
        return createElement(WrappedComponent, props);
    };
}
 
// Custom component - defines WHAT is created
function Button({ label, onClick }: ButtonProps): ReactElement {
    return createElement('button', { onClick }, label);
}
 
// Usage - factory method pattern in action
const element = createElement(Button, { label: 'Click me', onClick: handleClick });
 
// Framework renders - creates actual DOM elements from ReactElement descriptions
 
 
// === More explicit Abstract Factory in UI frameworks ===
 
// Theme-based component factory (Abstract Factory pattern)
interface ThemeFactory {
    createButton(props: ButtonProps): ReactElement;
    createInput(props: InputProps): ReactElement;
    createCard(props: CardProps): ReactElement;
}
 
class MaterialThemeFactory implements ThemeFactory {
    createButton(props: ButtonProps): ReactElement {
        return createElement(MaterialButton, {
            ...props,
            ripple: true,
            elevation: 2,
        });
    }
    
    createInput(props: InputProps): ReactElement {
        return createElement(MaterialInput, {
            ...props,
            variant: 'outlined',
            floatingLabel: true,
        });
    }
    
    createCard(props: CardProps): ReactElement {
        return createElement(MaterialCard, {
            ...props,
            elevation: 4,
        });
    }
}
 
class MinimalThemeFactory implements ThemeFactory {
    createButton(props: ButtonProps): ReactElement {
        return createElement(MinimalButton, {
            ...props,
            borderRadius: 0,
        });
    }
    
    createInput(props: InputProps): ReactElement {
        return createElement(MinimalInput, {
            ...props,
            underlineOnly: true,
        });
    }
    
    createCard(props: CardProps): ReactElement {
        return createElement(MinimalCard, {
            ...props,
            border: '1px solid',
        });
    }
}
 
// Theming via React Context - inject Abstract Factory
const ThemeFactoryContext = React.createContext<ThemeFactory>(new MaterialThemeFactory());
 
function Form() {
    const themeFactory = useContext(ThemeFactoryContext);
    
    return (
        <form>
            {themeFactory.createInput({ label: 'Email', type: 'email' })}
            {themeFactory.createInput({ label: 'Password', type: 'password' })}
            {themeFactory.createButton({ label: 'Sign In', type: 'submit' })}
        </form>
    );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

// Production-style logging system combining Factory + Builder + Decorator
 
interface Logger {
    debug(message: string, meta?: object): void;
    info(message: string, meta?: object): void;
    warn(message: string, meta?: object): void;
    error(message: string, meta?: object): void;
    child(context: object): Logger;  // Create child logger with added context
}
 
interface Transport {
    log(entry: LogEntry): void;
}
 
// Core implementation
class BaseLogger implements Logger {
    constructor(
        private context: object,
        private transports: Transport[],
        private minLevel: LogLevel
    ) {}
    
    private log(level: LogLevel, message: string, meta?: object): void {
        if (level < this.minLevel) return;
        
        const entry: LogEntry = {
            timestamp: new Date().toISOString(),
            level,
            message,
            ...this.context,
            ...meta,
        };
        
        for (const transport of this.transports) {
            transport.log(entry);
        }
    }
    
    debug(message: string, meta?: object): void { this.log(LogLevel.DEBUG, message, meta); }
    info(message: string, meta?: object): void { this.log(LogLevel.INFO, message, meta); }
    warn(message: string, meta?: object): void { this.log(LogLevel.WARN, message, meta); }
    error(message: string, meta?: object): void { this.log(LogLevel.ERROR, message, meta); }
    
    child(context: object): Logger {
        return new BaseLogger(
            { ...this.context, ...context },
            this.transports,
            this.minLevel
        );
    }
}
 
// BUILDER: Configures complex logger instances
class LoggerBuilder {
    private transports: Transport[] = [];
    private minLevel: LogLevel = LogLevel.INFO;
    private context: object = {};
    
    setLevel(level: LogLevel): this {
        this.minLevel = level;
        return this;
    }
    
    addContext(context: object): this {
        this.context = { ...this.context, ...context };
        return this;
    }
    
    addConsoleTransport(options?: ConsoleOptions): this {
        this.transports.push(new ConsoleTransport(options));
        return this;
    }
    
    addFileTransport(path: string, options?: FileOptions): this {
        this.transports.push(new FileTransport(path, options));
        return this;
    }
    
    addCloudTransport(config: CloudConfig): this {
        // DECORATOR: Wrap with batching for performance
        const baseTransport = new CloudTransport(config);
        const batchedTransport = new BatchingDecorator(baseTransport, {
            batchSize: 100,
            flushInterval: 5000,
        });
        this.transports.push(batchedTransport);
        return this;
    }
    
    build(): Logger {
        if (this.transports.length === 0) {
            this.addConsoleTransport();  // Default
        }
        return new BaseLogger(this.context, this.transports, this.minLevel);
    }
}
 
// FACTORY: Creates loggers by category
class LoggerFactory {
    private rootLogger: Logger;
    private loggers: Map<string, Logger> = new Map();
    
    constructor(rootLogger: Logger) {
        this.rootLogger = rootLogger;
    }
    
    getLogger(category: string): Logger {
        if (this.loggers.has(category)) {
            return this.loggers.get(category)!;
        }
        
        // Create child logger with category context
        const logger = this.rootLogger.child({ category });
        this.loggers.set(category, logger);
        return logger;
    }
    
    // Static factory method for convenience
    static create(configure: (builder: LoggerBuilder) => void): LoggerFactory {
        const builder = new LoggerBuilder();
        configure(builder);
        const rootLogger = builder.build();
        return new LoggerFactory(rootLogger);
    }
}
 
// DECORATOR: Adds batching behavior to transports
class BatchingDecorator implements Transport {
    private batch: LogEntry[] = [];
    private timer: NodeJS.Timer | null = null;
    
    constructor(
        private wrapped: Transport,
        private options: { batchSize: number; flushInterval: number }
    ) {
        this.startTimer();
    }
    
    log(entry: LogEntry): void {
        this.batch.push(entry);
        if (this.batch.length >= this.options.batchSize) {
            this.flush();
        }
    }
    
    private flush(): void {
        if (this.batch.length === 0) return;
        
        const entries = this.batch;
        this.batch = [];
        
        // Send batch to wrapped transport
        for (const entry of entries) {
            this.wrapped.log(entry);
        }
    }
    
    private startTimer(): void {
        this.timer = setInterval(() => this.flush(), this.options.flushInterval);
    }
}
 
// Usage
const loggerFactory = LoggerFactory.create(builder => {
    builder
        .setLevel(process.env.LOG_LEVEL === 'debug' ? LogLevel.DEBUG : LogLevel.INFO)
        .addContext({ service: 'api-server', env: process.env.NODE_ENV })
        .addConsoleTransport({ colorize: true })
        .addFileTransport('./logs/app.log', { maxSize: '10mb', maxFiles: 5 })
        .addCloudTransport({ endpoint: process.env.LOG_ENDPOINT });
});
 
// In services - get category-specific logger
class UserService {
    private logger = loggerFactory.getLogger('UserService');
    
    async createUser(data: CreateUserDTO): Promise<User> {
        this.logger.info('Creating user', { email: data.email });
        // ...
        this.logger.debug('User created', { userId: user.id });
        return user;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

// AWS SDK v3-style client builder
 
interface S3ClientConfig {
    region?: string;
    endpoint?: string;
    credentials?: CredentialProvider;
    retryMode?: 'standard' | 'adaptive';
    maxAttempts?: number;
    requestHandler?: HttpHandler;
    logger?: Logger;
}
 
// Immutable configuration object - Builder produces this
class S3Client {
    private readonly config: Required<S3ClientConfig>;
    
    constructor(config: S3ClientConfig) {
        // Resolve defaults
        this.config = {
            region: config.region ?? process.env.AWS_REGION ?? 'us-east-1',
            endpoint: config.endpoint ?? `https://s3.${config.region}.amazonaws.com`,
            credentials: config.credentials ?? defaultCredentialChain(),
            retryMode: config.retryMode ?? 'standard',
            maxAttempts: config.maxAttempts ?? 3,
            requestHandler: config.requestHandler ?? new FetchHttpHandler(),
            logger: config.logger ?? console,
        };
    }
    
    async putObject(input: PutObjectInput): Promise<PutObjectOutput> { /* ... */ }
    async getObject(input: GetObjectInput): Promise<GetObjectOutput> { /* ... */ }
    async deleteObject(input: DeleteObjectInput): Promise<DeleteObjectOutput> { /* ... */ }
}
 
// BUILDER: Fluent configuration with validation
class S3ClientBuilder {
    private config: S3ClientConfig = {};
    
    region(region: string): this {
        this.config.region = region;
        return this;
    }
    
    endpoint(endpoint: string): this {
        this.config.endpoint = endpoint;
        return this;
    }
    
    credentials(provider: CredentialProvider): this {
        this.config.credentials = provider;
        return this;
    }
    
    // Convenience methods for common credential types
    withStaticCredentials(accessKeyId: string, secretAccessKey: string): this {
        this.config.credentials = {
            accessKeyId,
            secretAccessKey,
        };
        return this;
    }
    
    withIAMRole(roleArn: string): this {
        this.config.credentials = new STSAssumeRoleCredentialProvider({
            roleArn,
            roleSessionName: 'sdk-session',
        });
        return this;
    }
    
    retryMode(mode: 'standard' | 'adaptive'): this {
        this.config.retryMode = mode;
        return this;
    }
    
    maxAttempts(attempts: number): this {
        if (attempts < 1 || attempts > 10) {
            throw new Error('maxAttempts must be between 1 and 10');
        }
        this.config.maxAttempts = attempts;
        return this;
    }
    
    // Custom HTTP handler for proxy, custom TLS, etc.
    requestHandler(handler: HttpHandler): this {
        this.config.requestHandler = handler;
        return this;
    }
    
    // Logging integration
    logger(logger: Logger): this {
        this.config.logger = logger;
        return this;
    }
    
    // Connect to LocalStack/MinIO for testing
    forLocalDevelopment(endpoint: string = 'http://localhost:4566'): this {
        this.config.endpoint = endpoint;
        this.config.credentials = {
            accessKeyId: 'test',
            secretAccessKey: 'test',
        };
        return this;
    }
    
    build(): S3Client {
        // Validation before build
        if (!this.config.region && !this.config.endpoint) {
            throw new Error('Either region or explicit endpoint must be specified');
        }
        
        return new S3Client(this.config);
    }
}
 
// Factory convenience for common configurations
class S3ClientFactory {
    static forRegion(region: string): S3Client {
        return new S3ClientBuilder().region(region).build();
    }
    
    static forLocalDevelopment(): S3Client {
        return new S3ClientBuilder().forLocalDevelopment().build();
    }
    
    static customBuilder(): S3ClientBuilder {
        return new S3ClientBuilder();
    }
}
 
// Usage examples
// Simple: Factory for common case
const s3Simple = S3ClientFactory.forRegion('us-west-2');
 
// Complex: Builder for full customization
const s3Custom = S3ClientFactory.customBuilder()
    .region('eu-west-1')
    .withIAMRole('arn:aws:iam::123456789:role/S3AccessRole')
    .retryMode('adaptive')
    .maxAttempts(5)
    .logger(applicationLogger)
    .requestHandler(new NodeHttpHandler({
        connectionTimeout: 5000,
        socketTimeout: 30000,
    }))
    .build();
 
// Testing: Easy local development
const s3Test = S3ClientFactory.forLocalDevelopment();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

// Test data factory pattern (similar to Factory Bot, faker-based factories)
 
import { faker } from '@faker-js/faker';
 
// Factory for a single entity type
class UserFactory {
    private overrides: Partial<User> = {};
    private traits: Set<string> = new Set();
    
    // Builder-style fluent API for customization
    with(overrides: Partial<User>): this {
        this.overrides = { ...this.overrides, ...overrides };
        return this;
    }
    
    // Traits: predefined customization bundles
    admin(): this {
        this.traits.add('admin');
        return this;
    }
    
    verified(): this {
        this.traits.add('verified');
        return this;
    }
    
    withSubscription(): this {
        this.traits.add('subscription');
        return this;
    }
    
    build(): User {
        const user: User = {
            id: faker.string.uuid(),
            email: faker.internet.email(),
            name: faker.person.fullName(),
            createdAt: faker.date.past(),
            role: 'user',
            verified: false,
            subscription: null,
            ...this.overrides,
        };
        
        // Apply traits
        if (this.traits.has('admin')) {
            user.role = 'admin';
        }
        if (this.traits.has('verified')) {
            user.verified = true;
            user.verifiedAt = faker.date.past();
        }
        if (this.traits.has('subscription')) {
            user.subscription = SubscriptionFactory.create();
        }
        
        return user;
    }
    
    // Create and reset for chaining
    create(): User {
        const user = this.build();
        this.reset();
        return user;
    }
    
    // Create multiple
    createMany(count: number): User[] {
        return Array.from({ length: count }, () => this.create());
    }
    
    // Persist to database
    async createPersisted(prisma: PrismaClient): Promise<User> {
        const data = this.build();
        const user = await prisma.user.create({ data });
        this.reset();
        return user;
    }
    
    private reset(): void {
        this.overrides = {};
        this.traits.clear();
    }
    
    // Static convenience methods
    static create(overrides?: Partial<User>): User {
        const factory = new UserFactory();
        if (overrides) factory.with(overrides);
        return factory.create();
    }
}
 
// Related entity factory
class PostFactory {
    private authorId: string | null = null;
    private overrides: Partial<Post> = {};
    
    by(author: User | string): this {
        this.authorId = typeof author === 'string' ? author : author.id;
        return this;
    }
    
    with(overrides: Partial<Post>): this {
        this.overrides = { ...this.overrides, ...overrides };
        return this;
    }
    
    published(): this {
        return this.with({ 
            status: 'published', 
            publishedAt: faker.date.past() 
        });
    }
    
    draft(): this {
        return this.with({ status: 'draft', publishedAt: null });
    }
    
    create(): Post {
        const post: Post = {
            id: faker.string.uuid(),
            title: faker.lorem.sentence(),
            content: faker.lorem.paragraphs(3),
            authorId: this.authorId ?? UserFactory.create().id,
            status: 'draft',
            publishedAt: null,
            createdAt: faker.date.past(),
            ...this.overrides,
        };
        
        this.reset();
        return post;
    }
    
    private reset(): void {
        this.authorId = null;
        this.overrides = {};
    }
}
 
// Master factory registry for complex scenarios
class FactoryRegistry {
    static user(): UserFactory {
        return new UserFactory();
    }
    
    static post(): PostFactory {
        return new PostFactory();
    }
    
    // Create related entities in one call
    static async seedBlogScenario(prisma: PrismaClient): Promise<{
        admin: User;
        authors: User[];
        posts: Post[];
    }> {
        // Create admin
        const admin = await FactoryRegistry.user()
            .admin()
            .verified()
            .createPersisted(prisma);
        
        // Create authors
        const authors = await Promise.all(
            Array.from({ length: 3 }, () =>
                FactoryRegistry.user().verified().createPersisted(prisma)
            )
        );
        
        // Create posts for each author
        const posts: Post[] = [];
        for (const author of authors) {
            for (let i = 0; i < 5; i++) {
                const post = await prisma.post.create({
                    data: FactoryRegistry.post()
                        .by(author)
                        .published()
                        .create(),
                });
                posts.push(post);
            }
        }
        
        return { admin, authors, posts };
    }
}
 
// Usage in tests
describe('BlogService', () => {
    it('should return posts by author', async () => {
        const author = UserFactory.create();
        const posts = [
            PostFactory.create().by(author).published(),
            PostFactory.create().by(author).draft(),
        ];
        
        // ... set up mocks with these entities
        
        const result = await blogService.getPostsByAuthor(author.id);
        expect(result).toHaveLength(2);
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

// HTTP client configuration combining Builder + Decorator + Factory
 
type Interceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
type ResponseInterceptor = (response: Response) => Response | Promise<Response>;
 
// BUILDER: Configures HTTP client instance
class HttpClientBuilder {
    private baseUrl: string = '';
    private headers: Record<string, string> = {};
    private timeout: number = 30000;
    private requestInterceptors: Interceptor[] = [];
    private responseInterceptors: ResponseInterceptor[] = [];
    private retryConfig: RetryConfig | null = null;
    
    setBaseUrl(url: string): this {
        this.baseUrl = url;
        return this;
    }
    
    setHeader(key: string, value: string): this {
        this.headers[key] = value;
        return this;
    }
    
    setHeaders(headers: Record<string, string>): this {
        this.headers = { ...this.headers, ...headers };
        return this;
    }
    
    setTimeout(ms: number): this {
        this.timeout = ms;
        return this;
    }
    
    // DECORATOR: Add request interceptor
    addRequestInterceptor(interceptor: Interceptor): this {
        this.requestInterceptors.push(interceptor);
        return this;
    }
    
    // DECORATOR: Add response interceptor
    addResponseInterceptor(interceptor: ResponseInterceptor): this {
        this.responseInterceptors.push(interceptor);
        return this;
    }
    
    // Pre-built interceptor bundles
    withBearerAuth(tokenProvider: () => string | Promise<string>): this {
        return this.addRequestInterceptor(async (config) => ({
            ...config,
            headers: {
                ...config.headers,
                Authorization: `Bearer ${await tokenProvider()}`,
            },
        }));
    }
    
    withApiKey(apiKey: string, headerName: string = 'X-API-Key'): this {
        return this.setHeader(headerName, apiKey);
    }
    
    withRetry(config: RetryConfig = { maxRetries: 3, backoff: 'exponential' }): this {
        this.retryConfig = config;
        return this;
    }
    
    withLogging(logger: Logger): this {
        return this
            .addRequestInterceptor((config) => {
                logger.debug('HTTP Request', {
                    method: config.method,
                    url: config.url,
                });
                return config;
            })
            .addResponseInterceptor((response) => {
                logger.debug('HTTP Response', {
                    status: response.status,
                    url: response.url,
                });
                return response;
            });
    }
    
    build(): HttpClient {
        return new HttpClient({
            baseUrl: this.baseUrl,
            headers: this.headers,
            timeout: this.timeout,
            requestInterceptors: this.requestInterceptors,
            responseInterceptors: this.responseInterceptors,
            retryConfig: this.retryConfig,
        });
    }
}
 
// FACTORY: Creates pre-configured clients for different APIs
class ApiClientFactory {
    constructor(
        private config: AppConfig,
        private authService: AuthService,
        private logger: Logger
    ) {}
    
    // Main API client
    createMainApiClient(): HttpClient {
        return new HttpClientBuilder()
            .setBaseUrl(this.config.mainApiUrl)
            .withBearerAuth(() => this.authService.getAccessToken())
            .withRetry({ maxRetries: 3, backoff: 'exponential' })
            .withLogging(this.logger)
            .setTimeout(10000)
            .build();
    }
    
    // Analytics API client (different auth, longer timeout)
    createAnalyticsClient(): HttpClient {
        return new HttpClientBuilder()
            .setBaseUrl(this.config.analyticsApiUrl)
            .withApiKey(this.config.analyticsApiKey)
            .setTimeout(60000)  // Analytics queries can be slow
            .withLogging(this.logger)
            .build();
    }
    
    // Internal service client (no auth, short timeout)
    createInternalClient(serviceName: string): HttpClient {
        return new HttpClientBuilder()
            .setBaseUrl(`http://${serviceName}.internal:8080`)
            .setHeader('X-Service-Name', 'my-service')
            .setTimeout(5000)
            .withRetry({ maxRetries: 5, backoff: 'linear' })
            .build();
    }
    
    // Third-party API client (custom auth, rate limiting)
    createThirdPartyClient(): HttpClient {
        return new HttpClientBuilder()
            .setBaseUrl(this.config.thirdPartyApiUrl)
            .addRequestInterceptor(this.rateLimitInterceptor())
            .addRequestInterceptor(this.signatureInterceptor())
            .withLogging(this.logger)
            .build();
    }
    
    private rateLimitInterceptor(): Interceptor {
        let lastRequest = 0;
        const minInterval = 100;  // Max 10 req/sec
        
        return async (config) => {
            const now = Date.now();
            const elapsed = now - lastRequest;
            if (elapsed < minInterval) {
                await sleep(minInterval - elapsed);
            }
            lastRequest = Date.now();
            return config;
        };
    }
    
    private signatureInterceptor(): Interceptor {
        return (config) => ({
            ...config,
            headers: {
                ...config.headers,
                'X-Signature': computeHmac(config.body, this.config.apiSecret),
                'X-Timestamp': Date.now().toString(),
            },
        });
    }
}
 
// Usage in application
class OrderService {
    private mainApi: HttpClient;
    private analyticsApi: HttpClient;
    
    constructor(apiFactory: ApiClientFactory) {
        this.mainApi = apiFactory.createMainApiClient();
        this.analyticsApi = apiFactory.createAnalyticsClient();
    }
    
    async createOrder(order: CreateOrderDTO): Promise<Order> {
        const response = await this.mainApi.post('/orders', order);
        
        // Fire and forget analytics
        this.analyticsApi.post('/events', {
            type: 'order_created',
            orderId: response.data.id,
        }).catch(() => {});  // Don't fail order on analytics error
        
        return response.data;
    }
}