@eleven-am/pondsocket 0.1.0

package/pondBase/pubSub.d.ts

@@ -0,0 +1,73 @@
+export declare class Subscription {
+    unsubscribe(): void;
+}
+
+export declare class Broadcast<T, A> {
+
+    /**
+     * @desc Subscribe to the broadcast
+     * @param handler - The handler to call when the broadcast is published
+     */
+    subscribe(handler: (data: T) => A): Subscription;
+
+    /**
+     * @desc Publish to the broadcast
+     * @param data - The data to publish
+     */
+    publish(data: T): A | undefined;
+}
+
+export declare class Subject<T, A> extends Broadcast<T, A> {
+    constructor(value: T);
+
+    /**
+     * @desc Get the current value of the subject
+     */
+    get value(): T;
+
+    /**
+     * @desc Subscribe to the subject
+     * @param handler - The handler to call when the subject is published
+     */
+    subscribe(handler: (data: T) => A): Subscription;
+
+    /**
+     * @desc Publish to the subject
+     * @param data - The data to publish
+     */
+    publish(data: T): A | undefined;
+}
+
+export declare class EventPubSub<T, A> {
+
+    /**
+     * @desc Subscribe to the event subject
+     * @param event - The event to subscribe to
+     * @param handler - The handler to call when the event subject is published
+     */
+    subscribe(event: string, handler: (data: T) => A): Subscription;
+
+    /**
+     * @desc Publish to the event subject
+     * @param event - The event to publish
+     * @param data - The data to publish
+     */
+    publish(event: string, data: T): void;
+
+    /**
+     * @desc Subscribe to all events
+     * @param handler - The handler to call when the event subject is published
+     */
+    subscribeAll(handler: (event: T) => A): Subscription;
+
+    /**
+     * @desc Complete the event subject
+     */
+    complete(): void;
+
+    /**
+     * @desc Subscribe to the event subject completion
+     * @param handler - The handler to call when the event subject is completed
+     */
+    onComplete(handler: () => void): void;
+}

package/pondBase/pubSub.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPubSub = exports.Subject = exports.Broadcast = void 0;
+class Broadcast {
+    constructor() {
+        this._subscribers = new Set();
+    }
+    /**
+     * @desc Subscribe to the broadcast
+     * @param handler - The handler to call when the broadcast is published
+     */
+    subscribe(handler) {
+        this._subscribers.add(handler);
+        return {
+            /**
+             * @desc Unsubscribe from the broadcast
+             */
+            unsubscribe: () => {
+                this._subscribers.delete(handler);
+            }
+        };
+    }
+    /**
+     * @desc Publish to the broadcast
+     * @param data - The data to publish
+     */
+    publish(data) {
+        let result;
+        for (const subscriber of this._subscribers) {
+            result = subscriber(data);
+            if (result)
+                break;
+        }
+        return result;
+    }
+}
+exports.Broadcast = Broadcast;
+class Subject extends Broadcast {
+    constructor(value) {
+        super();
+        this._value = value;
+    }
+    /**
+     * @desc Get the current value of the subject
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * @desc Subscribe to the subject
+     * @param handler - The handler to call when the subject is published
+     */
+    subscribe(handler) {
+        void handler(this._value);
+        return super.subscribe(handler);
+    }
+    /**
+     * @desc Publish to the subject
+     * @param data - The data to publish
+     */
+    publish(data) {
+        if (this._value !== data) {
+            this._value = data;
+            return super.publish(data);
+        }
+    }
+}
+exports.Subject = Subject;
+class EventPubSub {
+    constructor() {
+        this._subscribers = new Set();
+    }
+    /**
+     * @desc Subscribe to the event subject
+     * @param event - The event to subscribe to
+     * @param handler - The handler to call when the event subject is published
+     */
+    subscribe(event, handler) {
+        const subscriber = (eventData) => {
+            if (eventData.type === event)
+                return handler(eventData.data);
+            return undefined;
+        };
+        this._subscribers.add(subscriber);
+        return {
+            /**
+             * @desc Unsubscribe from the event subject
+             */
+            unsubscribe: () => {
+                this._subscribers.delete(subscriber);
+            }
+        };
+    }
+    /**
+     * @desc Publish to the event subject
+     * @param event - The event to publish
+     * @param data - The data to publish
+     */
+    publish(event, data) {
+        for (const subscriber of this._subscribers) {
+            void subscriber({ type: event, data });
+        }
+    }
+    /**
+     * @desc Subscribe to all events
+     * @param handler - The handler to call when the event subject is published
+     */
+    subscribeAll(handler) {
+        const subscriber = (eventData) => {
+            return handler(eventData.data);
+        };
+        this._subscribers.add(subscriber);
+        return {
+            /**
+             * @desc Unsubscribe from the event subject
+             */
+            unsubscribe: () => {
+                this._subscribers.delete(subscriber);
+            }
+        };
+    }
+    /**
+     * @desc Complete the event subject
+     */
+    complete() {
+        this._subscribers.clear();
+        if (this._onComplete)
+            this._onComplete();
+    }
+    /**
+     * @desc Subscribe to the event subject completion
+     * @param handler - The handler to call when the event subject is completed
+     */
+    onComplete(handler) {
+        this._onComplete = handler;
+    }
+}
+exports.EventPubSub = EventPubSub;

