@routier/core 0.0.1-alpha.1

package/src/pipeline/SyncronousQueue.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SyncronousQueue, SyncronousUnitOfWork } from './SyncronousQueue';
+
+describe('SyncronousQueue', () => {
+    describe('enqueue', () => {
+        it('should add unit of work to queue and start processing', () => {
+            const queue = new SyncronousQueue();
+            const mockUnitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            queue.enqueue(mockUnitOfWork);
+
+            expect(mockUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+
+        it('should process multiple units of work in order', () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const unitOfWork1 = vi.fn((done: () => void) => {
+                executionOrder.push(1);
+                done();
+            });
+
+            const unitOfWork2 = vi.fn((done: () => void) => {
+                executionOrder.push(2);
+                done();
+            });
+
+            queue.enqueue(unitOfWork1);
+            queue.enqueue(unitOfWork2);
+
+            expect(executionOrder).toEqual([1, 2]);
+            expect(unitOfWork1).toHaveBeenCalledTimes(1);
+            expect(unitOfWork2).toHaveBeenCalledTimes(1);
+        });
+
+        it('should not start processing if already processing', () => {
+            const queue = new SyncronousQueue();
+            let doneCalled = false;
+
+            const slowUnitOfWork = vi.fn((done: () => void) => {
+                setTimeout(() => {
+                    doneCalled = true;
+                    done();
+                }, 10);
+            });
+
+            const fastUnitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            queue.enqueue(slowUnitOfWork);
+            queue.enqueue(fastUnitOfWork);
+
+            expect(slowUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(fastUnitOfWork).toHaveBeenCalledTimes(0);
+        });
+
+        it('should process next unit of work after current one completes', async () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const slowUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(1);
+                setTimeout(() => {
+                    done();
+                }, 10);
+            });
+
+            const fastUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(2);
+                done();
+            });
+
+            queue.enqueue(slowUnitOfWork);
+            queue.enqueue(fastUnitOfWork);
+
+            await new Promise(resolve => setTimeout(resolve, 20));
+
+            expect(executionOrder).toEqual([1, 2]);
+            expect(slowUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(fastUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('queue behavior', () => {
+        it('should handle empty queue', () => {
+            const queue = new SyncronousQueue();
+
+            expect(() => {
+                queue.enqueue(vi.fn((done: () => void) => done()));
+            }).not.toThrow();
+        });
+
+        it('should handle unit of work that never calls done', () => {
+            const queue = new SyncronousQueue();
+            const stuckUnitOfWork = vi.fn((done: () => void) => {
+                // Never calls done
+            });
+
+            const secondUnitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            queue.enqueue(stuckUnitOfWork);
+            queue.enqueue(secondUnitOfWork);
+
+            expect(stuckUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(secondUnitOfWork).toHaveBeenCalledTimes(0);
+        });
+
+        it('should handle unit of work that calls done multiple times', () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const multiDoneUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(1);
+                done();
+                done(); // Call done multiple times
+            });
+
+            const secondUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(2);
+                done();
+            });
+
+            queue.enqueue(multiDoneUnitOfWork);
+            queue.enqueue(secondUnitOfWork);
+
+            expect(executionOrder).toEqual([1, 2]);
+            expect(multiDoneUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(secondUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+
+        it('should handle rapid enqueueing of multiple units', () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const createUnitOfWork = (id: number) => vi.fn((done: () => void) => {
+                executionOrder.push(id);
+                done();
+            });
+
+            for (let i = 1; i <= 5; i++) {
+                queue.enqueue(createUnitOfWork(i));
+            }
+
+            expect(executionOrder).toEqual([1, 2, 3, 4, 5]);
+        });
+
+        it('should handle unit of work that throws error', () => {
+            const queue = new SyncronousQueue();
+            const errorUnitOfWork = vi.fn((done: () => void) => {
+                throw new Error('Test error');
+            });
+
+            const secondUnitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            expect(() => {
+                queue.enqueue(errorUnitOfWork);
+            }).toThrow('Test error');
+
+            expect(errorUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+
+        it('should not process next unit after error', () => {
+            const queue = new SyncronousQueue();
+            const errorUnitOfWork = vi.fn((done: () => void) => {
+                throw new Error('Test error');
+            });
+
+            const secondUnitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            try {
+                queue.enqueue(errorUnitOfWork);
+            } catch (error) {
+                // Error is thrown, queue stops processing
+            }
+
+            queue.enqueue(secondUnitOfWork);
+
+            expect(errorUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(secondUnitOfWork).toHaveBeenCalledTimes(0);
+        });
+
+        it('should handle unit of work that calls done asynchronously', async () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const asyncUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(1);
+                Promise.resolve().then(() => {
+                    done();
+                });
+            });
+
+            const syncUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(2);
+                done();
+            });
+
+            queue.enqueue(asyncUnitOfWork);
+            queue.enqueue(syncUnitOfWork);
+
+            await new Promise(resolve => setTimeout(resolve, 10));
+
+            expect(executionOrder).toEqual([1, 2]);
+            expect(asyncUnitOfWork).toHaveBeenCalledTimes(1);
+            expect(syncUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle null done callback', () => {
+            const queue = new SyncronousQueue();
+            const unitOfWork = vi.fn((done: () => void) => {
+                done();
+            });
+
+            expect(() => {
+                queue.enqueue(unitOfWork);
+            }).not.toThrow();
+
+            expect(unitOfWork).toHaveBeenCalledTimes(1);
+        });
+
+        it('should handle unit of work that enqueues another unit of work', () => {
+            const queue = new SyncronousQueue();
+            const executionOrder: number[] = [];
+
+            const recursiveUnitOfWork = vi.fn((done: () => void) => {
+                executionOrder.push(1);
+                queue.enqueue(vi.fn((innerDone: () => void) => {
+                    executionOrder.push(2);
+                    innerDone();
+                }));
+                done();
+            });
+
+            queue.enqueue(recursiveUnitOfWork);
+
+            expect(executionOrder).toEqual([1, 2]);
+            expect(recursiveUnitOfWork).toHaveBeenCalledTimes(1);
+        });
+
+        it('should handle multiple rapid enqueue operations', () => {
+            const queue = new SyncronousQueue();
+            const executionCount = { count: 0 };
+
+            const unitOfWork = vi.fn((done: () => void) => {
+                executionCount.count++;
+                done();
+            });
+
+            for (let i = 0; i < 100; i++) {
+                queue.enqueue(unitOfWork);
+            }
+
+            expect(executionCount.count).toBe(100);
+            expect(unitOfWork).toHaveBeenCalledTimes(100);
+        });
+    });
+}); 

package/src/pipeline/SyncronousQueue.ts

@@ -0,0 +1,30 @@
+export type SyncronousUnitOfWork = (done: () => void) => void
+
+export class SyncronousQueue {
+
+    private readonly _queue: SyncronousUnitOfWork[] = [];
+    private _current: SyncronousUnitOfWork | null = null;
+
+    enqueue(unitOfWork: SyncronousUnitOfWork) {
+        this._queue.push(unitOfWork);
+        this._next();
+    }
+
+    private _next() {
+        if (this._current != null || this._queue.length === 0) {
+            return;
+        }
+
+        // Take first item
+        this._current = this._queue.shift() ?? null;
+
+        if (this._current == null) {
+            return;
+        }
+
+        this._current(() => {
+            this._current = null;
+            this._next();
+        })
+    }
+}

package/src/pipeline/TrampolinePipeline.test.ts

@@ -0,0 +1,374 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TrampolinePipeline, AsyncPipeline, Processor, AsyncUnitOfWork } from './TrampolinePipeline';
+import { Result } from '../results';
+
+describe('TrampolinePipeline', () => {
+    describe('filter', () => {
+        it('should call done immediately when no processors are added', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const initialData = 'test data';
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter(initialData, (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe(initialData);
+                    resolve();
+                });
+            });
+        });
+
+        it('should process single processor synchronously', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const processor: Processor<string, string> = vi.fn((data, callback) => {
+                expect(data).toBe('test');
+                callback('result');
+            });
+
+            pipeline.pipe(processor);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('test', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('result');
+                    expect(processor).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+
+        it('should process multiple processors in order', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const executionOrder: number[] = [];
+
+            const processor1: Processor<string, number> = vi.fn((data, callback) => {
+                executionOrder.push(1);
+                expect(data).toBe('test');
+                callback(42);
+            });
+
+            const processor2: Processor<number, string> = vi.fn((data, callback) => {
+                executionOrder.push(2);
+                expect(data).toBe(42);
+                callback('result');
+            });
+
+            pipeline.pipe(processor1).pipe(processor2);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('test', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('result');
+                    expect(executionOrder).toEqual([1, 2]);
+                    expect(processor1).toHaveBeenCalledTimes(1);
+                    expect(processor2).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+
+        it('should handle asynchronous processors', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const processor: Processor<string, string> = vi.fn((data, callback) => {
+                setTimeout(() => {
+                    callback(data.toUpperCase());
+                }, 10);
+            });
+
+            pipeline.pipe(processor);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('test', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('TEST');
+                    expect(processor).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+
+        it('should handle mixed sync and async processors', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const executionOrder: number[] = [];
+
+            const syncProcessor: Processor<string, number> = vi.fn((data, callback) => {
+                executionOrder.push(1);
+                callback(data.length);
+            });
+
+            const asyncProcessor: Processor<number, string> = vi.fn((data, callback) => {
+                executionOrder.push(2);
+                setTimeout(() => {
+                    callback(`Length: ${data}`);
+                }, 10);
+            });
+
+            pipeline.pipe(syncProcessor).pipe(asyncProcessor);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('test', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('Length: 4');
+                    expect(executionOrder).toEqual([1, 2]);
+                    expect(syncProcessor).toHaveBeenCalledTimes(1);
+                    expect(asyncProcessor).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+
+        it('should handle overlapping filter calls', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const processor: Processor<string, string> = vi.fn((data, callback) => {
+                setTimeout(() => {
+                    callback(data.toUpperCase());
+                }, 10);
+            });
+
+            pipeline.pipe(processor);
+
+            return new Promise<void>((resolve) => {
+                let completedCount = 0;
+                const checkDone = () => {
+                    completedCount++;
+                    if (completedCount === 2) {
+                        resolve();
+                    }
+                };
+
+                // Start two filter operations simultaneously
+                pipeline.filter('test1', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('TEST1');
+                    checkDone();
+                });
+
+                pipeline.filter('test2', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('TEST2');
+                    checkDone();
+                });
+            });
+        });
+    });
+
+    describe('pipe', () => {
+        it('should return pipeline instance for chaining', () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const processor: Processor<string, string> = vi.fn((data, callback) => {
+                callback(data);
+            });
+
+            const result = pipeline.pipe(processor);
+
+            expect(result).toBe(pipeline);
+        });
+
+        it('should add processor to the list', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const processor: Processor<string, string> = vi.fn((data, callback) => {
+                callback(data);
+            });
+
+            pipeline.pipe(processor);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('test', (result, error) => {
+                    expect(processor).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+    });
+
+    describe('pipeEach', () => {
+        it('should process each item in array', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+            const items = ['a', 'b', 'c'];
+            const processedItems: string[] = [];
+
+            pipeline.pipeEach(
+                items,
+                (payload, done) => {
+                    if (payload.ok === Result.SUCCESS) {
+                        processedItems.push(payload.data);
+                        done(Result.success(payload.data.toUpperCase()));
+                    }
+                },
+                (previous, current) => current
+            );
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('initial', (result, error) => {
+                    expect(error).toBeUndefined();
+                    // The result should be a Result object with the last processed item
+                    expect(result).toEqual({ ok: 'success', data: 'C' });
+                    expect(processedItems).toEqual(['a', 'b', 'c']);
+                    resolve();
+                });
+            });
+        });
+
+        it('should handle empty array in pipeEach', async () => {
+            const pipeline = new TrampolinePipeline<string, string>();
+
+            pipeline.pipeEach(
+                [],
+                (payload, done) => {
+                    if (payload.ok === Result.SUCCESS) {
+                        done(Result.success(payload.data));
+                    }
+                },
+                (previous, current) => current
+            );
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter('initial', (result, error) => {
+                    expect(error).toBeUndefined();
+                    expect(result).toBe('initial');
+                    resolve();
+                });
+            });
+        });
+    });
+});
+
+describe('AsyncPipeline', () => {
+    describe('filter', () => {
+        it('should call done with empty array when no processors are added', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        // When no processors are added, data should be undefined, not empty array
+                        expect(result.data).toBeUndefined();
+                    }
+                    resolve();
+                });
+            });
+        });
+
+        it('should process single unit of work', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+            const unitOfWork: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                expect(payload).toBe('test');
+                done(Result.success('result'));
+            });
+
+            pipeline.pipe('test', unitOfWork);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        expect(result.data).toEqual(['result']);
+                    }
+                    expect(unitOfWork).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+
+        it('should process multiple units of work', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+            const executionOrder: number[] = [];
+
+            const unitOfWork1: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                executionOrder.push(1);
+                done(Result.success(`result1-${payload}`));
+            });
+
+            const unitOfWork2: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                executionOrder.push(2);
+                done(Result.success(`result2-${payload}`));
+            });
+
+            pipeline.pipe('test1', unitOfWork1);
+            pipeline.pipe('test2', unitOfWork2);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        expect(result.data).toEqual(['result1-test1', 'result2-test2']);
+                    }
+                    expect(executionOrder).toEqual([1, 2]);
+                    expect(unitOfWork1).toHaveBeenCalledTimes(1);
+                    expect(unitOfWork2).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+    });
+
+    describe('pipe', () => {
+        it('should add unit of work to the list', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+            const unitOfWork: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                done(Result.success(payload));
+            });
+
+            pipeline.pipe('test', unitOfWork);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        expect(result.data).toEqual(['test']);
+                    }
+                    expect(unitOfWork).toHaveBeenCalledTimes(1);
+                    resolve();
+                });
+            });
+        });
+    });
+
+    describe('pipeEach', () => {
+        it('should process each item in array', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+            const items = ['a', 'b', 'c'];
+            const processedItems: string[] = [];
+
+            const unitOfWork: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                processedItems.push(payload);
+                done(Result.success(payload.toUpperCase()));
+            });
+
+            pipeline.pipeEach(items, unitOfWork);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        expect(result.data).toEqual(['A', 'B', 'C']);
+                    }
+                    expect(processedItems).toEqual(['a', 'b', 'c']);
+                    expect(unitOfWork).toHaveBeenCalledTimes(3);
+                    resolve();
+                });
+            });
+        });
+
+        it('should handle empty array in pipeEach', async () => {
+            const pipeline = new AsyncPipeline<string, string>();
+            const unitOfWork: AsyncUnitOfWork<string, string> = vi.fn((payload, done) => {
+                done(Result.success(payload));
+            });
+
+            pipeline.pipeEach([], unitOfWork);
+
+            return new Promise<void>((resolve) => {
+                pipeline.filter((result) => {
+                    expect(result.ok).toBe(Result.SUCCESS);
+                    if (result.ok === Result.SUCCESS) {
+                        // When pipeEach is called with empty array, data should be undefined, not empty array
+                        expect(result.data).toBeUndefined();
+                    }
+                    expect(unitOfWork).toHaveBeenCalledTimes(0);
+                    resolve();
+                });
+            });
+        });
+    });
+});