@eleven-am/pondsocket 0.1.0

package/base.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pondBase"), exports);

package/client.d.ts

@@ -0,0 +1 @@
+export * from './pondClient';

package/client.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pondClient"), exports);

package/index.d.ts

@@ -0,0 +1 @@
+export * from './pondSocket';

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pondSocket"), exports);

package/jest.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+    transform: {
+        '^.+\\.ts?$': 'ts-jest',
+    },
+    moduleFileExtensions: ['ts', 'js', 'json', 'node', 'd.ts'],
+    collectCoverage: true,
+    collectCoverageFrom: [
+        "src/**/*.{js,jsx,ts,tsx}",
+        "!src/**/*.d.ts"
+    ],
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@eleven-am/pondsocket",
+  "version": "0.1.0",
+  "description": "PondSocket is a fast simple socket server",
+  "keywords": [
+    "socket",
+    "server",
+    "ws",
+    "websocket",
+    "pubsub",
+    "presence",
+    "realtime",
+    "realtime server"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest --coverage",
+    "build": "tsc"
+  },
+  "author": "Roy OSSAI",
+  "license": "GPL-3.0",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Eleven-am/pondSocket.git"
+  },
+  "dependencies": {
+    "rxjs": "^7.5.6",
+    "ws": "^8.8.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.1.2",
+    "@types/node": "^16.10.3",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.40.1",
+    "@typescript-eslint/parser": "^5.40.1",
+    "eslint": "^8.25.0",
+    "jest": "^29.0.1",
+    "process": "^0.11.10",
+    "superwstest": "^2.0.3",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4"
+  }
+}

package/pondBase/baseClass.d.ts

@@ -0,0 +1,37 @@
+import {default_t, PondPath} from "./types";
+
+export interface Resolver {
+    params: default_t<string>;
+    query: default_t<string>;
+    address: string;
+}
+
+export declare class BaseClass {
+
+    /**
+     * @desc compares string to string | regex
+     * @param string - the string to compare to the pattern
+     * @param pattern - the pattern to compare to the string
+     */
+    compareStringToPattern(string: string, pattern: string | RegExp): boolean;
+
+    /**
+     * @desc Checks if the given object is empty
+     * @param obj - the object to check
+     */
+    isObjectEmpty(obj: object): boolean;
+
+    /**
+     * @desc Generates a pond request resolver object
+     * @param path - the path to resolve
+     * @param address - the address to resolve
+     */
+    generateEventRequest(path: PondPath, address: string): Resolver | null;
+
+    /**
+     * @desc Compares if two objects are equal
+     * @param obj1 - the first object
+     * @param obj2 - the second object
+     */
+    areEqual<T>(obj1: T, obj2: T): boolean;
+}

