@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/pipeline/SyncronousQueue.ts

@@ -1,30 +0,0 @@
-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

@@ -1,374 +0,0 @@
-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();
-                });
-            });
-        });
-    });
-}); 

package/src/pipeline/index.ts

@@ -1,2 +0,0 @@
-export * from './SyncronousQueue';
-export * from './TrampolinePipeline';

package/src/plugins/EphemeralDataPlugin.ts

@@ -1,132 +0,0 @@
-import { assertIsNotNull } from '../assertions';
-import { BulkPersistResult } from '../collections';
-import { WorkPipeline } from '../pipeline';
-import { DbPluginBulkPersistEvent, DbPluginEvent, DbPluginQueryEvent, IDbPlugin, JsonTranslator } from '.';
-import { PluginEventCallbackPartialResult, PluginEventCallbackResult, PluginEventResult, Result } from '../results';
-import { CompiledSchema, InferCreateType } from '../schema';
-import { DeepPartial } from '../types';
-import { MemoryDataCollection } from '../collections/MemoryDataCollection';
-import { UnknownRecord } from '../utilities';
-
-export abstract class EphemeralDataPlugin implements IDbPlugin {
-
-    protected databaseName: string;
-
-    constructor(databaseName: string) {
-        this.databaseName = databaseName;
-    }
-
-    protected abstract resolveCollection<TEntity extends {}>(schema: CompiledSchema<TEntity>): MemoryDataCollection;
-
-    bulkPersist(event: DbPluginBulkPersistEvent, done: PluginEventCallbackPartialResult<BulkPersistResult>) {
-        try {
-            const pipeline = new WorkPipeline();
-            const bulkPersistResult = event.operation.toResult();
-
-            for (const [schemaId, changes] of event.operation) {
-
-                pipeline.pipe((d) => {
-                    try {
-
-                        const { adds, hasItems, removes, updates } = changes;
-
-                        if (hasItems === false) {
-                            d(Result.success());
-                            return;
-                        }
-
-                        const result = bulkPersistResult.get(schemaId);
-                        const schema = event.schemas.get(schemaId);
-
-                        assertIsNotNull(schema);
-
-                        const collection = this.resolveCollection(schema);
-                        collection.load(readResult => {
-
-                            if (readResult.ok === Result.ERROR) {
-                                d(readResult);
-                                return;
-                            }
-
-                            for (let i = 0, length = adds.length; i < length; i++) {
-                                collection.add(adds[i]);
-                                result.adds.push(adds[i] as DeepPartial<InferCreateType<UnknownRecord>>);
-                            }
-
-                            for (let i = 0, length = updates.length; i < length; i++) {
-                                collection.update(updates[i].entity);
-                                result.updates.push(updates[i].entity);
-                            }
-
-                            for (let i = 0, length = removes.length; i < length; i++) {
-                                collection.remove(removes[i]);
-                                result.removes.push(removes[i]);
-                            }
-
-                            collection.save(saveResult => {
-
-                                if (saveResult.ok === Result.ERROR) {
-                                    d(saveResult);
-                                    return;
-                                }
-
-                                d(Result.success());
-                            });
-                        })
-
-                    } catch (e) {
-                        d(Result.error(e));
-                    }
-                });
-            }
-
-            let successCount = 0;
-
-            pipeline.filter((asyncResult) => {
-
-                if (asyncResult.ok !== PluginEventResult.SUCCESS) {
-
-                    if (successCount === 0) {
-                        done(PluginEventResult.error(event.id, asyncResult.error))
-                        return;
-                    }
-
-                    done(PluginEventResult.partial(event.id, bulkPersistResult, asyncResult.error))
-                    return;
-                }
-
-                successCount++;
-
-                done(PluginEventResult.success(event.id, bulkPersistResult));
-            });
-        } catch (e: any) {
-            done(PluginEventResult.error(event.id, e))
-        }
-    }
-
-    query<TEntity extends {}, TShape extends any = TEntity>(event: DbPluginQueryEvent<TEntity, TShape>, done: PluginEventCallbackResult<TShape>): void {
-
-        try {
-            const { operation } = event;
-            const translator = new JsonTranslator<TEntity, TShape>(operation);
-            const collection = this.resolveCollection(operation.schema);
-
-            // translate if we are doing any operations like count/sum/min/max/skip/take
-            collection.load(r => {
-
-                if (r.ok === Result.ERROR) {
-                    done(PluginEventResult.error(event.id, r.error));
-                    return;
-                }
-
-                const translated = translator.translate(collection.records);
-
-                done(PluginEventResult.success(event.id, translated));
-            })
-        } catch (e) {
-            done(PluginEventResult.error(event.id, e));
-        }
-    }
-
-    abstract destroy(event: DbPluginEvent, done: PluginEventCallbackResult<never>): void;
-}

