@routier/core 0.2.0 → 0.3.0

package/dist/utilities/index.cjs

@@ -0,0 +1,982 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+126(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  isPropertyExpression: () => (isPropertyExpression)
+});
+
+
+function assertDate(data) {
+    if (isDate(data) === false) {
+        throw new TypeError('Value is not a Date');
+    }
+}
+function assertIsNotNull(data, message) {
+    if (data == null) {
+        if (message == null) {
+            throw new TypeError('Assertion failed, data is null');
+        }
+        if (typeof message === "string") {
+            throw new TypeError(message);
+        }
+        throw new TypeError(message());
+    }
+}
+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`);
+}
+function assertIsNumber(value) {
+    if (typeof value !== "number") {
+        throw new TypeError("value is not of type `number`");
+    }
+}
+function isObjectWithType(value) {
+    return typeof value === "object" && value !== null && "type" in value;
+}
+/**
+ * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.
+ */ function isExpression(value) {
+    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type);
+}
+/**
+ * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === "operator"`.
+ */ function isOperatorExpression(value) {
+    return isObjectWithType(value) && value.type === "operator";
+}
+/**
+ * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === "comparator"`.
+ */ function isComparatorExpression(value) {
+    return isObjectWithType(value) && value.type === "comparator";
+}
+/**
+ * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === "property"`.
+ */ function isPropertyExpression(value) {
+    return isObjectWithType(value) && value.type === "property";
+}
+/**
+ * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === "value"`.
+ */ function isValueExpression(value) {
+    return isObjectWithType(value) && value.type === "value";
+}
+/**
+ * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
+ */ function isEmptyExpression(value) {
+    return isObjectWithType(value) && value.type === "empty";
+}
+/**
+ * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === "not-parsable"`.
+ */ function isNotParsableExpression(value) {
+    return isObjectWithType(value) && value.type === "not-parsable";
+}
+
+
+},
+63(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  j: () => (forEach)
+});
+/**
+ * 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 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);
+}
+
+
+},
+198(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  H: () => (QueryOptionsCollection)
+});
+/* import */ var _assertions__rspack_import_1 = __webpack_require__(126);
+/* import */ var _expressions_utils__rspack_import_0 = __webpack_require__(63);
+
+
+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 and renamed properties
+            const filterValue = value;
+            // A tautology (`x => true`) filters nothing — skip it entirely so
+            // plugins never see it
+            if (filterValue.expression.type === "empty") {
+                return;
+            }
+            if (filterValue.expression.type === "not-parsable") {
+                this.nextExecutionTarget = "memory";
+            } else {
+                (0,_expressions_utils__rspack_import_0/* .forEach */.j)(filterValue.expression, (expression)=>{
+                    if ((0,_assertions__rspack_import_1.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;
+                    }
+                    if ((0,_assertions__rspack_import_1.isPropertyExpression)(expression) && expression.property.hasRenamedSegments) {
+                        // Cut over to memory execution: the plugin stores data under the
+                        // `from` (storage) names, but filter selectors reference the
+                        // in-memory names.  Memory execution runs after deserialization,
+                        // where the in-memory names exist
+                        this.nextExecutionTarget = "memory";
+                        return false;
+                    }
+                    return true;
+                });
+            }
+        }
+        if (name === "sort") {
+            const sortValue = value;
+            // Same rule as filters: sort selectors reference in-memory names, which
+            // only exist after deserialization when the property is renamed or unmapped
+            if (sortValue.property != null && (sortValue.property.isUnmapped || sortValue.property.hasRenamedSegments)) {
+                this.nextExecutionTarget = "memory";
+            }
+        }
+        if (name === "nearest") {
+            const nearestValue = value;
+            // Same rule as sort, and for the same reason: the plugin stores the vector under
+            // the `from` name, and an unmapped property is not stored at all. Both are only
+            // readable after deserialization, which is where memory execution runs.
+            //
+            // This is also what lets every translator's in-memory fallback read the column by
+            // its resolved name — anything whose storage name differs never reaches them.
+            if (nearestValue.property != null && (nearestValue.property.isUnmapped || nearestValue.property.hasRenamedSegments)) {
+                this.nextExecutionTarget = "memory";
+            }
+        }
+        if (name === "join") {
+            const joinValue = value;
+            // A join whose two sides live on different plugins cannot be sent to EITHER of
+            // them — neither can read the other's rows — so the option itself belongs to the
+            // memory half, where the datastore interprets it.
+            //
+            // Set BEFORE the item is created, unlike `nearest`'s ratchet below, because this
+            // moves the join option itself rather than everything after it.
+            if (joinValue.crossPlugin === true) {
+                this.nextExecutionTarget = "memory";
+            }
+        }
+        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
+        ]);
+        if (name === "nearest") {
+            // Everything AFTER a similarity search runs in memory, whatever the backend.
+            //
+            // Whether the search was pushed down is a fact about the plugin, which this
+            // collection cannot see — so a later option is only safe if it runs after the
+            // scoring definitely happened, and in memory is the only place that is true of.
+            //
+            // The failure this prevents is silent. `.nearest(x => x.embedding, v, 10).take(3)`
+            // sends `LIMIT 3` to a backend that ignored the ordering, so three arbitrary rows
+            // come back and get scored — three real rows, in a plausible order, and not the
+            // three nearest. Nothing errors.
+            //
+            // A plugin that DID push the search down loses nothing but the chance to also
+            // push down what follows it, which is a limit over ten rows.
+            this.nextExecutionTarget = "memory";
+        }
+        if (name === "join") {
+            // Everything AFTER a join runs in memory, for the same reason as `nearest`: this
+            // collection cannot see HOW the plugin executed the join, and the rows it produced
+            // are TUPLES rather than entities of the root schema.
+            //
+            // A `take` sent to a backend that hash-joined in its translator would limit the
+            // OUTER rows read, not the pairs produced — a plausible-looking result with the
+            // wrong number of rows in it. Conjuncts that can safely run earlier are split off
+            // by the query builder BEFORE dispatch, which is the only exception.
+            this.nextExecutionTarget = "memory";
+        }
+    }
+    /**
+     * Splits the collection around the FIRST occurrence of `name`, preserving order.
+     *
+     * For a join: the options recorded before it operate on entity rows, the option itself
+     * produces tuples, and the ones after it operate on tuples. Three different shapes, so the
+     * caller has to run them in three steps rather than one pass.
+     */ splitAt(name) {
+        this.resolveEnumeration();
+        const sortedItems = this.enumeratedItems.toSorted((a, b)=>a.index - b.index);
+        const before = new QueryOptionsCollection();
+        const after = new QueryOptionsCollection();
+        let at = null;
+        for(let i = 0, length = sortedItems.length; i < length; i++){
+            const { option } = sortedItems[i];
+            if (at == null && option.name === name) {
+                at = option;
+                continue;
+            }
+            const destination = at == null ? before : after;
+            destination.add(option.name, option.value);
+        }
+        return {
+            before,
+            at,
+            after
+        };
+    }
+    /**
+     * Captures the collection's current state and returns a function that restores it.
+     *
+     * Terminal queryable operations (count, first, aggregates, …) record their option on
+     * the shared collection before executing. Without restoring, a re-executed terminal —
+     * the whole point of a subscribed queryable — stacks its option a second time and
+     * runs it over the first execution's scalar result.
+     */ snapshot() {
+        const options = new Map([
+            ...this.options.entries()
+        ].map(([key, items])=>[
+                key,
+                [
+                    ...items
+                ]
+            ]));
+        const nextExecutionTarget = this.nextExecutionTarget;
+        const nextIndex = this.nextIndex;
+        return ()=>{
+            this.options = new Map(options);
+            this.nextExecutionTarget = nextExecutionTarget;
+            this.nextIndex = nextIndex;
+            this.enumeratedItems = [];
+        };
+    }
+    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
+        };
+    }
+    hasTransformations() {
+        const transformationOptions = [
+            "map",
+            "group",
+            "min",
+            "max",
+            "count",
+            "sum"
+        ];
+        return transformationOptions.some((name)=>this.options.has(name));
+    }
+    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);
+        }
+    }
+}
+
+
+},
+76(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  $: () => (isDate)
+});
+const isDate = (data)=>{
+    if (data == null) {
+        return false;
+    }
+    if (typeof data !== "object") {
+        return false;
+    }
+    return data instanceof Date;
+};
+
+
+},
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Cg: () => (resetLogLevel),
+  He: () => (setLogLevel),
+  Mi: () => (isLogLevelEnabled),
+  XM: () => (getLogLevel),
+  p_: () => (LOG_LEVELS),
+  vF: () => (logger)
+});
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
+    }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
+};
+const logger = {
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
+};
+
+
+},
+615(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Nr: () => (fastHash),
+  Zm: () => (stringifyObject),
+  tW: () => (hash)
+});
+const hash = (value, seed = 0)=>{
+    // From Stack Overflow
+    // https://stackoverflow.com/a/52171480/3329760
+    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+    for(let i = 0, ch; i < value.length; i++){
+        ch = value.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+    h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+    h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+    h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+/**
+ * Fast string hash optimized for comparisons.
+ * Uses djb2 algorithm - very fast and good distribution for short to medium strings.
+ * Same input always produces same output (deterministic).
+ * 
+ * @param value - The string to hash
+ * @param seed - Optional seed value (default: 5381)
+ * @returns A positive 32-bit integer hash value
+ * 
+ * @example
+ * ```ts
+ * fastHash("test") === fastHash("test") // true
+ * fastHash("test") !== fastHash("test2") // true
+ * ```
+ */ const fastHash = (value, seed = 5381)=>{
+    let hash = seed;
+    for(let i = 0; i < value.length; i++){
+        hash = (hash << 5) + hash + value.charCodeAt(i);
+    }
+    return hash >>> 0; // Convert to unsigned 32-bit integer
+};
+/**
+ * Converts any value to a readable string representation.
+ * Handles primitives, objects, arrays, classes, dates, errors, and functions.
+ * Supports depth limiting to prevent infinite recursion on circular references.
+ * 
+ * @param obj - The value to stringify
+ * @param maxDepth - Maximum depth for nested objects (default: 3)
+ * @param currentDepth - Current recursion depth (default: 0)
+ * @returns String representation of the value
+ * 
+ * @example
+ * ```ts
+ * stringifyObject({ name: "test", count: 5 }) // '{ name: "test", count: 5 }'
+ * stringifyObject([1, 2, 3]) // '[1, 2, 3]'
+ * stringifyObject(new Date()) // 'Date(2024-01-01T00:00:00.000Z)'
+ * ```
+ */ function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
+    if (obj === null) return 'null';
+    if (obj === undefined) return 'undefined';
+    const type = typeof obj;
+    switch(type){
+        case 'string':
+            return `"${obj}"`;
+        case 'number':
+        case 'boolean':
+            return String(obj);
+        case 'function':
+            return `[Function: ${getFunctionName(obj)}]`;
+        case 'object':
+            if (currentDepth >= maxDepth) {
+                return '[Max Depth Reached]';
+            }
+            return stringifyObjectValue(obj, maxDepth, currentDepth);
+        default:
+            return `[${type}]`;
+    }
+}
+function getFunctionName(fn) {
+    const name = fn.name;
+    return name || 'anonymous';
+}
+function getObjectProperties(obj) {
+    const properties = {};
+    for(const key in obj){
+        if (obj.hasOwnProperty(key)) {
+            properties[key] = obj[key];
+        }
+    }
+    return properties;
+}
+function stringifyObjectValue(obj, maxDepth, currentDepth) {
+    if (obj === null) return 'null';
+    if (obj instanceof Date) {
+        return `Date(${obj.toISOString()})`;
+    }
+    if (obj instanceof Error) {
+        return `Error(${obj.message})`;
+    }
+    if (obj instanceof RegExp) {
+        return obj.toString();
+    }
+    if (Array.isArray(obj)) {
+        return stringifyArray(obj, maxDepth, currentDepth);
+    }
+    if (obj.constructor && obj.constructor.name !== 'Object') {
+        return stringifyClassInstance(obj, maxDepth, currentDepth);
+    }
+    return stringifyPlainObject(obj, maxDepth, currentDepth);
+}
+function stringifyArray(arr, maxDepth, currentDepth) {
+    if (arr.length === 0) return '[]';
+    const items = arr.slice(0, 5).map((item)=>stringifyObject(item, maxDepth, currentDepth + 1));
+    const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
+    return `[${items.join(', ')}${suffix}]`;
+}
+function stringifyClassInstance(obj, maxDepth, currentDepth) {
+    const className = obj.constructor.name;
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return `${className} {}`;
+    }
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `${className} { ${props.join(', ')}${suffix} }`;
+}
+function stringifyPlainObject(obj, maxDepth, currentDepth) {
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return '{}';
+    }
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `{ ${props.join(', ')}${suffix} }`;
+}
+
+
+},
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  g: () => (uuidv4),
+  u: () => (uuid)
+});
+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 hasRandomUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+const uuidv4 = ()=>{
+    if (hasRandomUUID) {
+        return crypto.randomUUID();
+    }
+    return uuidv4Fallback();
+};
+const uuidv4Fallback = ()=>{
+    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.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  resetLogLevel: () => (/* reexport */ logger/* .resetLogLevel */.Cg),
+  cast: () => (/* reexport */ cast),
+  resolveBulkPersistChanges: () => (/* reexport */ resolveBulkPersistChanges),
+  clone: () => (/* reexport */ clone),
+  isNodeRuntime: () => (/* reexport */ isNodeRuntime),
+  stringifyObject: () => (/* reexport */ strings/* .stringifyObject */.Zm),
+  uuid: () => (/* reexport */ uuid/* .uuid */.u),
+  isLogLevelEnabled: () => (/* reexport */ logger/* .isLogLevelEnabled */.Mi),
+  fastHash: () => (/* reexport */ strings/* .fastHash */.Nr),
+  isDate: () => (/* reexport */ dates/* .isDate */.$),
+  LOG_LEVELS: () => (/* reexport */ logger/* .LOG_LEVELS */.p_),
+  uuidv4: () => (/* reexport */ uuid/* .uuidv4 */.g),
+  toEventArray: () => (/* reexport */ toEventArray),
+  logger: () => (/* reexport */ logger/* .logger */.vF),
+  setLogLevel: () => (/* reexport */ logger/* .setLogLevel */.He),
+  unsafeCast: () => (/* reexport */ unsafeCast),
+  hash: () => (/* reexport */ strings/* .hash */.tW),
+  getLogLevel: () => (/* reexport */ logger/* .getLogLevel */.XM),
+  toMap: () => (/* reexport */ toMap),
+  combineQueryOptionsCollections: () => (/* reexport */ combineQueryOptionsCollections),
+  noop: () => (/* reexport */ noop)
+});
+
+;// CONCATENATED MODULE: ./src/utilities/arrays.ts
+const toMap = (data, keySelector)=>{
+    const result = new Map();
+    for(let i = 0; i < data.length; i++){
+        const item = data[i];
+        const key = keySelector(item);
+        result.set(key, item);
+    }
+    return result;
+};
+
+// EXTERNAL MODULE: ./src/utilities/strings.ts
+var strings = __webpack_require__(615);
+// EXTERNAL MODULE: ./src/utilities/dates.ts
+var dates = __webpack_require__(76);
+;// CONCATENATED MODULE: ./src/utilities/objects.ts
+const cast = (item)=>{
+    return item;
+};
+function clone(data) {
+    return JSON.parse(JSON.stringify(data));
+}
+
+;// CONCATENATED MODULE: ./src/utilities/runtime.ts
+const isNodeRuntime = ()=>typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+// EXTERNAL MODULE: ./src/utilities/uuid.ts
+var uuid = __webpack_require__(618);
+;// CONCATENATED MODULE: ./src/utilities/replication.ts
+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;
+    }
+};
+
+// EXTERNAL MODULE: ./src/plugins/query/QueryOptionsCollection.ts
+var QueryOptionsCollection = __webpack_require__(198);
+;// CONCATENATED MODULE: ./src/utilities/queryOptionsCollection.ts
+
+const combineQueryOptionsCollections = (...collections)=>{
+    const result = new QueryOptionsCollection/* .QueryOptionsCollection */.H();
+    for(let i = 0, length = collections.length; i < length; i++){
+        const collection = collections[i];
+        // Add scoped items first
+        collection.forEach((item)=>{
+            result.add(item.name, item.value);
+        });
+    }
+    return result;
+};
+
+;// CONCATENATED MODULE: ./src/utilities/dbPluginEventUtils.ts
+const toEventArray = (event)=>{
+    const result = [];
+    for (const [schemaId, changes] of event.operation){
+        if (changes.hasItems === false) {
+            continue;
+        }
+        if (changes.adds.length > 0) {
+            result.push(...changes.adds.map((add)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...add
+                        },
+                        type: "add"
+                    }
+                ];
+            }));
+        }
+        if (changes.updates.length > 0) {
+            result.push(...changes.updates.map((update)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...update
+                        },
+                        type: "update"
+                    }
+                ];
+            }));
+        }
+        if (changes.removes.length > 0) {
+            result.push(...changes.removes.map((remove)=>{
+                return [
+                    schemaId,
+                    {
+                        data: {
+                            ...remove
+                        },
+                        type: "remove"
+                    }
+                ];
+            }));
+        }
+    }
+    return result;
+};
+
+;// CONCATENATED MODULE: ./src/utilities/functions.ts
+const noop = (..._args)=>{};
+
+;// CONCATENATED MODULE: ./src/utilities/unsafeCast.ts
+const unsafeCast = (value)=>{
+    return value;
+};
+
+// EXTERNAL MODULE: ./src/utilities/logger.ts
+var logger = __webpack_require__(581);
+;// CONCATENATED MODULE: ./src/utilities/index.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map