package/pondBase/baseClass.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClass = void 0;
+class BaseClass {
+    /**
+     * @desc checks if the pattern is matchable
+     * @param pattern - the pattern to check
+     */
+    static isPatternMatchable(pattern) {
+        return typeof pattern === 'string' && pattern.includes(':');
+    }
+    /**
+     * @desc compares string to string | regex
+     * @param string - the string to compare to the pattern
+     * @param pattern - the pattern to compare to the string
+     */
+    compareStringToPattern(string, pattern) {
+        if (typeof pattern === 'string')
+            return string.split('?')[0] === pattern;
+        else
+            return pattern.test(string);
+    }
+    /**
+     * @desc Checks if the given object is empty
+     * @param obj - the object to check
+     */
+    isObjectEmpty(obj) {
+        return Object.keys(obj).length === 0;
+    }
+    /**
+     * @desc Generates a pond request resolver object
+     * @param path - the path to resolve
+     * @param address - the address to resolve
+     */
+    generateEventRequest(path, address) {
+        const match = this._matchStringToPattern(address, path);
+        if (match)
+            return {
+                params: match, query: this._parseQueries(address), address: address
+            };
+        return null;
+    }
+    /**
+     * @desc Compares if two objects are equal
+     * @param obj1 - the first object
+     * @param obj2 - the second object
+     */
+    areEqual(obj1, obj2) {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    /**
+     * @desc Creates an object from the params of a path
+     * @param path - the path to create the object from
+     *
+     * @example
+     * /api/id?name=abc should return { name: 'abc' }
+     * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
+     */
+    _parseQueries(path) {
+        const obj = {};
+        const params = path.split('?')[1];
+        if (params) {
+            params.split('&').forEach(param => {
+                const [key, value] = param.split('=');
+                obj[key] = value;
+            });
+        }
+        return obj;
+    }
+    /**
+     * @desc Returns the {key: value} matches of a string
+     * @param string - the string to create the regex from
+     * @param pattern - the pattern to match
+     *
+     * @example
+     * /api/:id should match /api/123 and return { id: 123 }
+     * /api/:id/:name should match /api/123/abc and return { id: 123, name: abc }
+     * hello:id should match hello:123 and return { id: 123 }
+     * @private
+     */
+    _matchString(string, pattern) {
+        const replace = pattern.replace(/:[^/]+/g, '([^/]+)');
+        const regExp = new RegExp(`^${replace}$`);
+        const matches = string.split('?')[0].match(regExp);
+        if (matches) {
+            const keys = pattern.match(/:[^/]+/g);
+            if (keys) {
+                const obj = {};
+                keys.forEach((key, index) => {
+                    obj[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
+                });
+                return obj;
+            }
+        }
+        return null;
+    }
+    /**
+     * @desc matches a string to a pattern and returns its params if any
+     * @param string - the string to match
+     * @param pattern - the pattern to match to
+     */
+    _matchStringToPattern(string, pattern) {
+        if (BaseClass.isPatternMatchable(pattern))
+            return this._matchString(string, pattern);
+        const valid = this.compareStringToPattern(string, pattern);
+        if (valid)
+            return {};
+        return null;
+    }
+}
+exports.BaseClass = BaseClass;

package/pondBase/baseClass.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseClass_1 = require("./baseClass");
+describe('BaseClass', () => {
+    const baseClass = new baseClass_1.BaseClass();
+    it('should return true when object is empty', () => {
+        expect(baseClass.isObjectEmpty({})).toBe(true);
+    });
+    it('should return false when object is not empty', () => {
+        expect(baseClass.isObjectEmpty({ test: 5 })).toBe(false);
+    });
+    it('should return true if a string matches a regex | string', () => {
+        const regex = new RegExp(/^test/);
+        expect(baseClass.compareStringToPattern('test', regex)).toBe(true);
+        const string = 'test';
+        expect(baseClass.compareStringToPattern('test', string)).toBe(true);
+    });
+    it('should return false if a string does not match a regex | string', () => {
+        const regex = new RegExp(/^test$/);
+        expect(baseClass.compareStringToPattern('test2', regex)).toBe(false);
+        const string = 'test';
+        expect(baseClass.compareStringToPattern('test2', string)).toBe(false);
+    });
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = '/test/:id';
+        const secondPattern = '/test/:id/:id2';
+        const string = '/test/5';
+        const secondString = '/test/5/6';
+        expect(baseClass['_matchString'](string, pattern)).toEqual({ id: '5' });
+        expect(baseClass['_matchString'](secondString, secondPattern)).toEqual({ id: '5', id2: '6' });
+        // this function fails if the pattern is not a string or regex
+        expect(baseClass['_matchString'](secondString, pattern)).toEqual(null);
+        // But will return null if the string is smaller than the pattern
+        expect(baseClass['_matchString'](string, secondPattern)).toEqual(null);
+        //it should also match patterns without the slash
+        const thirdPattern = 'test:id';
+        const thirdString = 'test5';
+        expect(baseClass['_matchString'](thirdString, thirdPattern)).toEqual({ id: '5' });
+    });
+    it('should return the query of string', () => {
+        const string = '/test/5?test=5';
+        const secondString = '/test/5?test=5&test2=6';
+        expect(baseClass['_parseQueries'](string)).toEqual({ test: '5' });
+        expect(baseClass['_parseQueries'](secondString)).toEqual({ test: '5', test2: '6' });
+    });
+    it('should return true if an object matches another object', () => {
+        const object = { test: 5 };
+        const secondObject = { test: 5, test2: 6 };
+        expect(baseClass.areEqual(object, object)).toBe(true);
+        expect(baseClass.areEqual(object, secondObject)).toBe(false);
+    });
+    it('should return null if the string does not match the pattern', () => {
+        const pattern = 'pondSocket';
+        const string = '/test2/5';
+        expect(baseClass['_matchStringToPattern'](string, pattern)).toBe(null);
+    });
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = 'pondSocket';
+        const string = 'pondSocket';
+        expect(baseClass['_matchStringToPattern'](string, pattern)).toEqual({});
+    });
+    it('should generateEventRequest', () => {
+        const pattern = 'pondSocket:test';
+        const string = 'pondSockethello?test=5&test2=6';
+        expect(baseClass.generateEventRequest(pattern, string)).toEqual({
+            address: string,
+            params: { test: 'hello' },
+            query: { test: '5', test2: '6' }
+        });
+        const unMatchingString = 'pondXocket2hello?test=5&test2=6';
+        expect(baseClass.generateEventRequest(pattern, unMatchingString)).toEqual(null);
+    });
+});

