teamplay 0.5.0-alpha.8 → 0.5.0

package/README.md

@@ -13,16 +13,16 @@ Features:
 
 > __*__ deep signals -- with support for objects and arrays\
 > __**__ concurrent changes to the same data are auto-merged using [OT](https://en.wikipedia.org/wiki/Operational_transformation)\
-> __***__ similar to Firebase but with your own MongoDB-compatible database
+> __***__ similar to Firebase but with your own MongoDB database
 
 ## Installation
 
 For installation and documentation see [teamplay.dev](https://teamplay.dev)
 
-## ORM Compat Helpers
+## ORM Helpers
 
 For legacy Racer-style model mixins (for example versioning libraries which call
-`getAssociations()`), use ORM compat helpers from the `teamplay/orm` subpath:
+`getAssociations()`), use ORM helpers from the `teamplay/orm` subpath:
 
 ```js
 import BaseModel, { hasMany, hasOne, belongsTo } from 'teamplay/orm'

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './orm/idFields.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './orm/idFields.js';

package/dist/config.js

@@ -0,0 +1 @@
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./orm/idFields.js";

package/dist/connect/index.d.ts

@@ -1 +1 @@
-export default function connect(options: any): void;
+export default function connect(options?: {}): void;

package/dist/connect/index.js

@@ -1,9 +1,13 @@
 import Socket from '@teamplay/channel';
 import Connection from './sharedbConnection.cjs';
 import { connection, setConnection } from "../orm/connection.js";
-export default function connect(options) {
+import { configureTeamplay } from "../config.js";
+export default function connect(options = {}) {
+    const { idFields, ...socketOptions } = options || {};
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     if (connection)
         return;
-    const socket = new Socket(options);
+    const socket = new Socket(socketOptions);
     setConnection(new Connection(socket));
 }

package/dist/connect/offline/index.d.ts

@@ -1 +1 @@
-export default function createConnectWithPersistence({ storage, createPubsub }?: {}): () => Promise<void>;
+export default function createConnectWithPersistence({ storage, createPubsub }?: {}): (options?: {}) => Promise<void>;

package/dist/connect/offline/index.js

@@ -3,21 +3,25 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../../orm/connection.js";
+import { configureTeamplay } from "../../config.js";
 const STORAGE_NAMESPACE = 'teamplay-offline';
 const DOCS_PREFIX = `${STORAGE_NAMESPACE}:docs:`;
 const LAST_OP_PREFIX = `${STORAGE_NAMESPACE}:last-op:`;
 export default function createConnectWithPersistence({ storage, createPubsub } = {}) {
     if (!storage)
         throw new Error('[connect-offline] storage is required');
-    return async function connect() {
+    return async function connect(options = {}) {
+        const { idFields } = options || {};
+        if (idFields !== undefined)
+            configureTeamplay({ idFields });
         if (connection)
             return;
         const db = new ShareDbMingo();
-        const options = { db };
+        const backendOptions = { db };
         const { pubsub } = (await init(db, storage, createPubsub)) || {};
         if (pubsub)
-            options.pubsub = pubsub;
-        const backend = new ShareBackend(options);
+            backendOptions.pubsub = pubsub;
+        const backend = new ShareBackend(backendOptions);
         setConnection(backend.connect());
     };
 }

package/dist/connect/offline/react-native.d.ts

@@ -3,7 +3,7 @@ export namespace storage {
     export { setItem };
     export { iterate };
 }
-declare const _default: () => Promise<void>;
+declare const _default: (options?: {}) => Promise<void>;
 export default _default;
 declare function getItem(key: any): Promise<any>;
 declare function setItem(key: any, value: any): Promise<any>;

package/dist/connect/offline/web.d.ts

@@ -4,6 +4,6 @@ export namespace storage {
     function setItem(key: any, value: any): Promise<any>;
     function iterate(iterator: any): Promise<any>;
 }
-declare const _default: () => Promise<void>;
+declare const _default: (options?: {}) => Promise<void>;
 export default _default;
 import SharedbCrosstabPubsub from '../lib/sharedb-crosstab-pubsub.cjs';

package/dist/connect/test.d.ts

@@ -1 +1 @@
-export default function connect(): void;
+export default function connect(options?: {}): void;

package/dist/connect/test.js

@@ -4,7 +4,11 @@
 import ShareDbMingo from '@startupjs/sharedb-mingo-memory';
 import ShareBackend from 'sharedb';
 import { connection, setConnection } from "../orm/connection.js";
-export default function connect() {
+import { configureTeamplay } from "../config.js";
+export default function connect(options = {}) {
+    const { idFields } = options || {};
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     if (connection)
         return;
     const backend = new ShareBackend({ db: new ShareDbMingo() });

package/dist/index.d.ts

@@ -53,15 +53,19 @@ export { default as signal } from './orm/getSignal.js';
 export { GLOBAL_ROOT_ID } from './orm/Root.js';
 export declare const $: RootSignal;
 export default $;
-export { default as sub } from './orm/sub.js';
-export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
+export { default as sub, unsub } from './orm/sub.js';
+export type { SubMode, SubOptions } from './orm/sub.js';
+export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from './react/useSub.js';
 export { default as useSuspendMemo, useSuspendMemoByKey } from './react/useSuspendMemo.js';
 export declare const observer: ObserverFunction;
-export { useValue, useValue$, useModel, useLocal, useLocal$, useLocalDoc, useLocalDoc$, useSession, useSession$, usePage, usePage$, useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
-export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { emit, useOn, useEmit } from './orm/events.js';
+export { default as reaction } from './orm/reaction.js';
+export type { ReactionHandle, ReactionOptions } from './orm/reaction.js';
 export { useDidUpdate, useOnce, useSyncEffect } from './react/helpers.js';
-export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from './orm/connection.js';
+export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly } from './orm/connection.js';
 export type { TeamplayConnection, TeamplayShareDoc } from './orm/connection.js';
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from './config.js';
+export type { IdField, IdFields, TeamplayRuntimeConfig } from './config.js';
 export { getSubscriptionGcDelay, setSubscriptionGcDelay } from './orm/subscriptionGcDelay.js';
 export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from './react/helpers.js';
 export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';

package/dist/index.js

@@ -14,14 +14,15 @@ export { GLOBAL_ROOT_ID } from "./orm/Root.js";
 const getRuntimeRootSignal = _getRootSignal;
 export const $ = getRuntimeRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ });
 export default $;
-export { default as sub } from "./orm/sub.js";
-export { default as useSub, useAsyncSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";
+export { default as sub, unsub } from "./orm/sub.js";
+export { default as useSub, useAsyncSub, useBatchSub, setUseDeferredValue as __setUseDeferredValue, setDefaultDefer as __setDefaultDefer } from "./react/useSub.js";
 export { default as useSuspendMemo, useSuspendMemoByKey } from "./react/useSuspendMemo.js";
 export const observer = runtimeObserver;
-export { useValue, useValue$, useModel, useLocal, useLocal$, useLocalDoc, useLocalDoc$, useSession, useSession$, usePage, usePage$, useBatch, useDoc, useDoc$, useBatchDoc, useBatchDoc$, useAsyncDoc, useAsyncDoc$, useQuery, useQuery$, useAsyncQuery, useAsyncQuery$, useBatchQuery, useBatchQuery$, useQueryIds, useBatchQueryIds, useAsyncQueryIds, useQueryDoc, useQueryDoc$, useBatchQueryDoc, useBatchQueryDoc$, useAsyncQueryDoc, useAsyncQueryDoc$ } from './orm/Compat/hooksCompat.js';
-export { emit, useOn, useEmit } from './orm/Compat/eventsCompat.js';
+export { emit, useOn, useEmit } from './orm/events.js';
+export { default as reaction } from "./orm/reaction.js";
 export { useDidUpdate, useOnce, useSyncEffect } from "./react/helpers.js";
-export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly, publicOnly, setPublicOnly } from "./orm/connection.js";
+export { connection, setConnection, getConnection, getDefaultFetchOnly, setDefaultFetchOnly } from "./orm/connection.js";
+export { TEAMPLAY_RUNTIME_CONFIG_SYMBOL, configureTeamplay, getTeamplayConfig, getDefaultIdFields, setDefaultIdFields } from "./config.js";
 export { getSubscriptionGcDelay, setSubscriptionGcDelay } from "./orm/subscriptionGcDelay.js";
 export { useId, useNow, useScheduleUpdate, useTriggerUpdate } from "./react/helpers.js";
 export { GUID_PATTERN, defineSchema, hasMany, hasOne, hasManyFlags, belongsTo, pickFormFields } from '@teamplay/schema';

package/dist/orm/$.js

@@ -4,7 +4,7 @@
 import getSignal from "./getSignal.js";
 import Signal from "./Signal.js";
 import { LOCAL, valueSubscriptions } from './Value.js';
-import { reactionSubscriptions } from './Reaction.js';
+import { reactionSubscriptions } from './reactionSubscriptions.js';
 export { LOCAL } from './Value.js';
 let counter = 0;
 function newIncrementalId() {

package/dist/orm/Aggregation.d.ts

@@ -3,15 +3,17 @@ import type {
   QuerySubscriptions,
   QuerySignalOptions
 } from './Query.js'
+import type { PathSegment } from './types/path.js'
 
 export const IS_AGGREGATION: unique symbol
 export const AGGREGATIONS: '$aggregations'
 export const aggregationSubscriptions: QuerySubscriptions
 export function getAggregationSignal (collectionName: string, params: unknown, options?: QuerySignalOptions): Signal
 export function isAggregationSignal ($signal: unknown): boolean | undefined
+export function getAggregationRowId (row: unknown, collectionName?: string): string | undefined
 export function getAggregationDocId (
-  segments: readonly unknown[],
+  segments: readonly PathSegment[],
   rootId?: string,
-  method?: (path: unknown[]) => unknown
+  method?: (path: PathSegment[]) => unknown
 ): string | undefined
-export function getAggregationCollectionName (segments: readonly unknown[]): string | undefined
+export function getAggregationCollectionName (segments: readonly PathSegment[]): string | undefined

package/dist/orm/Aggregation.js

@@ -1,13 +1,14 @@
 import { raw } from '@nx-js/observer-util';
 import { getRaw } from './dataTree.js';
 import getSignal from "./getSignal.js";
-import { QuerySubscriptions, hashQuery, Query, HASH, PARAMS, COLLECTION_NAME, parseQueryHash } from './Query.js';
+import { QuerySubscriptions, hashQuery, Query, cloneQueryParams, HASH, PARAMS, COLLECTION_NAME, parseQueryHash } from './Query.js';
 import Signal, { SEGMENTS } from "./Signal.js";
 import { getIdFieldsForSegments, isPlainObject } from "./idFields.js";
 import { delPrivateData, getPrivateData, setPrivateData } from './privateData.js';
 import { setSignalRuntimeDescriptor } from "./signalRuntimeDescriptor.js";
 export const IS_AGGREGATION = Symbol('is aggregation signal');
 export const AGGREGATIONS = '$aggregations';
+const DEFAULT_AGGREGATION_ID_FIELDS = ['_id', 'id'];
 class Aggregation extends Query {
     _initData() {
         this._syncAllRootsData();
@@ -39,21 +40,31 @@ aggregationSubscriptions.runtimeKind = 'aggregation';
 function injectAggregationIds(extra, collectionName) {
     if (!Array.isArray(extra))
         return;
-    const idFields = getIdFieldsForSegments([collectionName, '']);
+    const idFields = getCollectionIdFields(collectionName);
     for (const doc of extra) {
         if (!isPlainObject(doc))
             continue;
-        const docId = doc._id ?? doc.id;
+        const docId = getAggregationRowId(doc, collectionName);
         if (docId == null)
             continue;
-        if (idFields.includes('_id') && doc._id !== docId)
-            doc._id = docId;
-        if (idFields.includes('id') && doc.id !== docId)
-            doc.id = docId;
+        for (const field of idFields) {
+            if (doc[field] !== docId)
+                doc[field] = docId;
+        }
+    }
+}
+export function getAggregationRowId(row, collectionName) {
+    if (!isPlainObject(row))
+        return;
+    const idFields = getAggregationIdFields(collectionName);
+    for (const field of idFields) {
+        const value = row[field];
+        if (typeof value === 'string')
+            return value;
     }
 }
 export function getAggregationSignal(collectionName, params, options) {
-    params = JSON.parse(JSON.stringify(params));
+    params = cloneQueryParams(collectionName, params);
     const transportHash = hashQuery(collectionName, params);
     const { root, signalOptions } = parseAggregationSignalOptions(options);
     const $aggregation = getSignal(root, [AGGREGATIONS, transportHash], signalOptions);
@@ -80,7 +91,7 @@ export function isAggregationSignal($signal) {
     return true;
 }
 // example: ['$aggregations', '{"active":true}', 42]
-//          AND only if it also has either '_id' or 'id' field inside
+//          AND only if the aggregation row carries a source document id field
 export function getAggregationDocId(segments, rootId, method) {
     if (!(segments.length >= 3))
         return;
@@ -88,15 +99,16 @@ export function getAggregationDocId(segments, rootId, method) {
         return;
     if (!(typeof segments[2] === 'number'))
         return;
+    const collectionName = getAggregationCollectionName(segments);
+    const idFields = getAggregationIdFields(collectionName);
     if (typeof method !== 'function') {
         method = path => rootId == null ? getRaw(path) : getPrivateData(rootId, path);
     }
-    const underscoreId = method([...segments.slice(0, 3), '_id']);
-    if (typeof underscoreId === 'string')
-        return underscoreId;
-    const id = method([...segments.slice(0, 3), 'id']);
-    if (typeof id === 'string')
-        return id;
+    for (const field of idFields) {
+        const id = method([...segments.slice(0, 3), field]);
+        if (typeof id === 'string')
+            return id;
+    }
 }
 export function getAggregationCollectionName(segments) {
     if (!(segments.length >= 2))
@@ -117,3 +129,15 @@ function parseAggregationSignalOptions(options) {
     const { root, ...signalOptions } = options;
     return { root, signalOptions };
 }
+function getAggregationIdFields(collectionName) {
+    const idFields = getCollectionIdFields(collectionName);
+    return uniq(idFields.concat(DEFAULT_AGGREGATION_ID_FIELDS));
+}
+function getCollectionIdFields(collectionName) {
+    return collectionName
+        ? getIdFieldsForSegments([collectionName, ''])
+        : [];
+}
+function uniq(values) {
+    return Array.from(new Set(values));
+}

package/dist/orm/Doc.js

@@ -5,7 +5,6 @@ import { getConnection } from "./connection.js";
 import FinalizationRegistry from "../utils/MockFinalizationRegistry.js";
 import SubscriptionState from './SubscriptionState.js';
 import { getIdFieldsForSegments, injectIdFields, isPlainObject } from "./idFields.js";
-import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js';
 import { getSubscriptionGcDelay } from "./subscriptionGcDelay.js";
 import { isMissingShareDoc } from './missingDoc.js';
 import { getRoot, ROOT_ID, GLOBAL_ROOT_ID, getRootTransportMode } from "./Root.js";
@@ -148,9 +147,6 @@ class Doc {
         doc.on('load', () => this._refData());
         doc.on('create', () => this._refData());
         doc.on('del', () => this._refMissingData());
-        if (isModelEventsEnabled()) {
-            doc.on('op', op => emitDocOp(this.collection, this.docId, op));
-        }
     }
     _refMissingData() {
         _del([this.collection, this.docId]);
@@ -870,57 +866,6 @@ function createPendingDestroyEntry() {
         reject: rejectPending
     };
 }
-function emitDocOp(collection, docId, op) {
-    if (!isModelEventsEnabled())
-        return;
-    const ops = Array.isArray(op) ? op : [op];
-    for (const component of ops) {
-        if (!component || !component.p)
-            continue;
-        const baseSegments = [collection, docId];
-        let pathSegments = baseSegments.concat(component.p);
-        const meta = {};
-        let value;
-        let prevValue;
-        if (has(component, 'si') || has(component, 'sd')) {
-            const index = component.p[component.p.length - 1];
-            meta.op = has(component, 'si') ? 'stringInsert' : 'stringRemove';
-            meta.index = index;
-            pathSegments = baseSegments.concat(component.p.slice(0, -1));
-            value = _getRaw(pathSegments);
-            prevValue = component.sd;
-        }
-        else if (has(component, 'lm')) {
-            meta.op = 'arrayMove';
-            meta.from = component.p[component.p.length - 1];
-            meta.to = component.lm;
-            pathSegments = baseSegments.concat(component.p.slice(0, -1));
-            value = _getRaw(pathSegments);
-        }
-        else if (has(component, 'li') || has(component, 'ld')) {
-            meta.op = has(component, 'li') ? 'arrayInsert' : 'arrayRemove';
-            meta.index = component.p[component.p.length - 1];
-            value = _getRaw(pathSegments);
-            prevValue = component.ld;
-        }
-        else if (has(component, 'na')) {
-            meta.op = 'increment';
-            meta.by = component.na;
-            value = _getRaw(pathSegments);
-            if (typeof value === 'number')
-                prevValue = value - component.na;
-        }
-        else {
-            meta.op = 'set';
-            value = has(component, 'oi') ? component.oi : _getRaw(pathSegments);
-            prevValue = component.od;
-        }
-        emitModelChange(pathSegments, value, prevValue, meta);
-    }
-}
-function has(obj, key) {
-    return Object.prototype.hasOwnProperty.call(obj, key);
-}
 const ERRORS = {
     notSubscribed: $doc => Error('trying to unsubscribe when not subscribed. Doc: ' + $doc.path())
 };

package/dist/orm/Query.d.ts

@@ -113,5 +113,6 @@ export class QuerySubscriptions {
 
 export const querySubscriptions: QuerySubscriptions
 export function getQuerySignal (collectionName: string, params: unknown, options?: QuerySignalOptions): Signal
+export function materializeQueryDataDocsToCollection (collectionName: string, docs: unknown): void
 export function hashQuery (collectionName: string, params: unknown): string
 export function parseQueryHash (hash: string): QueryHashParts

package/dist/orm/Query.js

@@ -2,8 +2,6 @@ import { raw } from '@nx-js/observer-util';
 import { set as _set, getRaw } from './dataTree.js';
 import getSignal from "./getSignal.js";
 import { getConnection } from "./connection.js";
-import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js';
-import { isCompatEnv } from './compatEnv.js';
 import { docSubscriptions } from './Doc.js';
 import FinalizationRegistry from "../utils/MockFinalizationRegistry.js";
 import SubscriptionState from './SubscriptionState.js';
@@ -127,22 +125,6 @@ export class Query {
                     return;
                 docs.splice(index, 0, ...newDocs);
                 idsState.splice(index, 0, ...ids);
-                if (!isModelEventsEnabled())
-                    return;
-                const docsPath = [QUERIES, this.hash, 'docs'];
-                const idsPath = [QUERIES, this.hash, 'ids'];
-                for (let i = 0; i < newDocs.length; i++) {
-                    emitModelChange(rootId, docsPath.concat(index + i), newDocs[i], undefined, {
-                        op: 'queryInsert',
-                        index: index + i
-                    });
-                }
-                for (let i = 0; i < ids.length; i++) {
-                    emitModelChange(rootId, idsPath.concat(index + i), ids[i], undefined, {
-                        op: 'queryInsert',
-                        index: index + i
-                    });
-                }
             });
         });
         this.shareQuery.on('move', (shareDocs, from, to) => {
@@ -153,26 +135,10 @@ export class Query {
                 const ids = getPrivateData(rootId, [QUERIES, this.hash, 'ids']);
                 if (!Array.isArray(docs) || !Array.isArray(ids))
                     return;
-                const prevDocs = isModelEventsEnabled() ? docs.slice() : undefined;
                 docs.splice(from, shareDocs.length);
                 docs.splice(to, 0, ...movedDocs);
-                const prevIds = isModelEventsEnabled() ? ids.slice() : undefined;
                 ids.splice(from, shareDocs.length);
                 ids.splice(to, 0, ...movedIds);
-                if (!isModelEventsEnabled())
-                    return;
-                emitModelChange(rootId, [QUERIES, this.hash, 'docs'], docs, prevDocs, {
-                    op: 'queryMove',
-                    from,
-                    to,
-                    howMany: shareDocs.length
-                });
-                emitModelChange(rootId, [QUERIES, this.hash, 'ids'], ids, prevIds, {
-                    op: 'queryMove',
-                    from,
-                    to,
-                    howMany: shareDocs.length
-                });
             });
         });
         this.shareQuery.on('remove', (shareDocs, index) => {
@@ -187,26 +153,8 @@ export class Query {
                 const ids = getPrivateData(rootId, [QUERIES, this.hash, 'ids']);
                 if (!Array.isArray(docs) || !Array.isArray(ids))
                     return;
-                const removedDocs = isModelEventsEnabled() ? docs.slice(index, index + shareDocs.length) : undefined;
                 docs.splice(index, shareDocs.length);
-                const removedIds = isModelEventsEnabled() ? ids.slice(index, index + docIds.length) : undefined;
                 ids.splice(index, docIds.length);
-                if (!isModelEventsEnabled())
-                    return;
-                const docsPath = [QUERIES, this.hash, 'docs'];
-                const idsPath = [QUERIES, this.hash, 'ids'];
-                for (let i = 0; i < removedDocs.length; i++) {
-                    emitModelChange(rootId, docsPath.concat(index + i), undefined, removedDocs[i], {
-                        op: 'queryRemove',
-                        index: index + i
-                    });
-                }
-                for (let i = 0; i < removedIds.length; i++) {
-                    emitModelChange(rootId, idsPath.concat(index + i), undefined, removedIds[i], {
-                        op: 'queryRemove',
-                        index: index + i
-                    });
-                }
             });
         });
         this.shareQuery.on('extra', extra => {
@@ -465,7 +413,7 @@ export class QuerySubscriptions {
     }
     subscribe($query, { intent = 'subscribe' } = {}) {
         const collectionName = $query[COLLECTION_NAME];
-        const params = cloneQueryParams($query[PARAMS]);
+        const params = cloneQueryParams(collectionName, $query[PARAMS]);
         const transportHash = $query[HASH];
         const rootId = getOwningRootId($query);
         const ownerKey = getQueryOwnerKey(rootId, transportHash);
@@ -887,8 +835,6 @@ export class QuerySubscriptions {
 }
 export const querySubscriptions = new QuerySubscriptions();
 function maybeMaterializeQueryDocsToCollection(collectionName, shareDocs) {
-    if (!isCompatEnv())
-        return;
     for (const doc of shareDocs) {
         if (!doc?.id || doc.data == null)
             continue;
@@ -901,8 +847,26 @@ function maybeMaterializeQueryDocsToCollection(collectionName, shareDocs) {
         _set([collectionName, doc.id], raw(doc.data));
     }
 }
+export function materializeQueryDataDocsToCollection(collectionName, docs) {
+    if (!Array.isArray(docs))
+        return;
+    for (const doc of docs) {
+        const rawDoc = raw(doc);
+        if (!isPlainObject(rawDoc))
+            continue;
+        const docId = rawDoc._id ?? rawDoc.id;
+        if (docId == null)
+            continue;
+        const existing = getRaw([collectionName, docId]);
+        if (existing != null)
+            continue;
+        const idFields = getIdFieldsForSegments([collectionName, docId]);
+        injectIdFields(rawDoc, idFields, docId);
+        _set([collectionName, docId], rawDoc);
+    }
+}
 export function hashQuery(collectionName, params) {
-    params = normalizeQueryParamsForHash(params);
+    params = normalizeQueryParamsForHash(collectionName, params);
     // TODO: probably makes sense to use fast-stable-json-stringify for this because of the params
     return JSON.stringify({ query: [collectionName, params] });
 }
@@ -916,7 +880,7 @@ export function parseQueryHash(hash) {
     }
 }
 export function getQuerySignal(collectionName, params, options) {
-    params = cloneQueryParams(params);
+    params = cloneQueryParams(collectionName, params);
     const transportHash = hashQuery(collectionName, params);
     const { root, signalOptions } = parseQuerySignalOptions(options);
     const signalHash = getScopedSignalHash(root?.[ROOT_ID] ?? signalOptions.rootId, transportHash, 'querySignal');
@@ -969,10 +933,8 @@ function getOwningRootId($query) {
 function getQueryOwnerKey(rootId, transportHash) {
     return getScopedSignalHash(rootId, transportHash, 'queryOwner');
 }
-function cloneQueryParams(params) {
-    if (!isCompatEnv())
-        return JSON.parse(JSON.stringify(params));
-    return cloneQueryParamsCompat(params);
+export function cloneQueryParams(collectionName, params) {
+    return JSON.parse(JSON.stringify(params));
 }
 function parseQuerySignalOptions(options) {
     if (!options || typeof options !== 'object') {
@@ -984,27 +946,8 @@ function parseQuerySignalOptions(options) {
     const { root, ...signalOptions } = options;
     return { root, signalOptions };
 }
-function normalizeQueryParamsForHash(params) {
-    if (!isCompatEnv())
-        return params;
-    return cloneQueryParamsCompat(params);
-}
-// Racer compat: keep query keys with undefined values by normalizing them to null
-// instead of dropping them via JSON serialization.
-function cloneQueryParamsCompat(value) {
-    if (value === undefined)
-        return null;
-    if (value == null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map(item => cloneQueryParamsCompat(item));
-    const object = {};
-    for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            object[key] = cloneQueryParamsCompat(value[key]);
-        }
-    }
-    return object;
+function normalizeQueryParamsForHash(collectionName, params) {
+    return params;
 }
 function createPendingDestroyEntry() {
     let resolvePending;

package/dist/orm/Root.d.ts

@@ -14,8 +14,12 @@ export type RootSignalRuntime = SignalBaseInstance & {
     [ROOT]?: RootSignalRuntime;
     [ROOT_ID]?: string;
 };
+export type RootCloseCallback = (err?: unknown) => void;
 export declare function getRootSignal({ rootFunction, fetchOnly, rootId, ...options }?: RootSignalOptions): RootSignalRuntime;
 export declare function getRoot(signal: RootSignalRuntime | undefined): RootSignalRuntime | undefined;
+export declare function closeRootSignalAsync(signal: RootSignalRuntime | undefined): Promise<void>;
+export declare function closeRootSignal(signal: RootSignalRuntime | undefined): Promise<void>;
+export declare function closeRootSignal(signal: RootSignalRuntime | undefined, callback?: RootCloseCallback): void;
 export declare function getRootFetchOnly(rootOrRootId: RootSignalRuntime | string | undefined): boolean;
 export declare function getRootTransportMode(rootOrRootId: RootSignalRuntime | string | undefined, intent?: RootTransportIntent): RootTransportIntent;
 export declare function registerRootFinalizer($root: RootSignalRuntime | undefined): void;

package/dist/orm/Root.js

@@ -43,6 +43,22 @@ export function getRoot(signal) {
     else
         return undefined;
 }
+export function closeRootSignalAsync(signal) {
+    const $root = getRoot(signal) || signal;
+    const rootId = $root?.[ROOT_ID];
+    unregisterRootFinalizer($root);
+    return disposeRootContext(rootId);
+}
+export function closeRootSignal(signal, callback) {
+    const promise = closeRootSignalAsync(signal);
+    if (!callback)
+        return promise;
+    promise
+        .then(() => callback?.())
+        .catch(err => {
+        callback(err);
+    });
+}
 export function getRootFetchOnly(rootOrRootId) {
     const $root = typeof rootOrRootId === 'string'
         ? undefined

package/dist/orm/Signal.d.ts

@@ -1,4 +1,3 @@
-import SignalCompat from './Compat/SignalCompat.js';
 import type { SignalConstructor } from './types/signal.js';
 export type { FromJsonSchema, InferZodSchema, JsonSchema, JsonSchemaObject, ZodLikeSchema } from './types/jsonSchema.js';
 export type { ComputedQueryParamsInput, QueryParams, QueryParamsInput } from './types/query.js';
@@ -7,6 +6,5 @@ export type { AppendPath, JoinPath, PathSegment, SignalPath, WildcardPathSegment
 export type { AggregationSignal, AnySignal, ArraySignal, CollectionAggregationSignal, CollectionDocument, CollectionDocumentModel, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, DocumentSignal, JsonSchemaSpec, MaybePromise, MaybePromiseSubResult, PublicSignal, LocalSignalFactory, RegisteredAggregationInput, RuntimeSignalConstructor, RuntimeSignalInstance, QuerySignal, RootCollections, RootSignal, SignalBaseInstance, SignalChild, SignalChildren, SignalClass, SignalConstructor, SignalForKind, SignalKind, SignalInstance, SignalModelConstructor, PrivateSignalFromSpec, RootPrivateCollections, SubResult, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodSchemaSpec } from './types/signal.js';
 export type { CollectionsFromManifest, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest } from './types/modelManifest.js';
 export { Signal, SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS, regularBindings, extremelyLateBindings, isPublicCollectionSignal, isPublicDocumentSignal, isPublicCollection, isPrivateCollection } from './SignalBase.js';
-export { SignalCompat };
 declare const DefaultSignal: SignalConstructor;
 export default DefaultSignal;

package/dist/orm/Signal.js

@@ -1,7 +1,4 @@
 import { Signal } from "./SignalBase.js";
-import SignalCompat from './Compat/SignalCompat.js';
-import { isCompatEnv } from './compatEnv.js';
 export { Signal, SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS, regularBindings, extremelyLateBindings, isPublicCollectionSignal, isPublicDocumentSignal, isPublicCollection, isPrivateCollection } from "./SignalBase.js";
-export { SignalCompat };
-const DefaultSignal = (isCompatEnv() ? SignalCompat : Signal);
+const DefaultSignal = Signal;
 export default DefaultSignal;