package/pondBase/pubSub.test.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pubSub_1 = require("./pubSub");
+describe('Broadcast', () => {
+    it('should be defined', () => {
+        expect(pubSub_1.Broadcast).toBeDefined();
+    });
+    it('should be a class', () => {
+        expect(pubSub_1.Broadcast).toBeInstanceOf(Function);
+    });
+    // Functionality tests
+    it('should publish a message to all subscribers', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber = jest.fn();
+        broadcast.subscribe(subscriber); // test with one subscriber
+        broadcast.publish('Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+    });
+    it('should publish a message to all subscribers', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        broadcast.subscribe(subscriber1); // test with two subscribers
+        broadcast.subscribe(subscriber2);
+        broadcast.publish('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+    });
+    it('should publish a message to all subscribers', () => {
+        // including subscribers that subscribe after the first message is published
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        broadcast.subscribe(subscriber1);
+        broadcast.publish('Hello');
+        broadcast.subscribe(subscriber2);
+        broadcast.publish('Hello Again');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello Again');
+    });
+    it('should unsubscribe a subscriber and thus not receive new message', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        broadcast.subscribe(subscriber1);
+        broadcast.subscribe(subscriber2);
+        broadcast.publish('Hello');
+        const subscription = broadcast.subscribe(subscriber2);
+        subscription.unsubscribe();
+        broadcast.publish('Hello Again');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).not.toHaveBeenCalledWith('Hello Again');
+    });
+    it('should stop the broadcast midway if a subscription returns a value', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn(() => true);
+        const subscriber3 = jest.fn();
+        broadcast.subscribe(subscriber1);
+        broadcast.subscribe(subscriber2);
+        broadcast.subscribe(subscriber3);
+        broadcast.publish('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+        expect(subscriber3).not.toHaveBeenCalled();
+    });
+    it('should throw an error if one of its subscribers throws an error', () => {
+        const broadcast = new pubSub_1.Broadcast();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn(() => {
+            throw new Error('Something went wrong');
+        });
+        const subscriber3 = jest.fn();
+        broadcast.subscribe(subscriber1);
+        broadcast.subscribe(subscriber2);
+        broadcast.subscribe(subscriber3);
+        expect(() => broadcast.publish('Hello')).toThrowError('Something went wrong');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+        expect(subscriber3).not.toHaveBeenCalled();
+    });
+});
+describe('Subject', () => {
+    it('should be defined', () => {
+        expect(pubSub_1.Subject).toBeDefined();
+    });
+    it('should be a class', () => {
+        expect(pubSub_1.Subject).toBeInstanceOf(Function);
+    });
+    // Functionality tests
+    it('should publish a message to all subscribers', () => {
+        const subject = new pubSub_1.Subject('hi');
+        const subscriber = jest.fn();
+        subject.subscribe(subscriber); // test with one subscriber
+        subject.publish('Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+    });
+    it('should publish a message to all subscribers', () => {
+        const subject = new pubSub_1.Subject('hi');
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.subscribe(subscriber1); // test with two subscribers
+        subject.subscribe(subscriber2);
+        subject.publish('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+    });
+    it('should provide the initial value to new subscribers', () => {
+        const subject = new pubSub_1.Subject('hi');
+        const subscriber = jest.fn();
+        subject.subscribe(subscriber); // test with one subscriber
+        expect(subscriber).toHaveBeenCalledWith('hi');
+    });
+    it('should publish a message to all subscribers', () => {
+        // including subscribers that subscribe after the first message is published
+        const subject = new pubSub_1.Subject('hi');
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.subscribe(subscriber1);
+        subject.publish('Hello');
+        subject.subscribe(subscriber2);
+        subject.publish('Hello Again');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello Again');
+    });
+    it('should return the current value when the getter is called', () => {
+        const subject = new pubSub_1.Subject('hi');
+        expect(subject.value).toEqual('hi');
+    });
+    it('should throw an error if one of its subscribers throws an error', () => {
+        const subject = new pubSub_1.Subject('hi');
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn(() => {
+            throw new Error('Something went wrong');
+        });
+        const subscriber3 = jest.fn();
+        subject.subscribe(subscriber1);
+        // because the subject immediately calls the subscriber with the initial value
+        expect(() => subject.subscribe(subscriber2)).toThrowError('Something went wrong');
+        subscriber2.mockClear();
+        subject.subscribe(subscriber3);
+        // since ths subscriber throws an error, the subject should not call it
+        subject.publish('Hello'); // this should not call subscriber2 and should not throw an error
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber3).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).not.toHaveBeenCalled();
+    });
+});
+describe('EventSubject', () => {
+    it('should be defined', () => {
+        expect(pubSub_1.EventPubSub).toBeDefined();
+    });
+    it('should be a class', () => {
+        expect(pubSub_1.EventPubSub).toBeInstanceOf(Function);
+    });
+    // Functionality tests
+    it('should publish a message to all subscribers', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        subject.subscribe('test', subscriber); // test with one subscriber
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+    });
+    it('should publish a message to all subscribers', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.subscribe('test', subscriber1); // test with two subscribers
+        subject.subscribe('test', subscriber2);
+        subject.publish('test', 'Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+    });
+    it('should publish a message to all subscribers', () => {
+        // including subscribers that subscribe after the first message is published
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.subscribe('test', subscriber1);
+        subject.publish('test', 'Hello');
+        subject.subscribe('test', subscriber2);
+        subject.publish('test', 'Hello Again');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello Again');
+    });
+    it('should not call a function if the event name does not match', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        subject.subscribe('test', subscriber);
+        subject.publish('test2', 'Hello');
+        expect(subscriber).not.toHaveBeenCalled();
+    });
+    it('should not call a function if the event name does not match', () => {
+        // including subscribers that subscribe after the first message is published
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.subscribe('test', subscriber1);
+        subject.publish('test', 'Hello');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).not.toHaveBeenCalled();
+        subscriber1.mockClear();
+        subscriber2.mockClear();
+        subject.subscribe('test2', subscriber2);
+        subject.publish('test2', 'Hello Again');
+        expect(subscriber1).not.toHaveBeenCalled();
+        expect(subscriber2).toHaveBeenCalledWith('Hello Again');
+    });
+    it('should accept a generic subscriber', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        subject.subscribeAll(subscriber);
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+    });
+    it('should accept a generic subscriber', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        subject.subscribeAll(subscriber);
+        subject.publish('test', 'Hello');
+        subject.publish('test2', 'Hello Again');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello Again');
+    });
+    it('should be able to unsubscribe from a specific event', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        const sub = subject.subscribe('test', subscriber);
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+        subscriber.mockClear();
+        sub.unsubscribe();
+        subject.publish('test', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+    });
+    it('should complete the subscription when unsubscribed', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        const subscriber2 = jest.fn();
+        const subscriber3 = jest.fn();
+        subject.subscribe('test', subscriber);
+        subject.subscribe('test1', subscriber2);
+        subject.subscribe('test2', subscriber3);
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+        subscriber.mockClear();
+        subject.publish('test1', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).toHaveBeenCalledWith('Hello Again');
+        subscriber2.mockClear();
+        subject.publish('test2', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+        expect(subscriber2).not.toHaveBeenCalledWith('Hello Again');
+        expect(subscriber3).toHaveBeenCalledWith('Hello Again');
+        subscriber3.mockClear();
+        subject.complete(); // complete all subscriptions
+        subject.publish('test', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+        subject.publish('test1', 'Hello Again');
+        expect(subscriber2).not.toHaveBeenCalledWith('Hello Again');
+        subject.publish('test2', 'Hello Again');
+        expect(subscriber3).not.toHaveBeenCalledWith('Hello Again');
+    });
+    it('should throw an error if one of its subscribers throw an error', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber1 = jest.fn();
+        const subscriber2 = jest.fn(() => {
+            throw new Error('Something went wrong');
+        });
+        const subscriber3 = jest.fn();
+        subject.subscribeAll(subscriber1);
+        subject.subscribeAll(subscriber2);
+        subject.subscribe('event', subscriber3);
+        expect(() => subject.publish('event', 'Hello')).toThrowError('Something went wrong');
+        expect(subscriber1).toHaveBeenCalledWith('Hello');
+        expect(subscriber2).toHaveBeenCalledWith('Hello');
+        expect(subscriber3).not.toHaveBeenCalled();
+    });
+    it('should be possible to unsubscribe from a generic subscriber', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        const sub = subject.subscribeAll(subscriber);
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+        subscriber.mockClear();
+        sub.unsubscribe();
+        subject.publish('test', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+    });
+    it('should be able to add an oncomplete callback', () => {
+        const subject = new pubSub_1.EventPubSub();
+        const subscriber = jest.fn();
+        const subscriber2 = jest.fn();
+        subject.onComplete(subscriber2);
+        subject.subscribe('test', subscriber);
+        subject.publish('test', 'Hello');
+        expect(subscriber).toHaveBeenCalledWith('Hello');
+        subscriber.mockClear();
+        subject.complete();
+        expect(subscriber2).toHaveBeenCalled();
+        subject.publish('test', 'Hello Again');
+        expect(subscriber).not.toHaveBeenCalledWith('Hello Again');
+    });
+});

package/pondBase/simpleBase.d.ts

@@ -0,0 +1,131 @@
+export declare class PondDocument<T> {
+    private readonly _id;
+    private readonly _getDoc;
+    private readonly _removeDoc;
+    private readonly _updateDoc;
+
+    constructor(id: string, removeDoc: () => void, updateDoc: (value: T) => PondDocument<T>, getDoc: () => T);
+
+    get id(): string;
+
+    get doc(): T;
+
+    /**
+     * @desc Removes the document from the collection
+     */
+    removeDoc(): T;
+
+    /**
+     * @desc Updates the document in the collection
+     * @param value - the new value of the document
+     */
+    updateDoc(value: T): this;
+}
+
+declare type UpdateCallback<T> = (data: {
+    oldValue: T | null; currentValue: T | null;
+}) => void;
+
+export declare class SimpleBase<T> {
+    constructor(callbacks?: UpdateCallback<T>);
+
+    /**
+     * @desc Get the number of documents
+     */
+    get size(): number;
+
+    /**
+     * @desc Get all the documents in the database
+     */
+    get all(): PondDocument<T>[];
+
+    /**
+     * @desc Gets all the keys of the database
+     */
+    get keys(): string[];
+
+    /**
+     * @desc Gets all the values of the database
+     */
+    get values(): T[];
+
+    /**
+     * @desc Makes the database iterable
+     */
+    [Symbol.iterator](): IterableIterator<PondDocument<T>>;
+
+    /**
+     * @desc Create a generator for the pond
+     */
+    generator(): Generator<PondDocument<T>>;
+
+    /**
+     * @desc Get a document by key
+     * @param key - The key of the document
+     */
+    get(key: string): PondDocument<T> | null;
+
+    /**
+     * @desc getOrCreate a document in the database
+     * @param key - The key of the document
+     * @param creator - The function to create the document
+     */
+    getOrCreate(key: string, creator: (doc: Readonly<PondDocument<T>>) => T): PondDocument<T>;
+
+    /**
+     * @desc Upsert a document in the database
+     * @param key - The key of the document
+     * @param value - The value of the document
+     */
+    upsert(key: string, value: T): PondDocument<T>;
+
+    /**
+     * @desc checks if a document exists
+     * @param key - The key of the document
+     */
+    has(key: string): boolean;
+
+    /**
+     * @desc Set a document to the database
+     * @param key - The key of the document
+     * @param value - The value of the document
+     */
+    set(key: string, value: T): PondDocument<T>;
+
+    /**
+     * @desc Find a document by a query function
+     * @param query - The query function
+     */
+    find(query: (doc: T, id: string) => boolean): PondDocument<T> | null;
+
+    /**
+     * @desc Map the pond to a new array
+     * @param mapper - The mapper function
+     */
+    map<U>(mapper: (doc: T, id: string) => U): U[];
+
+    /**
+     * @desc Filters the pond using a query function
+     * @param query - The query function
+     */
+    filter(query: (doc: T, id: string) => boolean): PondDocument<T>[];
+
+    /**
+     * @desc Reduce the pond to a single value
+     * @param reducer - The reducer function
+     * @param initialValue - The initial value of the reducer
+     */
+    reduce<U>(reducer: (accumulator: U, currentValue: T) => U, initialValue: U): U;
+
+    /**
+     * @desc Generate a generic pond document
+     * @param id - The id of the document
+     */
+    createGenericDocument(id?: string): PondDocument<T>;
+
+    /**
+     * @desc Gets the raw database
+     * @protected
+     */
+    protected _getDB(): Record<string, T>;
+}