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

package/dist/plugins/index.js

@@ -0,0 +1,2328 @@
+var __webpack_modules__ = ({
+"./src/assertions/index.ts": 
+/*!*********************************!*\
+  !*** ./src/assertions/index.ts ***!
+  \*********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  assertDate: () => (assertDate),
+  assertInstanceOf: () => (assertInstanceOf),
+  assertIsArray: () => (assertIsArray),
+  assertIsNotNull: () => (assertIsNotNull),
+  assertString: () => (assertString)
+});
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utilities */ "./src/utilities/dates.ts");
+
+function assertDate(data) {
+    if ((0,_utilities__WEBPACK_IMPORTED_MODULE_0__.isDate)(data) === false) {
+        throw new TypeError('Value is not a Date');
+    }
+}
+function assertIsNotNull(data, message) {
+    if (data == null) {
+        throw new TypeError(message ?? 'Assertion failed, data is null');
+    }
+}
+function assertIsArray(data, message) {
+    if (!Array.isArray(data)) {
+        throw new TypeError(message ?? 'Assertion failed, data is not of type Array');
+    }
+}
+function assertString(data, message) {
+    if (typeof data !== "string") {
+        throw new TypeError(message ?? 'Assertion failed, data is not of type String');
+    }
+}
+function assertInstanceOf(value, Instance) {
+    if (value instanceof Instance) {
+        return;
+    }
+    if (value != null && typeof value === "object" && "constructor" in value) {
+        throw new TypeError(`Value is not instance of type.  Type: ${value.constructor.name}`);
+    }
+    throw new TypeError(`Value is not instance of type`);
+}
+
+
+}),
+"./src/collections/Changes.ts": 
+/*!************************************!*\
+  !*** ./src/collections/Changes.ts ***!
+  \************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  BulkPersistChanges: () => (BulkPersistChanges),
+  BulkPersistResult: () => (BulkPersistResult),
+  SchemaPersistChanges: () => (SchemaPersistChanges),
+  SchemaPersistResult: () => (SchemaPersistResult)
+});
+/* ESM import */var _TagCollection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./TagCollection */ "./src/collections/TagCollection.ts");
+
+class BulkPersistResult extends Map {
+    resolve(schemaId) {
+        if (this.has(schemaId)) {
+            return this.get(schemaId);
+        }
+        this.set(schemaId, new SchemaPersistResult());
+        return this.get(schemaId);
+    }
+    get(schemaId) {
+        return super.get(schemaId);
+    }
+    get aggregate() {
+        return {
+            size: this.aggregateSize,
+            adds: this.aggregateAddsSize,
+            updates: this.aggregateUpdatesSize,
+            removes: this.aggregateRemovesSize
+        };
+    }
+    get aggregateSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.total;
+        }
+        return count;
+    }
+    get aggregateAddsSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.adds.length;
+        }
+        return count;
+    }
+    get aggregateUpdatesSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.updates.length;
+        }
+        return count;
+    }
+    get aggregateRemovesSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.removes.length;
+        }
+        return count;
+    }
+}
+class BulkPersistChanges extends Map {
+    resolve(schemaId) {
+        if (this.has(schemaId)) {
+            return this.get(schemaId);
+        }
+        this.set(schemaId, new SchemaPersistChanges());
+        return this.get(schemaId);
+    }
+    get(schemaId) {
+        return super.get(schemaId);
+    }
+    get aggregate() {
+        return {
+            size: this.aggregateSize,
+            adds: this.aggregateAddsSize,
+            updates: this.aggregateUpdatesSize,
+            removes: this.aggregateRemovesSize
+        };
+    }
+    get aggregateSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.total;
+        }
+        return count;
+    }
+    get aggregateAddsSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.adds.length;
+        }
+        return count;
+    }
+    get aggregateUpdatesSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.updates.length;
+        }
+        return count;
+    }
+    get aggregateRemovesSize() {
+        let count = 0;
+        for (const [, result] of this) {
+            count += result.removes.length;
+        }
+        return count;
+    }
+    /**
+     * Ensures the result has the same result sets as the change sets
+     * @returns
+     */
+    toResult() {
+        const result = new BulkPersistResult();
+        for (const [schemaId] of this) {
+            result.set(schemaId, new SchemaPersistResult());
+        }
+        return result;
+    }
+}
+class SchemaPersistChanges {
+    adds = [];
+    updates = [];
+    removes = [];
+    tags = new _TagCollection__WEBPACK_IMPORTED_MODULE_0__.TagCollection();
+    get hasItems() {
+        return this.total > 0;
+    }
+    get total() {
+        return this.adds.length + this.updates.length + this.removes.length;
+    }
+}
+class SchemaPersistResult {
+    adds = [];
+    updates = [];
+    removes = [];
+    get hasItems() {
+        return this.total > 0;
+    }
+    get total() {
+        return this.adds.length + this.updates.length + this.removes.length;
+    }
+}
+
+
+}),
+"./src/collections/TagCollection.ts": 
+/*!******************************************!*\
+  !*** ./src/collections/TagCollection.ts ***!
+  \******************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  TagCollection: () => (TagCollection)
+});
+class TagCollection {
+    data = new Map();
+    _size = 0;
+    get size() {
+        return this._size;
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    set(key, tag) {
+        this._size++;
+        return this.data.set(key, tag);
+    }
+    delete(key) {
+        const result = this.data.delete(key);
+        if (result) {
+            this._size--;
+        }
+        return result;
+    }
+    setMany(keys, tag) {
+        this._size += keys.length;
+        for (let i = 0, length = keys.length; i < length; i++) {
+            const key = keys[i];
+            this.set(key, tag);
+        }
+    }
+    combine(tags) {
+        for (const [key, value] of tags) {
+            this.data.set(key, value);
+        }
+    }
+    values() {
+        return this.data.values();
+    }
+    keys() {
+        return this.data.keys();
+    }
+    [Symbol.dispose]() {
+        this.data = null;
+    }
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+}
+
+
+}),
+"./src/expressions/utils.ts": 
+/*!**********************************!*\
+  !*** ./src/expressions/utils.ts ***!
+  \**********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  forEach: () => (forEach),
+  getProperties: () => (getProperties),
+  isPropertyExpression: () => (isPropertyExpression)
+});
+/**
+ * Extracts all properties referenced in an expression
+ * @param expression The expression to analyze
+ * @returns Array of PropertyInfo objects referenced in the expression
+ */
+function getProperties(expression) {
+    const properties = [];
+    function traverse(expr) {
+        // If this is a property expression, add it to our collection
+        if (expr.type === "property") {
+            properties.push(expr.property);
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            traverse(expr.left);
+        }
+        if (expr.right) {
+            traverse(expr.right);
+        }
+    }
+    traverse(expression);
+    return properties;
+}
+function isPropertyExpression(expression) {
+    return expression.type === "property";
+}
+function forEach(expression, callback) {
+    function traverse(expr) {
+        // Call the callback for this expression
+        // If callback returns false, stop traversing
+        if (!callback(expr)) {
+            return false;
+        }
+        // Traverse left and right expressions if they exist
+        if (expr.left) {
+            if (!traverse(expr.left)) {
+                return false;
+            }
+        }
+        if (expr.right) {
+            if (!traverse(expr.right)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    traverse(expression);
+}
+
+
+}),
+"./src/performance/index.ts": 
+/*!**********************************!*\
+  !*** ./src/performance/index.ts ***!
+  \**********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  measure: () => (measure),
+  now: () => (now)
+});
+const measurements = {};
+const now = () => {
+    if (typeof performance !== 'undefined' && performance.now) {
+        // Browser or modern Node.js
+        return performance.now();
+    }
+    // Fallback for older environments
+    return Date.now();
+};
+const measure = {
+    start: (name) => {
+        measurements[name] = now();
+    },
+    end: (name) => {
+        const start = measurements[name];
+        delete measurements[name];
+        const delta = now() - start;
+        console.log(`[ROUTIER] - Performance: ${name} took ${delta}`);
+    }
+};
+
+
+}),
+"./src/pipeline/TrampolinePipeline.ts": 
+/*!********************************************!*\
+  !*** ./src/pipeline/TrampolinePipeline.ts ***!
+  \********************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  AsyncPipeline: () => (AsyncPipeline),
+  TrampolinePipeline: () => (TrampolinePipeline),
+  WorkPipeline: () => (WorkPipeline)
+});
+/* ESM import */var _results__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../results */ "./src/results/Result.ts");
+
+class TrampolinePipeline {
+    _list = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(initialData, done) {
+        this._hasErrored = false; // Reset error flag on new execution
+        if (this._list.length === 0) {
+            queueMicrotask(() => done(initialData));
+            return;
+        }
+        let index = 0;
+        let currentData = initialData;
+        let isRunning = false; // Guard against overlapping trampoline calls
+        try {
+            // --- Revised Completion Logic --- (Moved up for clarity)
+            const finalStepSentinel = () => {
+                // Only call done if no error has occurred
+                if (!this._hasErrored) {
+                    queueMicrotask(() => done(currentData));
+                }
+                return null; // Stop the trampoline
+            };
+            const createStepRevised = (idx) => {
+                return () => {
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
+                    if (idx >= this._list.length) {
+                        return finalStepSentinel(); // Execute the dedicated final step
+                    }
+                    const processor = this._list[idx];
+                    // Initialize syncCallbackResult to null to satisfy StepResult type
+                    let syncCallbackResult = null;
+                    let calledSync = false;
+                    try {
+                        processor(currentData, (result, error) => {
+                            // --- Error Handling ---
+                            if (error) {
+                                console.error(`Error reported by processor at index ${idx}:`, error);
+                                this._hasErrored = true; // Set flag
+                                // Throw the error to be caught by outer try...catch blocks
+                                throw error;
+                            }
+                            // --- /Error Handling ---
+                            // If no error, proceed as before
+                            currentData = result;
+                            index = idx + 1; // Update index for the next step
+                            const nextStep = createStepRevised(index); // Use updated index
+                            if (isRunning) {
+                                // Callback was synchronous
+                                syncCallbackResult = nextStep; // Store next step function
+                                calledSync = true;
+                            }
+                            else {
+                                // Callback was asynchronous, restart trampoline
+                                trampoline(nextStep);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
+                            console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                            this._hasErrored = true;
+                        }
+                        // Rethrow to be caught by the trampoline's catch block
+                        throw error;
+                    }
+                    if (calledSync) {
+                        // Return the next step function for the sync loop
+                        return syncCallbackResult;
+                    }
+                    else {
+                        // Pause trampoline for async, loop will stop as step returns null
+                        return null;
+                    }
+                };
+            };
+            // The trampoline loop
+            const trampoline = (step) => {
+                if (isRunning) {
+                    return;
+                }
+                isRunning = true;
+                let currentStep = step;
+                while (typeof currentStep === 'function') {
+                    try {
+                        // Stop immediately if an error was flagged elsewhere
+                        if (this._hasErrored) {
+                            currentStep = null;
+                            break;
+                        }
+                        currentStep = currentStep(); // Execute step, get next step or null
+                    }
+                    catch (trampolineError) {
+                        // Catch errors propagated from step execution (processor or callback errors)
+                        if (!this._hasErrored) { // Avoid double logging
+                            console.error("Error during trampoline step execution:", trampolineError);
+                            this._hasErrored = true;
+                        }
+                        currentStep = null; // Stop the loop
+                        // We don't call `done` here because an error occurred.
+                        // The application should handle the uncaught exception if desired.
+                        break; // Explicitly break loop on error
+                    }
+                }
+                // Loop ends when currentStep is null or loop is broken by error
+                isRunning = false;
+                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            };
+            // --- Start the process ---
+            index = 0; // Reset index
+            currentData = initialData; // Reset data
+            trampoline(createStepRevised(0)); // Start with the revised step creator
+        }
+        catch (error) {
+            done(currentData, error);
+        }
+    }
+    pipe(processor) {
+        this._list.push(processor);
+        return this;
+    }
+    pipeEach(items, fn, map) {
+        for (let i = 0, length = items.length; i < length; i++) {
+            this.pipe((previous, done) => {
+                fn(map(previous, _results__WEBPACK_IMPORTED_MODULE_0__.Result.success(items[i])), done);
+            });
+        }
+    }
+}
+class AsyncPipeline {
+    _list = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(done) {
+        this._hasErrored = false; // Reset error flag on new execution
+        let currentData = [];
+        if (this._list.length === 0) {
+            queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
+            return;
+        }
+        let index = 0;
+        let isRunning = false; // Guard against overlapping trampoline calls
+        try {
+            // --- Revised Completion Logic --- (Moved up for clarity)
+            const finalStepSentinel = () => {
+                // Only call done if no error has occurred
+                if (!this._hasErrored) {
+                    queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success(currentData)));
+                }
+                return null; // Stop the trampoline
+            };
+            const createStepRevised = (idx) => {
+                return () => {
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
+                    if (idx >= this._list.length) {
+                        return finalStepSentinel(); // Execute the dedicated final step
+                    }
+                    const [payload, processor] = this._list[idx];
+                    // Initialize syncCallbackResult to null to satisfy StepResult type
+                    let syncCallbackResult = null;
+                    let calledSync = false;
+                    try {
+                        processor(payload, (result) => {
+                            // --- Error Handling ---
+                            if (result.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                                console.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
+                                this._hasErrored = true; // Set flag
+                                // Throw the error to be caught by outer try...catch blocks
+                                throw result.error;
+                            }
+                            // --- /Error Handling ---
+                            // If no error, proceed as before
+                            currentData.push(result.data);
+                            index = idx + 1; // Update index for the next step
+                            const nextStep = createStepRevised(index); // Use updated index
+                            if (isRunning) {
+                                // Callback was synchronous
+                                syncCallbackResult = nextStep; // Store next step function
+                                calledSync = true;
+                            }
+                            else {
+                                // Callback was asynchronous, restart trampoline
+                                trampoline(nextStep);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
+                            console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                            this._hasErrored = true;
+                        }
+                        // Rethrow to be caught by the trampoline's catch block
+                        throw error;
+                    }
+                    if (calledSync) {
+                        // Return the next step function for the sync loop
+                        return syncCallbackResult;
+                    }
+                    else {
+                        // Pause trampoline for async, loop will stop as step returns null
+                        return null;
+                    }
+                };
+            };
+            // The trampoline loop
+            const trampoline = (step) => {
+                if (isRunning) {
+                    return;
+                }
+                isRunning = true;
+                let currentStep = step;
+                while (typeof currentStep === 'function') {
+                    try {
+                        // Stop immediately if an error was flagged elsewhere
+                        if (this._hasErrored) {
+                            currentStep = null;
+                            break;
+                        }
+                        currentStep = currentStep(); // Execute step, get next step or null
+                    }
+                    catch (trampolineError) {
+                        // Catch errors propagated from step execution (processor or callback errors)
+                        if (!this._hasErrored) { // Avoid double logging
+                            console.error("Error during trampoline step execution:", trampolineError);
+                            this._hasErrored = true;
+                        }
+                        currentStep = null; // Stop the loop
+                        // We don't call `done` here because an error occurred.
+                        // The application should handle the uncaught exception if desired.
+                        break; // Explicitly break loop on error
+                    }
+                }
+                // Loop ends when currentStep is null or loop is broken by error
+                isRunning = false;
+                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            };
+            // --- Start the process ---
+            index = 0; // Reset index
+            trampoline(createStepRevised(0)); // Start with the revised step creator
+        }
+        catch (error) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.error(error));
+        }
+    }
+    pipe(data, processor) {
+        this._list.push([data, processor]);
+    }
+    pipeEach(items, processor) {
+        for (let i = 0, length = items.length; i < length; i++) {
+            this.pipe(items[i], processor);
+        }
+    }
+}
+/**
+ * Processes functions with callbacks asynchronously.
+ *
+ * This pipeline handles work items that contain callback functions,
+ * executing them in an asynchronous manner while maintaining proper
+ * flow control and error handling.
+ */
+class WorkPipeline {
+    unitsOfWork = [];
+    _hasErrored = false; // Flag to prevent calling done on error
+    filter(done) {
+        this._hasErrored = false; // Reset error flag on new execution
+        if (this.unitsOfWork.length === 0) {
+            queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
+            return;
+        }
+        let index = 0;
+        let isRunning = false; // Guard against overlapping trampoline calls
+        try {
+            // --- Revised Completion Logic --- (Moved up for clarity)
+            const finalStepSentinel = () => {
+                // Only call done if no error has occurred
+                if (!this._hasErrored) {
+                    queueMicrotask(() => done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success()));
+                }
+                return null; // Stop the trampoline
+            };
+            const createStepRevised = (idx) => {
+                return () => {
+                    if (this._hasErrored)
+                        return null; // Stop if an error occurred elsewhere
+                    if (idx >= this.unitsOfWork.length) {
+                        return finalStepSentinel(); // Execute the dedicated final step
+                    }
+                    const processor = this.unitsOfWork[idx];
+                    // Initialize syncCallbackResult to null to satisfy StepResult type
+                    let syncCallbackResult = null;
+                    let calledSync = false;
+                    try {
+                        processor((result) => {
+                            // --- Error Handling ---
+                            if (result.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                                console.error(`Error reported by AsyncPipeline at index ${idx}:`, result.error);
+                                this._hasErrored = true; // Set flag
+                                // Throw the error to be caught by outer try...catch blocks
+                                throw result.error;
+                            }
+                            // --- /Error Handling ---
+                            // If no error, proceed as before
+                            index = idx + 1; // Update index for the next step
+                            const nextStep = createStepRevised(index); // Use updated index
+                            if (isRunning) {
+                                // Callback was synchronous
+                                syncCallbackResult = nextStep; // Store next step function
+                                calledSync = true;
+                            }
+                            else {
+                                // Callback was asynchronous, restart trampoline
+                                trampoline(nextStep);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        if (!this._hasErrored) { // Check flag to avoid double logging if error was from callback
+                            console.error(`Error thrown by processor at index ${idx} or its callback:`, error);
+                            this._hasErrored = true;
+                        }
+                        // Rethrow to be caught by the trampoline's catch block
+                        throw error;
+                    }
+                    if (calledSync) {
+                        // Return the next step function for the sync loop
+                        return syncCallbackResult;
+                    }
+                    else {
+                        // Pause trampoline for async, loop will stop as step returns null
+                        return null;
+                    }
+                };
+            };
+            // The trampoline loop
+            const trampoline = (step) => {
+                if (isRunning) {
+                    return;
+                }
+                isRunning = true;
+                let currentStep = step;
+                while (typeof currentStep === 'function') {
+                    try {
+                        // Stop immediately if an error was flagged elsewhere
+                        if (this._hasErrored) {
+                            currentStep = null;
+                            break;
+                        }
+                        currentStep = currentStep(); // Execute step, get next step or null
+                    }
+                    catch (trampolineError) {
+                        // Catch errors propagated from step execution (processor or callback errors)
+                        if (!this._hasErrored) { // Avoid double logging
+                            console.error("Error during trampoline step execution:", trampolineError);
+                            this._hasErrored = true;
+                        }
+                        currentStep = null; // Stop the loop
+                        // We don't call `done` here because an error occurred.
+                        // The application should handle the uncaught exception if desired.
+                        break; // Explicitly break loop on error
+                    }
+                }
+                // Loop ends when currentStep is null or loop is broken by error
+                isRunning = false;
+                // Completion check is now handled by finalStepSentinel ensuring `done` isn't called on error.
+            };
+            // --- Start the process ---
+            index = 0; // Reset index
+            trampoline(createStepRevised(0)); // Start with the revised step creator
+        }
+        catch (error) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.Result.error(error));
+        }
+    }
+    pipe(work) {
+        this.unitsOfWork.push(work);
+    }
+}
+
+
+}),
+"./src/plugins/EphemeralDataPlugin.ts": 
+/*!********************************************!*\
+  !*** ./src/plugins/EphemeralDataPlugin.ts ***!
+  \********************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  EphemeralDataPlugin: () => (EphemeralDataPlugin)
+});
+/* ESM import */var _assertions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../assertions */ "./src/assertions/index.ts");
+/* ESM import */var _pipeline__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../pipeline */ "./src/pipeline/TrampolinePipeline.ts");
+/* ESM import */var ___WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! . */ "./src/plugins/translators/JsonTranslator.ts");
+/* ESM import */var _results__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../results */ "./src/results/Result.ts");
+
+
+
+
+class EphemeralDataPlugin {
+    databaseName;
+    constructor(databaseName) {
+        this.databaseName = databaseName;
+    }
+    bulkPersist(event, done) {
+        try {
+            const pipeline = new _pipeline__WEBPACK_IMPORTED_MODULE_0__.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(_results__WEBPACK_IMPORTED_MODULE_1__.Result.success());
+                            return;
+                        }
+                        const result = bulkPersistResult.get(schemaId);
+                        const schema = event.schemas.get(schemaId);
+                        (0,_assertions__WEBPACK_IMPORTED_MODULE_2__.assertIsNotNull)(schema);
+                        const collection = this.resolveCollection(schema);
+                        collection.load(readResult => {
+                            if (readResult.ok === _results__WEBPACK_IMPORTED_MODULE_1__.Result.ERROR) {
+                                d(readResult);
+                                return;
+                            }
+                            for (let i = 0, length = adds.length; i < length; i++) {
+                                collection.add(adds[i]);
+                                result.adds.push(adds[i]);
+                            }
+                            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 === _results__WEBPACK_IMPORTED_MODULE_1__.Result.ERROR) {
+                                    d(saveResult);
+                                    return;
+                                }
+                                d(_results__WEBPACK_IMPORTED_MODULE_1__.Result.success());
+                            });
+                        });
+                    }
+                    catch (e) {
+                        d(_results__WEBPACK_IMPORTED_MODULE_1__.Result.error(e));
+                    }
+                });
+            }
+            let successCount = 0;
+            pipeline.filter((asyncResult) => {
+                if (asyncResult.ok !== _results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.SUCCESS) {
+                    if (successCount === 0) {
+                        done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.error(event.id, asyncResult.error));
+                        return;
+                    }
+                    done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.partial(event.id, bulkPersistResult, asyncResult.error));
+                    return;
+                }
+                successCount++;
+                done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.success(event.id, bulkPersistResult));
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.error(event.id, e));
+        }
+    }
+    query(event, done) {
+        try {
+            const { operation } = event;
+            const translator = new ___WEBPACK_IMPORTED_MODULE_3__.JsonTranslator(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 === _results__WEBPACK_IMPORTED_MODULE_1__.Result.ERROR) {
+                    done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.error(event.id, r.error));
+                    return;
+                }
+                const translated = translator.translate(collection.records);
+                done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.success(event.id, translated));
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_1__.PluginEventResult.error(event.id, e));
+        }
+    }
+}
+
+
+}),
+"./src/plugins/capabilities/DbPluginCapability.ts": 
+/*!********************************************************!*\
+  !*** ./src/plugins/capabilities/DbPluginCapability.ts ***!
+  \********************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DbPluginCapability: () => (DbPluginCapability)
+});
+/**
+ * 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.
+ */
+class DbPluginCapability {
+    events = {};
+    add(name, callback) {
+        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;
+    }
+    resolve(name) {
+        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(plugin) {
+        const methodWrappers = [
+            { 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, done) => {
+                    events.before?.(event, done);
+                    if (events.after) {
+                        return original(event, (result) => {
+                            events.after(result);
+                            done(result);
+                        });
+                    }
+                    return original(event, done);
+                });
+            }
+        }
+    }
+}
+
+
+}),
+"./src/plugins/capabilities/index.ts": 
+/*!*******************************************!*\
+  !*** ./src/plugins/capabilities/index.ts ***!
+  \*******************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DbPluginCapability: () => (/* reexport safe */ _DbPluginCapability__WEBPACK_IMPORTED_MODULE_0__.DbPluginCapability),
+  DbPluginLoggingCapability: () => (/* reexport safe */ _logging__WEBPACK_IMPORTED_MODULE_1__.DbPluginLoggingCapability)
+});
+/* ESM import */var _DbPluginCapability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DbPluginCapability */ "./src/plugins/capabilities/DbPluginCapability.ts");
+/* ESM import */var _logging__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./logging */ "./src/plugins/capabilities/logging/index.ts");
+
+
+
+
+}),
+"./src/plugins/capabilities/logging/DbPluginLoggingCapability.ts": 
+/*!***********************************************************************!*\
+  !*** ./src/plugins/capabilities/logging/DbPluginLoggingCapability.ts ***!
+  \***********************************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DbPluginLoggingCapability: () => (DbPluginLoggingCapability)
+});
+/* ESM import */var _DbPluginCapability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../DbPluginCapability */ "./src/plugins/capabilities/DbPluginCapability.ts");
+/* ESM import */var _performance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../performance */ "./src/performance/index.ts");
+
+
+class DbPluginLoggingCapability {
+    logStyle = 'redux';
+    maxLogEntries = 100;
+    logHistory = [];
+    queryPerformance = new Map();
+    constructor(options) {
+        this.logStyle = options?.logStyle ?? 'redux';
+        this.maxLogEntries = options?.maxLogEntries ?? 100;
+    }
+    apply(plugin) {
+        const baseCapability = new _DbPluginCapability__WEBPACK_IMPORTED_MODULE_0__.DbPluginCapability();
+        const pluginName = plugin.constructor.name;
+        // Query logging
+        baseCapability
+            .add("queryStart", (event) => {
+            this.logReduxAction('QUERY_REQUEST', event.id, {
+                plugin: pluginName,
+                collection: event.operation.schema.collectionName,
+                schemaId: event.operation.schema.id,
+                changeTracking: event.operation.changeTracking
+            }, {
+                timestamp: new Date().toISOString(),
+                options: this.extractQueryOptions(event.operation)
+            });
+            this.addToHistory('QUERY_REQUEST', event);
+            this.queryPerformance.set(event.id, (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)());
+        })
+            .add("queryComplete", (result) => {
+            const start = this.queryPerformance.get(result.id);
+            this.queryPerformance.delete(result.id);
+            const end = (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)();
+            const duration = start == null ? -1 : end - start;
+            const performance = this.getPerformanceIndicator(duration);
+            if (result.ok === 'success') {
+                this.logReduxAction('QUERY_SUCCESS', result.id, {
+                    plugin: pluginName,
+                    resultCount: this.getResultCount(result.data),
+                    resultType: this.getResultType(result.data)
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            else {
+                this.logReduxAction('QUERY_ERROR', result.id, {
+                    plugin: pluginName,
+                    error: result.error?.message || result.error,
+                    isCritical: false
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            this.addToHistory('QUERY_RESULT', { result, duration });
+        });
+        // Bulk operations logging
+        baseCapability
+            .add("bulkPersistStart", (event) => {
+            const totalOperations = event.operation.aggregate.size;
+            this.logReduxAction('BULK_OPERATIONS_REQUEST', event.id, {
+                plugin: pluginName,
+                totalOperations,
+                schemaCount: event.schemas.size,
+                operations: this.extractBulkOperations(event.operation)
+            }, {
+                timestamp: new Date().toISOString()
+            });
+            this.addToHistory('BULK_OPERATIONS_REQUEST', event);
+            this.queryPerformance.set(event.id, (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)());
+        })
+            .add("bulkPersistComplete", (result) => {
+            const start = this.queryPerformance.get(result.id);
+            this.queryPerformance.delete(result.id);
+            const end = (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)();
+            const duration = start == null ? -1 : end - start;
+            const performance = this.getPerformanceIndicator(duration);
+            if (result.ok === 'success') {
+                this.logReduxAction('BULK_OPERATIONS_SUCCESS', result.id, {
+                    plugin: pluginName,
+                    completedOperations: this.countCompletedOperations(result.data),
+                    schemaCount: result.data.size
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            else {
+                this.logReduxAction('BULK_OPERATIONS_ERROR', result.id, {
+                    plugin: pluginName,
+                    error: result.error?.message || result.error,
+                    isCritical: false
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            this.addToHistory('BULK_OPERATIONS_RESULT', { result, duration });
+        });
+        // Destroy logging
+        baseCapability
+            .add("destroyStart", (event) => {
+            this.logReduxAction('DESTROY_REQUEST', event.id, {
+                plugin: pluginName,
+                schemaCount: event.schemas.size
+            }, {
+                timestamp: new Date().toISOString()
+            });
+            this.addToHistory('DESTROY_REQUEST', event);
+            this.queryPerformance.set(event.id, (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)());
+        })
+            .add("destroyComplete", (result) => {
+            const start = this.queryPerformance.get(result.id);
+            this.queryPerformance.delete(result.id);
+            const end = (0,_performance__WEBPACK_IMPORTED_MODULE_1__.now)();
+            const duration = start == null ? -1 : end - start;
+            const performance = this.getPerformanceIndicator(duration);
+            if (result.ok === 'success') {
+                this.logReduxAction('DESTROY_SUCCESS', result.id, {
+                    plugin: pluginName
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            else {
+                this.logReduxAction('DESTROY_ERROR', result.id, {
+                    plugin: pluginName,
+                    error: result.error?.message || result.error
+                }, {
+                    duration: `${duration.toFixed(4)}ms`,
+                    performance: performance.label,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            this.addToHistory('DESTROY_RESULT', { result, duration });
+        });
+        baseCapability.apply(plugin);
+    }
+    getPerformanceIndicator(duration) {
+        if (duration > 1000)
+            return { emoji: '🐌', color: '#ef4444', label: 'SLOW', level: 'error' };
+        if (duration > 500)
+            return { emoji: '🐢', color: '#f97316', label: 'MEDIUM', level: 'warning' };
+        if (duration > 100)
+            return { emoji: '⚡', color: '#eab308', label: 'FAST', level: 'info' };
+        return { emoji: '🚀', color: '#22c55e', label: 'INSTANT', level: 'success' };
+    }
+    logReduxAction(action, eventId, payload, meta) {
+        if (this.logStyle !== 'redux')
+            return;
+        const timestamp = new Date().toISOString();
+        console.groupCollapsed(`%c${action} %c@ ${timestamp}`, 'color: #3b82f6; font-weight: bold; font-size: 14px;', 'color: #6b7280; font-size: 12px;');
+        console.group('Action');
+        console.log('Type:', action);
+        console.log('Event ID:', eventId);
+        console.log('Timestamp:', timestamp);
+        console.groupEnd();
+        if (payload) {
+            console.group('Payload');
+            console.log(payload);
+            console.groupEnd();
+        }
+        if (meta) {
+            console.group('Meta');
+            console.log(meta);
+            console.groupEnd();
+        }
+        console.groupEnd();
+    }
+    extractQueryOptions(query) {
+        const options = {};
+        if (query.options) {
+            ['skip', 'take', 'sort', 'filter', 'map', 'distinct'].forEach(type => {
+                try {
+                    const values = query.options.getValues(type);
+                    if (values.length > 0)
+                        options[type] = values;
+                }
+                catch (e) {
+                    // Skip if option type not supported
+                }
+            });
+        }
+        return options;
+    }
+    getResultCount(result) {
+        if (Array.isArray(result))
+            return `${result.length} items`;
+        if (result !== null && typeof result === 'object')
+            return '1 object';
+        return '1 primitive';
+    }
+    getResultType(result) {
+        if (Array.isArray(result))
+            return 'array';
+        if (result !== null && typeof result === 'object')
+            return 'object';
+        return typeof result;
+    }
+    extractBulkOperations(operations) {
+        const aggregate = operations.aggregate;
+        return {
+            adds: aggregate.adds,
+            updates: aggregate.updates,
+            removes: aggregate.removes
+        };
+    }
+    countCompletedOperations(result) {
+        return result?.aggregate.size || 0;
+    }
+    addToHistory(type, data) {
+        this.logHistory.push({
+            type,
+            timestamp: Date.now(),
+            data
+        });
+        if (this.logHistory.length > this.maxLogEntries) {
+            this.logHistory = this.logHistory.slice(-this.maxLogEntries);
+        }
+    }
+    generateId() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+    // Public methods for debugging
+    getLogHistory() {
+        return [...this.logHistory];
+    }
+    clearLogHistory() {
+        this.logHistory = [];
+    }
+}
+
+
+}),
+"./src/plugins/capabilities/logging/index.ts": 
+/*!***************************************************!*\
+  !*** ./src/plugins/capabilities/logging/index.ts ***!
+  \***************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DbPluginLoggingCapability: () => (/* reexport safe */ _DbPluginLoggingCapability__WEBPACK_IMPORTED_MODULE_0__.DbPluginLoggingCapability)
+});
+/* ESM import */var _DbPluginLoggingCapability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DbPluginLoggingCapability */ "./src/plugins/capabilities/logging/DbPluginLoggingCapability.ts");
+
+
+
+}),
+"./src/plugins/query/Query.ts": 
+/*!************************************!*\
+  !*** ./src/plugins/query/Query.ts ***!
+  \************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Query: () => (Query)
+});
+/* ESM import */var _QueryOptionsCollection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./QueryOptionsCollection */ "./src/plugins/query/QueryOptionsCollection.ts");
+
+class Query {
+    options;
+    schema;
+    enableChangeTrackingOverride;
+    constructor(options, schema, enableChangeTrackingOverride) {
+        this.schema = schema;
+        this.options = options;
+        this.enableChangeTrackingOverride = enableChangeTrackingOverride;
+    }
+    // boolean value whether or not change tracking can be enabled on the query result
+    get changeTracking() {
+        if (this.enableChangeTrackingOverride != null) {
+            return this.enableChangeTrackingOverride;
+        }
+        const map = this.options.getValues("map");
+        const count = this.options.has("count");
+        const max = this.options.has("max");
+        const min = this.options.has("min");
+        const sum = this.options.has("sum");
+        if (map.some(x => x.fields.length > 0)) {
+            return false;
+        }
+        if (count === true ||
+            max === true ||
+            min === true ||
+            sum === true) {
+            return false;
+        }
+        return true;
+    }
+    static EMPTY(schema) {
+        return new Query(_QueryOptionsCollection__WEBPACK_IMPORTED_MODULE_0__.QueryOptionsCollection.EMPTY(), schema);
+    }
+    static isEmpty(query) {
+        return _QueryOptionsCollection__WEBPACK_IMPORTED_MODULE_0__.QueryOptionsCollection.isEmpty(query.options);
+    }
+    static toString(query) {
+        return JSON.stringify({
+            options: query.options.items,
+            schema: {
+                id: query.schema.id,
+                collectionName: query.schema.collectionName
+            },
+            changeTracking: query.changeTracking
+        });
+    }
+}
+
+
+}),
+"./src/plugins/query/QueryOptionsCollection.ts": 
+/*!*****************************************************!*\
+  !*** ./src/plugins/query/QueryOptionsCollection.ts ***!
+  \*****************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  QueryOptionsCollection: () => (QueryOptionsCollection)
+});
+/* ESM import */var _expressions_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../expressions/utils */ "./src/expressions/utils.ts");
+
+class QueryOptionsCollection {
+    options = new Map();
+    nextExecutionTarget = "database";
+    nextIndex = 0;
+    enumeratedItems = [];
+    get items() {
+        return this.options;
+    }
+    get isEmpty() {
+        return this.items.size === 0;
+    }
+    static EMPTY() {
+        return new QueryOptionsCollection();
+    }
+    static isEmpty(options) {
+        return options.isEmpty;
+    }
+    add(name, value) {
+        if (name === "map") {
+            const mapValue = value;
+            // Evaluate the map value to see if we are renaming properties, 
+            // if we are we need to perform everything after in memory
+            if (mapValue.fields.some(x => x.isRename === true) || mapValue.fields.some(x => x.property?.isUnmapped === true)) {
+                // Cut over to memory execution since we are renaming a property with .map
+                // We do not want to figure out how the new name flows through the entire query
+                this.nextExecutionTarget = "memory";
+            }
+        }
+        if (name === "filter") {
+            // Need to check for unmapped properties
+            const filterValue = value;
+            if (filterValue.expression.type === "not-parsable") {
+                this.nextExecutionTarget = "memory";
+            }
+            else {
+                (0,_expressions_utils__WEBPACK_IMPORTED_MODULE_0__.forEach)(filterValue.expression, (expression) => {
+                    if ((0,_expressions_utils__WEBPACK_IMPORTED_MODULE_0__.isPropertyExpression)(expression) && expression.property.isUnmapped) {
+                        // Cut over to memory execution, unmapped properties are not in the database and
+                        // cannot be queried
+                        this.nextExecutionTarget = "memory";
+                        return false;
+                    }
+                    return true;
+                });
+            }
+        }
+        const item = {
+            index: this.nextIndex,
+            option: {
+                name,
+                target: this.nextExecutionTarget,
+                value
+            }
+        };
+        this.nextIndex++;
+        const found = this.options.get(name);
+        this.options.set(name, [...found ?? [], item]);
+    }
+    split() {
+        this.resolveEnumeration();
+        const sortedItems = this.enumeratedItems.toSorted((a, b) => a.index - b.index);
+        const memoryQueryOptionsCollection = new QueryOptionsCollection();
+        const databaseQueryOptionsCollection = new QueryOptionsCollection();
+        for (let i = 0, length = sortedItems.length; i < length; i++) {
+            const sortedItem = sortedItems[i];
+            if (sortedItem.option.target === "database") {
+                databaseQueryOptionsCollection.add(sortedItem.option.name, sortedItem.option.value);
+                continue;
+            }
+            memoryQueryOptionsCollection.add(sortedItem.option.name, sortedItem.option.value);
+        }
+        return {
+            memory: memoryQueryOptionsCollection,
+            database: databaseQueryOptionsCollection
+        };
+    }
+    has(name) {
+        return this.options.has(name);
+    }
+    get(name) {
+        return this.options.get(name) ?? [];
+    }
+    getLast(name) {
+        this.resolveEnumeration();
+        for (let i = this.enumeratedItems.length - 1; i >= 0; i--) {
+            const item = this.enumeratedItems[i];
+            if (item.option.name === name) {
+                return item.option;
+            }
+        }
+        return null;
+    }
+    getValues(name) {
+        const found = this.options.get(name);
+        if (found == null) {
+            return [];
+        }
+        return found.map(w => w.option.value);
+    }
+    getEnumeration() {
+        return [...this.options.values()].flat().toSorted((a, b) => a.index - b.index);
+    }
+    resolveEnumeration() {
+        if (this.enumeratedItems.length != this.nextIndex) {
+            this.enumeratedItems = this.getEnumeration();
+        }
+    }
+    forEach(iterator) {
+        this.resolveEnumeration();
+        for (let i = 0, length = this.enumeratedItems.length; i < length; i++) {
+            iterator(this.enumeratedItems[i].option);
+        }
+    }
+}
+
+
+}),
+"./src/plugins/query/index.ts": 
+/*!************************************!*\
+  !*** ./src/plugins/query/index.ts ***!
+  \************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Query: () => (/* reexport safe */ _Query__WEBPACK_IMPORTED_MODULE_0__.Query),
+  QueryOptionsCollection: () => (/* reexport safe */ _QueryOptionsCollection__WEBPACK_IMPORTED_MODULE_1__.QueryOptionsCollection),
+  QueryOrdering: () => (/* reexport safe */ _types__WEBPACK_IMPORTED_MODULE_2__.QueryOrdering)
+});
+/* ESM import */var _Query__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Query */ "./src/plugins/query/Query.ts");
+/* ESM import */var _QueryOptionsCollection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./QueryOptionsCollection */ "./src/plugins/query/QueryOptionsCollection.ts");
+/* ESM import */var _types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./types */ "./src/plugins/query/types.ts");
+
+
+
+
+
+}),
+"./src/plugins/query/types.ts": 
+/*!************************************!*\
+  !*** ./src/plugins/query/types.ts ***!
+  \************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  QueryOrdering: () => (QueryOrdering)
+});
+var QueryOrdering;
+(function (QueryOrdering) {
+    QueryOrdering["Descending"] = "desc";
+    QueryOrdering["Ascending"] = "asc";
+})(QueryOrdering || (QueryOrdering = {}));
+
+
+}),
+"./src/plugins/replication/OptimisticReplicationDbPlugin.ts": 
+/*!******************************************************************!*\
+  !*** ./src/plugins/replication/OptimisticReplicationDbPlugin.ts ***!
+  \******************************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  OptimisticReplicationDbPlugin: () => (OptimisticReplicationDbPlugin)
+});
+/* ESM import */var _results__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../results */ "./src/results/Result.ts");
+/* ESM import */var _pipeline__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../pipeline */ "./src/pipeline/TrampolinePipeline.ts");
+/* ESM import */var _query__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../query */ "./src/plugins/query/Query.ts");
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../utilities */ "./src/utilities/uuid.ts");
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../utilities */ "./src/utilities/replication.ts");
+/* ESM import */var _collections__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../collections */ "./src/collections/Changes.ts");
+
+
+7;
+
+
+
+const getMemoryPluginCollectionSize = (plugin, schema) => {
+    if ("getCollectionSize" in plugin && typeof plugin.getCollectionSize === "function") {
+        return plugin.getCollectionSize(schema.collectionName);
+    }
+    throw new Error("Cannot get size of collection for MemoryPlugin, not an instance of MemoryPlugin");
+};
+class OptimisticReplicationDbPlugin {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    /**
+     * Creates a new OptimisticDbPluginReplicator that coordinates operations between a source database and its replicas.
+     *
+     * @param source The primary database plugin that will receive all operations first
+     * @param replicas Additional database plugins that will replicate operations from the source
+     * @returns A new DbPluginReplicator instance that manages the source-replica relationship
+     */
+    static create(plugins) {
+        return new OptimisticReplicationDbPlugin(plugins);
+    }
+    /**
+     * Will query the read plugin if there is one, otherwise the source plugin will be queried
+    */
+    query(event, done) {
+        try {
+            const readPlugin = this.plugins.read;
+            const sourcePlugin = this.plugins.source;
+            const collectionSize = getMemoryPluginCollectionSize(this.plugins.read, event.operation.schema);
+            if (collectionSize === 0) {
+                // nothing is hydrated, let's try and hydrate before querying
+                // Memory plugin might not be hydrated, lets hydrate it for the targeted schema only,
+                // Other queries will do the same and hydrate if needed
+                // We want to select all data here
+                sourcePlugin.query({
+                    id: (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)(8),
+                    schemas: event.schemas,
+                    // Select All Data
+                    operation: _query__WEBPACK_IMPORTED_MODULE_1__.Query.EMPTY(event.operation.schema)
+                }, (sourceResult) => {
+                    if (sourceResult.ok === _results__WEBPACK_IMPORTED_MODULE_2__.Result.ERROR) {
+                        done(sourceResult);
+                        return;
+                    }
+                    if (sourceResult == null || (Array.isArray(sourceResult.data) && sourceResult.data.length === 0)) {
+                        done(sourceResult);
+                        return;
+                    }
+                    if (Array.isArray(sourceResult.data) === false) {
+                        done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.error(event.id, "Query result is not an array"));
+                        return;
+                    }
+                    const changesCollection = new _collections__WEBPACK_IMPORTED_MODULE_3__.BulkPersistChanges();
+                    const schemaChanges = changesCollection.resolve(event.operation.schema.id);
+                    // Add the existing items into the persist payload as adds
+                    schemaChanges.adds = sourceResult.data;
+                    readPlugin.bulkPersist({
+                        id: (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)(8),
+                        schemas: event.schemas,
+                        operation: changesCollection
+                    }, (readPersistResult) => {
+                        if (readPersistResult.ok === _results__WEBPACK_IMPORTED_MODULE_2__.Result.ERROR) {
+                            done(readPersistResult);
+                            return;
+                        }
+                        // requery the read plugin
+                        readPlugin.query(event, done);
+                    });
+                });
+                return;
+            }
+            // Collection is hydrated for the targeted collection and should be in sync
+            readPlugin.query(event, (readResult) => {
+                if (readResult.ok === _results__WEBPACK_IMPORTED_MODULE_2__.Result.ERROR) {
+                    done(readResult);
+                    return;
+                }
+                done(readResult);
+                return;
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.error(event.id, e));
+        }
+    }
+    destroy(event, done) {
+        try {
+            const workPipeline = new _pipeline__WEBPACK_IMPORTED_MODULE_4__.WorkPipeline();
+            const plugins = [this.plugins.source, ...this.plugins.replicas];
+            for (let i = 0, length = plugins.length; i < length; i++) {
+                workPipeline.pipe((done) => plugins[i].destroy(event, done));
+            }
+            workPipeline.filter((result) => {
+                if (result.ok === _results__WEBPACK_IMPORTED_MODULE_2__.Result.ERROR) {
+                    done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.error(event.id, result.error));
+                    return;
+                }
+                done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.success(event.id));
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.error(event.id, e));
+        }
+    }
+    bulkPersist(event, done) {
+        try {
+            const workPipeline = new _pipeline__WEBPACK_IMPORTED_MODULE_4__.WorkPipeline();
+            const deferredPlugins = [this.plugins.source, ...this.plugins.replicas];
+            // Since we are doing optimistic, we insert into the read plugin first and assume later plugins will succeed
+            // This means the read plugin will generate ids for the source plugin
+            this.plugins.read.bulkPersist({
+                id: (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)(8),
+                operation: event.operation,
+                schemas: event.schemas
+            }, (r) => {
+                if (r.ok !== _results__WEBPACK_IMPORTED_MODULE_2__.Result.SUCCESS) {
+                    done(r);
+                    return;
+                }
+                // optimistically call done and still continue saving the rest of the data.  We read from the memory
+                // db anyways
+                done(r);
+                const optimisticBulkPersistChanges = new _collections__WEBPACK_IMPORTED_MODULE_3__.BulkPersistChanges();
+                // make sure we swap the adds here, that way we can make sure other persist events
+                // don't take their additions and try to change subsequent calls
+                (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.resolveBulkPersistChanges)(event, r.data, optimisticBulkPersistChanges);
+                for (let i = 0, length = deferredPlugins.length; i < length; i++) {
+                    workPipeline.pipe((d) => {
+                        const plugin = deferredPlugins[i];
+                        plugin.bulkPersist({
+                            id: (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)(8),
+                            operation: optimisticBulkPersistChanges,
+                            schemas: event.schemas
+                        }, (r) => {
+                            if (r.ok === _results__WEBPACK_IMPORTED_MODULE_2__.Result.ERROR) {
+                                d(r);
+                                return;
+                            }
+                            d(_results__WEBPACK_IMPORTED_MODULE_2__.Result.success());
+                        });
+                    });
+                }
+                setTimeout(() => {
+                    workPipeline.filter((_) => {
+                        // no-op for now, maybe implement retries?
+                    });
+                }, 5);
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_2__.PluginEventResult.error(event.id, e));
+        }
+    }
+}
+
+
+}),
+"./src/plugins/replication/ReplicationDbPlugin.ts": 
+/*!********************************************************!*\
+  !*** ./src/plugins/replication/ReplicationDbPlugin.ts ***!
+  \********************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  ReplicationDbPlugin: () => (ReplicationDbPlugin)
+});
+/* ESM import */var _results__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../results */ "./src/results/Result.ts");
+/* ESM import */var _pipeline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../pipeline */ "./src/pipeline/TrampolinePipeline.ts");
+/* ESM import */var _collections__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../collections */ "./src/collections/Changes.ts");
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../utilities */ "./src/utilities/replication.ts");
+
+
+
+
+class ReplicationDbPlugin {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+    }
+    /**
+     * Creates a new DbPluginReplicator that coordinates operations between a source database and its replicas.
+     *
+     * @param source The primary database plugin that will receive all operations first
+     * @param replicas Additional database plugins that will replicate operations from the source
+     * @returns A new DbPluginReplicator instance that manages the source-replica relationship
+     */
+    static create(plugins) {
+        return new ReplicationDbPlugin(plugins);
+    }
+    /**
+     * Will query the read plugin if there is one, otherwise the source plugin will be queried
+    */
+    query(event, done) {
+        try {
+            const plugin = this.plugins.read != null ? this.plugins.read : this.plugins.source;
+            plugin.query(event, done);
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.error(event.id, e));
+        }
+    }
+    destroy(event, done) {
+        try {
+            const pipeline = new _pipeline__WEBPACK_IMPORTED_MODULE_1__.AsyncPipeline();
+            const plugins = [this.plugins.source, ...this.plugins.replicas];
+            for (let i = 0, length = plugins.length; i < length; i++) {
+                pipeline.pipe(plugins[i], (plugin, done) => plugin.destroy(event, done));
+            }
+            pipeline.filter((result) => {
+                if (result.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                    done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.error(event.id, result.error));
+                    return;
+                }
+                done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.success(event.id));
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.error(event.id, e));
+        }
+    }
+    bulkPersist(event, done) {
+        try {
+            // insert into the source first to generate any ids, then take the result and persist that into the replicas
+            const pipeline = new _pipeline__WEBPACK_IMPORTED_MODULE_1__.WorkPipeline();
+            const plugins = [this.plugins.source, ...this.plugins.replicas];
+            if (this.plugins.read != null) {
+                plugins.push(this.plugins.read);
+            }
+            const result = new _collections__WEBPACK_IMPORTED_MODULE_2__.BulkPersistResult();
+            for (let i = 0, length = plugins.length; i < length; i++) {
+                pipeline.pipe((d) => {
+                    const plugin = plugins[i];
+                    // source is first
+                    if (i === 0) {
+                        plugin.bulkPersist(event, (r) => {
+                            if (r.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                                d(r);
+                                return;
+                            }
+                            // make sure we swap the adds here, that way we can make sure other persist events
+                            // don't take their additions and try to change subsequent calls
+                            (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.resolveBulkPersistChanges)(event, r.data, event.operation);
+                            d(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success());
+                        });
+                        return;
+                    }
+                    plugin.bulkPersist(event, (r) => {
+                        if (r.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                            d(r);
+                            return;
+                        }
+                        d(_results__WEBPACK_IMPORTED_MODULE_0__.Result.success());
+                    });
+                });
+            }
+            let successCount = 0;
+            pipeline.filter((r) => {
+                if (r.ok === _results__WEBPACK_IMPORTED_MODULE_0__.Result.ERROR) {
+                    if (successCount > 0) {
+                        done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.partial(event.id, result, r.error));
+                        return;
+                    }
+                    done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.error(event.id, r.error));
+                    return;
+                }
+                successCount++;
+                done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.success(event.id, result));
+            });
+        }
+        catch (e) {
+            done(_results__WEBPACK_IMPORTED_MODULE_0__.PluginEventResult.error(event.id, e));
+        }
+    }
+}
+
+
+}),
+"./src/plugins/replication/index.ts": 
+/*!******************************************!*\
+  !*** ./src/plugins/replication/index.ts ***!
+  \******************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  OptimisticReplicationDbPlugin: () => (/* reexport safe */ _OptimisticReplicationDbPlugin__WEBPACK_IMPORTED_MODULE_1__.OptimisticReplicationDbPlugin),
+  ReplicationDbPlugin: () => (/* reexport safe */ _ReplicationDbPlugin__WEBPACK_IMPORTED_MODULE_0__.ReplicationDbPlugin)
+});
+/* ESM import */var _ReplicationDbPlugin__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ReplicationDbPlugin */ "./src/plugins/replication/ReplicationDbPlugin.ts");
+/* ESM import */var _OptimisticReplicationDbPlugin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./OptimisticReplicationDbPlugin */ "./src/plugins/replication/OptimisticReplicationDbPlugin.ts");
+
+
+
+
+
+}),
+"./src/plugins/translators/DataTranslator.ts": 
+/*!***************************************************!*\
+  !*** ./src/plugins/translators/DataTranslator.ts ***!
+  \***************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DataTranslator: () => (DataTranslator)
+});
+class DataTranslator {
+    query;
+    functionMap = {
+        count: (data, option) => this.count(data, option),
+        distinct: (data, option) => this.distinct(data, option),
+        filter: (data, option) => this.filter(data, option),
+        map: (data, option) => this.map(data, option),
+        max: (data, option) => this.max(data, option),
+        min: (data, option) => this.min(data, option),
+        skip: (data, option) => this.skip(data, option),
+        sort: (data, option) => this.sort(data, option),
+        sum: (data, option) => this.sum(data, option),
+        take: (data, option) => this.take(data, option)
+    };
+    constructor(query) {
+        this.query = query;
+    }
+    translate(data) {
+        this.query.options.forEach(item => {
+            data = this.functionMap[item.name](data, item);
+        });
+        return data;
+    }
+}
+
+
+}),
+"./src/plugins/translators/JsonTranslator.ts": 
+/*!***************************************************!*\
+  !*** ./src/plugins/translators/JsonTranslator.ts ***!
+  \***************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  JsonTranslator: () => (JsonTranslator)
+});
+/* ESM import */var _DataTranslator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DataTranslator */ "./src/plugins/translators/DataTranslator.ts");
+/* ESM import */var _assertions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../assertions */ "./src/assertions/index.ts");
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../utilities */ "./src/utilities/dates.ts");
+
+
+
+class JsonTranslator extends _DataTranslator__WEBPACK_IMPORTED_MODULE_0__.DataTranslator {
+    filter(data, option) {
+        (0,_assertions__WEBPACK_IMPORTED_MODULE_1__.assertIsArray)(data);
+        if (option.value.filter) {
+            if (option.value.params == null) {
+                // standard filtering
+                return data.filter(option.value.filter);
+            }
+            // params filtering
+            const selector = option.value.filter;
+            return data.filter(w => selector([w, option.value.params]));
+        }
+        return data;
+    }
+    map(data, option) {
+        if (Array.isArray(data) == false) {
+            throw new Error("Can only map an array of data");
+        }
+        const response = [];
+        // We want deserialization to flow through mappings
+        // TODO: Speed this up!
+        // Generate a function on the fly?
+        for (let i = 0, length = data.length; i < length; i++) {
+            for (let j = 0, l = option.value.fields.length; j < l; j++) {
+                const field = option.value.fields[j];
+                if (field.property != null) {
+                    const value = field.property.getValue(data[i]);
+                    if (value != null) {
+                        field.property.setValue(data[i], field.property.deserialize(value));
+                    }
+                }
+            }
+            response.push(option.value.selector(data[i]));
+        }
+        return response;
+    }
+    count(data, _) {
+        if (Array.isArray(data)) {
+            return data.length;
+        }
+        throw new Error("Cannot count resulting data, it must be an array.  Please return array of data for function: count()");
+    }
+    min(data, _) {
+        return this._minMax(data, "min", (a, b) => a - b);
+    }
+    max(data, _) {
+        return this._minMax(data, "max", (a, b) => b - a);
+    }
+    sort(data, option) {
+        if (Array.isArray(data)) {
+            data.sort((a, b) => {
+                if (option.value.direction === "asc") {
+                    return option.value.selector(a) - option.value.selector(b);
+                }
+                return option.value.selector(b) - option.value.selector(a);
+            });
+        }
+        return data;
+    }
+    sum(data, _) {
+        (0,_assertions__WEBPACK_IMPORTED_MODULE_1__.assertIsArray)(data, this._formatDataNotArrayError("sum"));
+        const map = this.query.options.getLast("map");
+        let sum = 0;
+        const field = this._getSelectionField("sum", map);
+        for (let i = 0, length = data.length; i < length; i++) {
+            const value = data[i];
+            if (typeof value !== "number") {
+                throw new Error(`Cannot sum, property is not a number.  Property: ${field.sourceName}`);
+            }
+            sum += value;
+        }
+        return sum;
+    }
+    distinct(data, _) {
+        (0,_assertions__WEBPACK_IMPORTED_MODULE_1__.assertIsArray)(data, this._formatDataNotArrayError("distinct"));
+        const result = new Set();
+        // would be nice to have property info here for type detection
+        let needsDateConversion = false;
+        for (let i = 0, length = data.length; i < length; i++) {
+            const value = data[i];
+            if (typeof value === "number" || typeof value === "string") {
+                result.add(value);
+                continue;
+            }
+            if ((0,_utilities__WEBPACK_IMPORTED_MODULE_2__.isDate)(value)) {
+                needsDateConversion = true;
+                result.add(value.toISOString());
+                continue;
+            }
+        }
+        if (needsDateConversion) {
+            return [...result].map(w => new Date(w));
+        }
+        return [...result];
+    }
+    skip(data, option) {
+        if (Array.isArray(data)) {
+            if (option.value > 0) {
+                if (data.length < option.value) {
+                    // We don't have enough data to skip, return an empty array
+                    return [];
+                }
+                return data.slice(option.value);
+            }
+            return data;
+        }
+        return data;
+    }
+    take(data, option) {
+        if (Array.isArray(data)) {
+            if (option.value > 0) {
+                if (data.length < option.value) {
+                    return data;
+                }
+                return data.slice(0, option.value);
+            }
+            return data;
+        }
+        return data;
+    }
+    _getSelectionField(name, mapOption) {
+        if (mapOption == null ||
+            mapOption.value.fields.length === 0 ||
+            mapOption.value.fields.length > 1) {
+            throw new Error(`${name}() operation can only be performed when one field is mapped for a result.  Ex.  myset.map(x => x.someNumberOrDateOrString).${name}()`);
+        }
+        return mapOption.value.fields[0];
+    }
+    _minMax(data, name, sort) {
+        (0,_assertions__WEBPACK_IMPORTED_MODULE_1__.assertIsArray)(data, this._formatDataNotArrayError(name));
+        data.sort(sort);
+        if (data.length === 0) {
+            throw new Error("Cannot perform operation on empty array, result query contains no data");
+        }
+        return data[0];
+    }
+    _formatDataNotArrayError(functionName) {
+        return `Cannot sum resulting data, it must be an array.  Please return array of data for function: ${functionName}()`;
+    }
+}
+
+
+}),
+"./src/plugins/translators/SqlTranslator.ts": 
+/*!**************************************************!*\
+  !*** ./src/plugins/translators/SqlTranslator.ts ***!
+  \**************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  SqlTranslator: () => (SqlTranslator)
+});
+/* ESM import */var _DataTranslator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DataTranslator */ "./src/plugins/translators/DataTranslator.ts");
+
+class SqlTranslator extends _DataTranslator__WEBPACK_IMPORTED_MODULE_0__.DataTranslator {
+    count(data, _) {
+        return data;
+    }
+    min(data, _) {
+        return data;
+    }
+    max(data, _) {
+        return data;
+    }
+    sum(data, _) {
+        return data;
+    }
+    distinct(data, _) {
+        return data;
+    }
+    filter(data, _) {
+        return data;
+    }
+    skip(data, _) {
+        return data;
+    }
+    take(data, _) {
+        return data;
+    }
+    sort(data, _) {
+        return data;
+    }
+    map(data, _) {
+        return data;
+    }
+}
+
+
+}),
+"./src/plugins/translators/index.ts": 
+/*!******************************************!*\
+  !*** ./src/plugins/translators/index.ts ***!
+  \******************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DataTranslator: () => (/* reexport safe */ _DataTranslator__WEBPACK_IMPORTED_MODULE_0__.DataTranslator),
+  JsonTranslator: () => (/* reexport safe */ _JsonTranslator__WEBPACK_IMPORTED_MODULE_1__.JsonTranslator),
+  SqlTranslator: () => (/* reexport safe */ _SqlTranslator__WEBPACK_IMPORTED_MODULE_2__.SqlTranslator)
+});
+/* ESM import */var _DataTranslator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./DataTranslator */ "./src/plugins/translators/DataTranslator.ts");
+/* ESM import */var _JsonTranslator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./JsonTranslator */ "./src/plugins/translators/JsonTranslator.ts");
+/* ESM import */var _SqlTranslator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./SqlTranslator */ "./src/plugins/translators/SqlTranslator.ts");
+
+
+
+
+
+}),
+"./src/results/Result.ts": 
+/*!*******************************!*\
+  !*** ./src/results/Result.ts ***!
+  \*******************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  PluginEventResult: () => (PluginEventResult),
+  Result: () => (Result)
+});
+class BaseResult {
+    static ERROR = "error";
+    static SUCCESS = "success";
+    static PARTIAL = "partial";
+    static resolve(result, resolve, reject) {
+        if (result.ok === BaseResult.SUCCESS) {
+            resolve(result.data);
+            return;
+        }
+        if (result.ok === BaseResult.PARTIAL) {
+            reject({
+                partial: result.data,
+                error: result.error
+            });
+            return;
+        }
+        reject(result.error);
+    }
+    static assertSuccess(result) {
+        if (result.ok !== BaseResult.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+class Result extends BaseResult {
+    static success(data) {
+        return {
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(error) {
+        return {
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(data, error) {
+        return {
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+}
+class PluginEventResult extends BaseResult {
+    static success(id, data) {
+        return {
+            id,
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(id, error) {
+        return {
+            id,
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(id, data, error) {
+        return {
+            id,
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+    static assertSuccess(result) {
+        if (result.ok !== Result.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+
+
+}),
+"./src/utilities/dates.ts": 
+/*!********************************!*\
+  !*** ./src/utilities/dates.ts ***!
+  \********************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  isDate: () => (isDate)
+});
+const isDate = (data) => {
+    if (data == null) {
+        return false;
+    }
+    if (typeof data !== "object") {
+        return false;
+    }
+    return data instanceof Date;
+};
+
+
+}),
+"./src/utilities/replication.ts": 
+/*!**************************************!*\
+  !*** ./src/utilities/replication.ts ***!
+  \**************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  resolveBulkPersistChanges: () => (resolveBulkPersistChanges)
+});
+const resolveBulkPersistChanges = (event, result, bulkPersistChanges) => {
+    // make sure we swap the adds here, that way we can make sure other persist events
+    // don't take their additions and try to change subsequent calls
+    for (const [schemaId, changes] of event.operation) {
+        const schemmaBulkPersistResult = result.get(schemaId);
+        const schemaBulkPersistChanges = bulkPersistChanges.resolve(schemaId);
+        // Set the original removes
+        schemaBulkPersistChanges.removes = changes.removes;
+        // Set the original updates
+        schemaBulkPersistChanges.updates = changes.updates;
+        // Take the adds from the result and set them to be persisted
+        // in the replicated plugins because the id's are set in the 
+        // memory data store
+        schemaBulkPersistChanges.adds = schemmaBulkPersistResult.adds;
+    }
+};
+
+
+}),
+"./src/utilities/uuid.ts": 
+/*!*******************************!*\
+  !*** ./src/utilities/uuid.ts ***!
+  \*******************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  uuid: () => (uuid),
+  uuidv4: () => (uuidv4)
+});
+const uuid = (length = 16) => {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charLength = chars.length;
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars[Math.random() * charLength | 0];
+    }
+    return result;
+};
+const HEX_CHARS = '0123456789abcdef';
+const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
+const uuidv4 = () => {
+    let randomBytes = null;
+    if (hasCrypto) {
+        randomBytes = crypto.getRandomValues(new Uint8Array(16));
+    }
+    let byteIndex = 0;
+    let uuid = '';
+    for (let i = 0; i < UUID_TEMPLATE.length; i++) {
+        const c = UUID_TEMPLATE[i];
+        if (c === '-') {
+            uuid += '-';
+            continue;
+        }
+        let r;
+        if (hasCrypto && randomBytes) {
+            // Each byte gives two hex digits (nibbles)
+            r =
+                (i % 2 === 0
+                    ? randomBytes[byteIndex] >> 4
+                    : randomBytes[byteIndex++] & 0x0f);
+        }
+        else {
+            r = Math.floor(Math.random() * 16);
+        }
+        if (c === 'x') {
+            uuid += HEX_CHARS[r];
+        }
+        else if (c === 'y') {
+            // Variant bits: 8, 9, A, or B
+            uuid += HEX_CHARS[(r & 0x3) | 0x8];
+        }
+        else if (c === '4') {
+            uuid += '4';
+        }
+    }
+    return uuid;
+};
+
+
+}),
+
+});
+/************************************************************************/
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+/************************************************************************/
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+/*!******************************!*\
+  !*** ./src/plugins/index.ts ***!
+  \******************************/
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  DataTranslator: () => (/* reexport safe */ _translators__WEBPACK_IMPORTED_MODULE_0__.DataTranslator),
+  DbPluginCapability: () => (/* reexport safe */ _capabilities__WEBPACK_IMPORTED_MODULE_1__.DbPluginCapability),
+  DbPluginLoggingCapability: () => (/* reexport safe */ _capabilities__WEBPACK_IMPORTED_MODULE_1__.DbPluginLoggingCapability),
+  EphemeralDataPlugin: () => (/* reexport safe */ _EphemeralDataPlugin__WEBPACK_IMPORTED_MODULE_4__.EphemeralDataPlugin),
+  JsonTranslator: () => (/* reexport safe */ _translators__WEBPACK_IMPORTED_MODULE_0__.JsonTranslator),
+  OptimisticReplicationDbPlugin: () => (/* reexport safe */ _replication__WEBPACK_IMPORTED_MODULE_2__.OptimisticReplicationDbPlugin),
+  Query: () => (/* reexport safe */ _query__WEBPACK_IMPORTED_MODULE_3__.Query),
+  QueryOptionsCollection: () => (/* reexport safe */ _query__WEBPACK_IMPORTED_MODULE_3__.QueryOptionsCollection),
+  QueryOrdering: () => (/* reexport safe */ _query__WEBPACK_IMPORTED_MODULE_3__.QueryOrdering),
+  ReplicationDbPlugin: () => (/* reexport safe */ _replication__WEBPACK_IMPORTED_MODULE_2__.ReplicationDbPlugin),
+  SqlTranslator: () => (/* reexport safe */ _translators__WEBPACK_IMPORTED_MODULE_0__.SqlTranslator)
+});
+/* ESM import */var _translators__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./translators */ "./src/plugins/translators/index.ts");
+/* ESM import */var _capabilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./capabilities */ "./src/plugins/capabilities/index.ts");
+/* ESM import */var _replication__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./replication */ "./src/plugins/replication/index.ts");
+/* ESM import */var _query__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./query */ "./src/plugins/query/index.ts");
+/* ESM import */var _EphemeralDataPlugin__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./EphemeralDataPlugin */ "./src/plugins/EphemeralDataPlugin.ts");
+
+
+
+
+
+
+
+})();
+
+var __webpack_exports__DataTranslator = __webpack_exports__.DataTranslator;
+var __webpack_exports__DbPluginCapability = __webpack_exports__.DbPluginCapability;
+var __webpack_exports__DbPluginLoggingCapability = __webpack_exports__.DbPluginLoggingCapability;
+var __webpack_exports__EphemeralDataPlugin = __webpack_exports__.EphemeralDataPlugin;
+var __webpack_exports__JsonTranslator = __webpack_exports__.JsonTranslator;
+var __webpack_exports__OptimisticReplicationDbPlugin = __webpack_exports__.OptimisticReplicationDbPlugin;
+var __webpack_exports__Query = __webpack_exports__.Query;
+var __webpack_exports__QueryOptionsCollection = __webpack_exports__.QueryOptionsCollection;
+var __webpack_exports__QueryOrdering = __webpack_exports__.QueryOrdering;
+var __webpack_exports__ReplicationDbPlugin = __webpack_exports__.ReplicationDbPlugin;
+var __webpack_exports__SqlTranslator = __webpack_exports__.SqlTranslator;
+export { __webpack_exports__DataTranslator as DataTranslator, __webpack_exports__DbPluginCapability as DbPluginCapability, __webpack_exports__DbPluginLoggingCapability as DbPluginLoggingCapability, __webpack_exports__EphemeralDataPlugin as EphemeralDataPlugin, __webpack_exports__JsonTranslator as JsonTranslator, __webpack_exports__OptimisticReplicationDbPlugin as OptimisticReplicationDbPlugin, __webpack_exports__Query as Query, __webpack_exports__QueryOptionsCollection as QueryOptionsCollection, __webpack_exports__QueryOrdering as QueryOrdering, __webpack_exports__ReplicationDbPlugin as ReplicationDbPlugin, __webpack_exports__SqlTranslator as SqlTranslator };
+
+//# sourceMappingURL=index.js.map