package/src/plugins/capabilities/DbPluginCapability.ts

@@ -1,111 +0,0 @@
-import { BulkPersistResult } from "../../collections";
-import { PluginEventPartialResultType, PluginEventResultType } from "../../results";
-import { DbPluginBulkPersistEvent, DbPluginEvent, DbPluginQueryEvent, IDbPlugin } from "../types";
-
-export type DbPluginCapabilityEvent = "queryStart" | "queryComplete" | "destroyStart" | "destroyComplete" | "bulkPersistStart" | "bulkPersistComplete";
-
-export interface IDbPluginCapability {
-    apply<T extends IDbPlugin>(plugin: T): void;
-}
-
-/**
- * Extends plugin functionality through hooks and event handlers without
- * changing the plugin's type (mixin). Essential for maintaining type safety
- * in routier's core systems.
- */
-export class DbPluginCapability {
-
-    private events: Record<string, { before?: Function, after?: Function }> = {};
-
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "queryStart", callback: (event: DbPluginQueryEvent<TRoot, TShape>) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "queryComplete", callback: (event: PluginEventResultType<TShape>) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "destroyStart", callback: (event: DbPluginEvent) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "destroyComplete", callback: (event: PluginEventResultType<never>) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "bulkPersistStart", callback: (event: DbPluginBulkPersistEvent) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: "bulkPersistComplete", callback: (event: PluginEventPartialResultType<BulkPersistResult>) => void): DbPluginCapability;
-    add<TRoot extends {}, TShape extends any = TRoot>(name: DbPluginCapabilityEvent, callback: Function): DbPluginCapability {
-
-        this.resolve(name);
-
-        switch (name) {
-            case "queryStart":
-                this.events["query"].before = callback;
-                break;
-            case "queryComplete":
-                this.events["query"].after = callback;
-                break;
-            case "destroyStart":
-                this.events["destroy"].before = callback;
-                break;
-            case "destroyComplete":
-                this.events["destroy"].after = callback;
-                break;
-            case "bulkPersistStart":
-                this.events["bulkPersist"].before = callback;
-                break;
-            case "bulkPersistComplete":
-                this.events["bulkPersist"].after = callback;
-                break;
-        }
-
-        return this;
-    }
-
-    private resolve(name: DbPluginCapabilityEvent) {
-
-        switch (name) {
-            case "queryStart":
-            case "queryComplete":
-                if (!this.events["query"]) {
-                    this.events["query"] = {};
-                }
-                return;
-            case "destroyStart":
-            case "destroyComplete":
-                if (!this.events["destroy"]) {
-                    this.events["destroy"] = {};
-                }
-                return;
-            case "bulkPersistStart":
-            case "bulkPersistComplete":
-                if (!this.events["bulkPersist"]) {
-                    this.events["bulkPersist"] = {};
-                }
-                return;
-
-            default:
-                throw new Error("Exhaustive check")
-        }
-    }
-
-    apply<T extends IDbPlugin>(plugin: T) {
-
-        const methodWrappers: { method: keyof IDbPlugin, events: { before?: Function, after?: Function } }[] = [
-            { method: 'query', events: this.events.query },
-            { method: 'destroy', events: this.events.destroy },
-            { method: 'bulkPersist', events: this.events.bulkPersist }
-        ];
-
-        // apply the mixins
-        for (let i = 0, length = methodWrappers.length; i < length; i++) {
-
-            const { events, method } = methodWrappers[i];
-
-            if (events?.before || events?.after) {
-                const original = plugin[method].bind(plugin);
-                plugin[method] = ((event: unknown, done: Function) => {
-                    events.before?.(event, done);
-
-                    if (events.after) {
-                        return original(event, (result: unknown) => {
-                            events.after(result);
-                            done(result);
-                        });
-                    }
-
-                    return original(event, done);
-                });
-            }
-        }
-    }
-}