package/pondBase/enums.d.ts

@@ -0,0 +1,9 @@
+export declare enum ResponsePicker {
+    POND = "POND",
+    CHANNEL = "CHANNEL"
+}
+export declare enum PondBaseActions {
+    ADD_TO_POND = "ADD_TO_POND",
+    REMOVE_FROM_POND = "REMOVE_FROM_POND",
+    UPDATE_IN_POND = "UPDATE_IN_POND"
+}

package/pondBase/enums.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondBaseActions = exports.ResponsePicker = void 0;
+var ResponsePicker;
+(function (ResponsePicker) {
+    ResponsePicker["POND"] = "POND";
+    ResponsePicker["CHANNEL"] = "CHANNEL";
+})(ResponsePicker = exports.ResponsePicker || (exports.ResponsePicker = {}));
+var PondBaseActions;
+(function (PondBaseActions) {
+    PondBaseActions["ADD_TO_POND"] = "ADD_TO_POND";
+    PondBaseActions["REMOVE_FROM_POND"] = "REMOVE_FROM_POND";
+    PondBaseActions["UPDATE_IN_POND"] = "UPDATE_IN_POND";
+})(PondBaseActions = exports.PondBaseActions || (exports.PondBaseActions = {}));

package/pondBase/index.d.ts

@@ -0,0 +1,6 @@
+export * from './baseClass';
+export * from './pondBase';
+export * from './pubSub';
+export * from './types';
+export * from './enums';
+export * from './simpleBase';

package/pondBase/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseClass"), exports);
+__exportStar(require("./pondBase"), exports);
+__exportStar(require("./pubSub"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./simpleBase"), exports);

package/pondBase/pondBase.d.ts

@@ -0,0 +1,41 @@
+import {Subscription} from "./pubSub";
+import {SimpleBase} from "./simpleBase";
+import {PondBaseActions} from "./enums";
+
+declare type ExtractSameValueType<A, B, C extends keyof A> = {
+    [K in keyof B]: B[K] extends A[C] ? A[C] extends B[K] ? K : never : never;
+}[keyof B];
+
+export declare class PondBase<T> extends SimpleBase<T> {
+
+    constructor();
+
+    /**
+     * @des Generate a key for a new document
+     */
+    private get _nanoid();
+
+    /**
+     * @desc Subscribe to the database
+     * @param handler - The handler to call when the database is updated
+     */
+    subscribe(handler: (docs: T[], change: T | null, action: PondBaseActions) => void): Subscription;
+
+    /**
+     * @desc Add a document to the database
+     * @param doc - The document to add
+     */
+    addDoc(doc: T): import("./simpleBase").PondDocument<T>;
+
+    /**
+     * @desc Left join two ponds on a key on this pond and a foreign key on the other pond
+     * @param pond - The pond to join with
+     * @param key - The key to join on
+     * @param foreignKey - The foreign key to join on
+     */
+    leftJoin<U, A extends keyof T, B extends ExtractSameValueType<T, U, A>>(pond: PondBase<U>, key: A, foreignKey: B): PondBase<T & {
+        [K in A]: U | null;
+    }>;
+}
+
+export {};

package/pondBase/pondBase.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PondBase = void 0;
+const pubSub_1 = require("./pubSub");
+const simpleBase_1 = require("./simpleBase");
+const enums_1 = require("./enums");
+class PondBase extends simpleBase_1.SimpleBase {
+    constructor() {
+        const broadcast = new pubSub_1.Broadcast();
+        super((data) => broadcast.publish(data));
+        this._broadcast = broadcast;
+    }
+    /**
+     * @des Generate a key for a new document
+     */
+    get _nanoid() {
+        let id = '';
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < 21; i++) {
+            id += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return id;
+    }
+    /**
+     * @desc Subscribe to the database
+     * @param handler - The handler to call when the database is updated
+     */
+    subscribe(handler) {
+        return this._broadcast.subscribe((data) => {
+            let change = enums_1.PondBaseActions.UPDATE_IN_POND;
+            if (data.oldValue === null)
+                change = enums_1.PondBaseActions.ADD_TO_POND;
+            else if (data.currentValue === null)
+                change = enums_1.PondBaseActions.REMOVE_FROM_POND;
+            handler(Object.values(this._getDB()), data.currentValue || data.oldValue, change);
+        });
+    }
+    /**
+     * @desc Add a document to the database
+     * @param doc - The document to add
+     */
+    addDoc(doc) {
+        return super.set(this._nanoid, doc);
+    }
+    /**
+     * @desc Left join two ponds on a key on this pond and a foreign key on the other pond
+     * @param pond - The pond to join with
+     * @param key - The key to join on
+     * @param foreignKey - The foreign key to join on
+     */
+    leftJoin(pond, key, foreignKey) {
+        const newPond = new PondBase();
+        for (const doc of this) {
+            const foreignDoc = pond.find((d) => d[foreignKey] === doc.doc[key]);
+            newPond.set(doc.id, { ...doc.doc, [key]: (foreignDoc === null || foreignDoc === void 0 ? void 0 : foreignDoc.doc) || null });
+        }
+        return newPond;
+    }
+}
+exports.PondBase = PondBase;

package/pondBase/pondBase.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pondBase_1 = require("./pondBase");
+const enums_1 = require("./enums");
+describe('PondBase', () => {
+    it('should be able to take in a subscriber', () => {
+        const base = new pondBase_1.PondBase();
+        expect(base['_broadcast']['_subscribers'].size).toBe(0);
+        const mockSubscriber = jest.fn();
+        base.subscribe(mockSubscriber);
+        expect(base['_broadcast']['_subscribers'].size).toBe(1);
+    });
+    it('should be able to remove a subscriber', () => {
+        const base = new pondBase_1.PondBase();
+        expect(base['_broadcast']['_subscribers'].size).toBe(0);
+        const mockSubscriber = jest.fn();
+        const subscription = base.subscribe(mockSubscriber);
+        expect(base['_broadcast']['_subscribers'].size).toBe(1);
+        subscription.unsubscribe();
+        expect(base['_broadcast']['_subscribers'].size).toBe(0);
+    });
+    it('should fire the subscriber when a document is added', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
+        base.subscribe(mockSubscriber);
+        base.set('test', { name: 'test' });
+        expect(mockSubscriber).toBeCalled();
+        expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
+    });
+    it('should fire the subscriber when a document is removed', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
+        base.subscribe(mockSubscriber);
+        const data = base.set('test', { name: 'test' });
+        expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
+        mockSubscriber.mockClear();
+        data.removeDoc();
+        expect(mockSubscriber).toBeCalledWith([], { name: "test" }, enums_1.PondBaseActions.REMOVE_FROM_POND);
+    });
+    it('should fire the subscriber when a document is updated', () => {
+        const base = new pondBase_1.PondBase();
+        const mockSubscriber = jest.fn();
+        base.subscribe(mockSubscriber);
+        const data = base.set('test', { name: 'test' });
+        expect(mockSubscriber).toBeCalledWith([{ name: "test" }], { name: "test" }, enums_1.PondBaseActions.ADD_TO_POND);
+        mockSubscriber.mockClear();
+        data.updateDoc({ name: 'test2' });
+        expect(mockSubscriber).toBeCalledWith([{ name: "test2" }], { name: "test2" }, enums_1.PondBaseActions.UPDATE_IN_POND);
+    });
+    it('should add a document to the database', () => {
+        var _a, _b;
+        const base = new pondBase_1.PondBase();
+        const data = base.addDoc({ name: 'test' });
+        expect(data.id).toBeDefined();
+        expect((_a = base.get(data.id)) === null || _a === void 0 ? void 0 : _a.doc).toEqual(data.doc);
+        expect((_b = base.get(data.id)) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test' });
+    });
+    it('should left join with another pond', () => {
+        const owners = new pondBase_1.PondBase();
+        const pets = new pondBase_1.PondBase();
+        owners.addDoc({ name: 'test', age: 10 });
+        owners.set('test2', { name: 'test2', age: 12 });
+        pets.addDoc({ name: 'test', owner: 'test' });
+        pets.addDoc({ name: 'test2', owner: 'test2' });
+        pets.set('test3', { name: 'test3', owner: 'test3' });
+        const joined = pets.leftJoin(owners, 'owner', 'name');
+        expect([...joined].map(({ doc }) => doc)).toEqual([
+            { name: 'test', owner: { name: 'test', age: 10 } },
+            { name: 'test2', owner: { name: 'test2', age: 12 } },
+            { name: 'test3', owner: null }
+        ]);
+    });
+    it('should be able to get the keys', () => {
+        const base = new pondBase_1.PondBase();
+        base.set('test', { name: 'test' });
+        base.set('test2', { name: 'test2' });
+        expect(base.keys).toEqual(['test', 'test2']);
+    });
+    it('should be able to get the values', () => {
+        const base = new pondBase_1.PondBase();
+        base.addDoc({ name: 'test' });
+        base.set('test2', { name: 'test2' });
+        expect(base.values).toEqual([{ name: 'test' }, { name: 'test2' }]);
+    });
+    it('should be able to upsert a document', () => {
+        var _a, _b;
+        const base = new pondBase_1.PondBase();
+        base.upsert('test', { name: 'test' });
+        expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toEqual({ name: 'test' });
+        base.upsert('test', { name: 'test2' });
+        expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test2' });
+    });
+    it('should be able to getOrCreate a document with a function', () => {
+        var _a, _b;
+        const base = new pondBase_1.PondBase();
+        base.getOrCreate('test', () => ({ name: 'test' }));
+        expect((_a = base.get('test')) === null || _a === void 0 ? void 0 : _a.doc).toEqual({ name: 'test' });
+        base.getOrCreate('test', () => ({ name: 'test2' }));
+        expect((_b = base.get('test')) === null || _b === void 0 ? void 0 : _b.doc).toEqual({ name: 'test' });
+    });
+});