teamplay 0.5.0-alpha.35 → 0.5.0-alpha.36

package/dist/index.d.ts

@@ -62,7 +62,7 @@ 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';

package/dist/index.js

@@ -21,7 +21,7 @@ export const observer = runtimeObserver;
 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";

package/dist/orm/Compat/SignalCompat.js

@@ -1,14 +1,12 @@
 import { raw } from '@nx-js/observer-util';
 import arrayDiff from 'arraydiff';
-import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection, isPublicCollectionSignal, isPublicDocumentSignal } from "../SignalBase.js";
+import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection } from "../SignalBase.js";
 import { getRoot, ROOT, ROOT_ID } from "../Root.js";
-import { docSubscriptions } from '../Doc.js';
-import { IS_QUERY, querySubscriptions } from '../Query.js';
-import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
+import { IS_QUERY } from '../Query.js';
+import { AGGREGATIONS, IS_AGGREGATION } from '../Aggregation.js';
 import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from "../idFields.js";
 import { incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, setPublicDocReplace as _setPublicDocReplace, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from '../dataTree.js';
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from '../events.js';
-import { waitForImperativeQueryReady } from '../queryReadiness.js';
 import { runInBatch } from '../batchScheduler.js';
 import { arrayInsertPrivateData, arrayMovePrivateData, arrayPopPrivateData, arrayPushPrivateData, arrayRemovePrivateData, arrayShiftPrivateData, arrayUnshiftPrivateData, delPrivateData, setReplacePrivateData, stringInsertPrivateData, stringRemovePrivateData } from '../privateData.js';
 class SignalCompat extends Signal {
@@ -36,16 +34,6 @@ class SignalCompat extends Signal {
             throw Error('Signal.getDeepCopy() does not accept any arguments');
         return deepCopy(this.get());
     }
-    fetch(...items) {
-        if (items.length > 0)
-            return subscribeMany(items, 'subscribe', 'fetch', 'fetch');
-        return subscribeSelf(this, 'fetch', 'fetch');
-    }
-    unfetch(...items) {
-        if (items.length > 0)
-            return subscribeMany(items, 'unsubscribe', 'fetch', 'unfetch');
-        return unsubscribeSelf(this, 'fetch', 'unfetch');
-    }
     getExtra() {
         if (arguments.length > 0)
             throw Error('Signal.getExtra() does not accept any arguments');
@@ -68,9 +56,7 @@ class SignalCompat extends Signal {
     async set(value) {
         if (arguments.length > 1)
             throw Error('Signal.set() expects a single argument');
-        if (value === undefined)
-            return Signal.prototype.set.call(this, value);
-        return setReplaceOnSignal(this, value);
+        return Signal.prototype.set.call(this, value);
     }
     async setReplace(value) {
         if (arguments.length > 1)
@@ -621,75 +607,6 @@ function deepCopy(value) {
     }
     return racerDeepCopy(rawValue);
 }
-function subscribeMany(items, action, intent = 'subscribe', methodName = action) {
-    const targets = flattenItems(items);
-    const promises = [];
-    for (const target of targets) {
-        if (!target)
-            continue;
-        if (!(target instanceof Signal)) {
-            throw Error(`Signal.${methodName}() accepts only Signal instances. Got: ${target}`);
-        }
-        const result = action === 'subscribe'
-            ? subscribeSelf(target, intent, methodName)
-            : unsubscribeSelf(target, intent, methodName);
-        if (result?.then)
-            promises.push(result);
-    }
-    if (promises.length)
-        return Promise.all(promises);
-}
-function flattenItems(items, result = []) {
-    for (const item of items) {
-        if (!item)
-            continue;
-        if (Array.isArray(item)) {
-            flattenItems(item, result);
-        }
-        else {
-            result.push(item);
-        }
-    }
-    return result;
-}
-function subscribeSelf($signal, intent = 'subscribe', methodName = 'subscribe') {
-    if ($signal[IS_QUERY]) {
-        return (async () => {
-            await querySubscriptions.subscribe($signal, { intent });
-            await waitForImperativeQueryReady($signal);
-        })();
-    }
-    if ($signal[IS_AGGREGATION]) {
-        return (async () => {
-            await aggregationSubscriptions.subscribe($signal, { intent });
-            await waitForImperativeQueryReady($signal);
-        })();
-    }
-    if (isPublicDocumentSignal($signal))
-        return docSubscriptions.subscribe($signal, { intent });
-    if (isPublicCollectionSignal($signal)) {
-        throw Error(`Signal.${methodName}() expects a document or query signal. Use sub($collection, params, { mode: 'fetch' }) for collection fetches.`);
-    }
-    if ($signal[SEGMENTS].length === 0) {
-        throw Error(`Signal.${methodName}() cannot be called on the root signal`);
-    }
-    throw Error(`Signal.${methodName}() expects a document or query signal`);
-}
-function unsubscribeSelf($signal, intent = 'subscribe', methodName = 'unsubscribe') {
-    if ($signal[IS_QUERY])
-        return querySubscriptions.unsubscribe($signal, { intent });
-    if ($signal[IS_AGGREGATION])
-        return aggregationSubscriptions.unsubscribe($signal, { intent });
-    if (isPublicDocumentSignal($signal))
-        return docSubscriptions.unsubscribe($signal, { intent });
-    if (isPublicCollectionSignal($signal)) {
-        throw Error(`Signal.${methodName}() expects a document or query signal`);
-    }
-    if ($signal[SEGMENTS].length === 0) {
-        throw Error(`Signal.${methodName}() cannot be called on the root signal`);
-    }
-    throw Error(`Signal.${methodName}() expects a document or query signal`);
-}
 // Racer-style deep copy:
 // - Preserves prototypes by instantiating via `new value.constructor()`
 // - Copies own enumerable props recursively

package/dist/orm/Doc.js

@@ -5,50 +5,12 @@ 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";
 import { registerRootOwnedDirectDocSubscription, unregisterRootOwnedDirectDocSubscription, getRootOwnedDirectDocSubscriptions, clearRootOwnedDirectDocSubscriptions } from "./rootContext.js";
 const ERROR_ON_EXCESSIVE_UNSUBSCRIBES = false;
 const DOC_FINALIZATION_TOKENS = new WeakMap();
-const RECENT_DOC_OP_CONTEXT_TTL = 100;
-const ACTIVE_DOC_OP_CONTEXTS = [];
-let recentDocOpContext;
-export function getActiveDocOpContext() {
-    return ACTIVE_DOC_OP_CONTEXTS[ACTIVE_DOC_OP_CONTEXTS.length - 1] || recentDocOpContext;
-}
-function pushActiveDocOpContext(collection, docId, source) {
-    const context = { collection, docId, source };
-    ACTIVE_DOC_OP_CONTEXTS.push(context);
-    recentDocOpContext = context;
-}
-function popActiveDocOpContext(collection, docId, source) {
-    const current = ACTIVE_DOC_OP_CONTEXTS[ACTIVE_DOC_OP_CONTEXTS.length - 1];
-    if (current?.collection === collection && current?.docId === docId && current?.source === source) {
-        ACTIVE_DOC_OP_CONTEXTS.pop();
-        clearRecentDocOpContext(current);
-        return;
-    }
-    let index = -1;
-    for (let i = ACTIVE_DOC_OP_CONTEXTS.length - 1; i >= 0; i--) {
-        const context = ACTIVE_DOC_OP_CONTEXTS[i];
-        if (context.collection === collection && context.docId === docId && context.source === source) {
-            index = i;
-            break;
-        }
-    }
-    if (index === -1)
-        return;
-    const [context] = ACTIVE_DOC_OP_CONTEXTS.splice(index, 1);
-    clearRecentDocOpContext(context);
-}
-function clearRecentDocOpContext(context) {
-    setTimeout(() => {
-        if (recentDocOpContext === context)
-            recentDocOpContext = undefined;
-    }, RECENT_DOC_OP_CONTEXT_TTL);
-}
 function getDocFinalizationToken($doc) {
     let token = DOC_FINALIZATION_TOKENS.get($doc);
     if (!token) {
@@ -185,17 +147,6 @@ class Doc {
         doc.on('load', () => this._refData());
         doc.on('create', () => this._refData());
         doc.on('del', () => this._refMissingData());
-        if (isModelEventsEnabled()) {
-            doc.on('before op', (_op, source) => pushActiveDocOpContext(this.collection, this.docId, source));
-            doc.on('op', (op, source) => {
-                try {
-                    emitDocOp(this.collection, this.docId, op, source);
-                }
-                finally {
-                    popActiveDocOpContext(this.collection, this.docId, source);
-                }
-            });
-        }
     }
     _refMissingData() {
         _del([this.collection, this.docId]);
@@ -915,57 +866,6 @@ function createPendingDestroyEntry() {
         reject: rejectPending
     };
 }
-function emitDocOp(collection, docId, op, source) {
-    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 = { source };
-        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.js

@@ -2,7 +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";
@@ -127,22 +126,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 +136,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 +154,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 => {

package/dist/orm/SignalBase.js

@@ -778,8 +778,7 @@ export const regularBindings = {
         return Reflect.apply(extremelyLateBindings.get, this, arguments);
     }
 };
-const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra', 'fetch', 'unfetch'];
-const AGGREGATION_ALLOWED_METHODS = ['fetch', 'unfetch'];
+const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra'];
 // dot syntax always returns a child signal even if such method or property exists.
 // The method is only called when the signal is explicitly called as a function,
 // in which case we get the original method from the raw (non-proxied) parent signal
@@ -824,7 +823,7 @@ export const extremelyLateBindings = {
                     });
                 }
             }
-            else if (!DEFAULT_GETTERS.includes(key) && !AGGREGATION_ALLOWED_METHODS.includes(key)) {
+            else if (!DEFAULT_GETTERS.includes(key)) {
                 throw Error(ERRORS.aggregationSetter(segments, key));
             }
         }

package/dist/orm/connection.d.ts

@@ -16,18 +16,7 @@ export interface TeamplayConnection {
     [key: string]: unknown;
 }
 export declare let connection: TeamplayConnection | undefined;
-/** @deprecated Root-scoped private data made the publicOnly write guard obsolete. */
-export declare const publicOnly = false;
 export declare function setConnection(_connection: TeamplayConnection | undefined): void;
 export declare function getConnection(): TeamplayConnection;
 export declare function setDefaultFetchOnly(_fetchOnly: boolean): void;
 export declare function getDefaultFetchOnly(): boolean;
-export declare function setFetchOnly(_fetchOnly: boolean): void;
-/**
- * @deprecated No-op kept for compatibility with older server bootstrap code.
- * Private collections are root-scoped; server safety now relies on avoiding
- * writes to private collections through the global root.
- */
-export declare function setPublicOnly(_publicOnly: boolean): void;
-/** @deprecated publicOnly no longer blocks private writes. */
-export declare function isPrivateMutationForbidden(): boolean;

package/dist/orm/connection.js

@@ -1,7 +1,5 @@
 export let connection;
 let defaultFetchOnly;
-/** @deprecated Root-scoped private data made the publicOnly write guard obsolete. */
-export const publicOnly = false;
 export function setConnection(_connection) {
     connection = _connection;
 }
@@ -16,21 +14,6 @@ export function setDefaultFetchOnly(_fetchOnly) {
 export function getDefaultFetchOnly() {
     return !!defaultFetchOnly;
 }
-// Deprecated alias kept for internal transition.
-export function setFetchOnly(_fetchOnly) {
-    setDefaultFetchOnly(_fetchOnly);
-}
-/**
- * @deprecated No-op kept for compatibility with older server bootstrap code.
- * Private collections are root-scoped; server safety now relies on avoiding
- * writes to private collections through the global root.
- */
-export function setPublicOnly(_publicOnly) {
-}
-/** @deprecated publicOnly no longer blocks private writes. */
-export function isPrivateMutationForbidden() {
-    return false;
-}
 const ERRORS = {
     notSet: `
     Connection is not set.

package/dist/orm/dataTree.d.ts

@@ -4,18 +4,18 @@ export function getLogicalRootSnapshot(rootId: any, tree?: {}): {
 };
 export function get(segments: any, tree?: {}): {};
 export function getRaw(segments: any): {};
-export function set(segments: any, value: any, tree: {} | undefined, eventContext: any): void;
-export function setReplace(segments: any, value: any, tree: {} | undefined, eventContext: any): void;
-export function del(segments: any, tree: {} | undefined, eventContext: any): void;
+export function set(segments: any, value: any, tree?: {}): void;
+export function setReplace(segments: any, value: any, tree?: {}): void;
+export function del(segments: any, tree?: {}): void;
 export function setPublicDoc(segments: any, value: any, deleteValue?: boolean): Promise<any>;
 export function setPublicDocReplace(segments: any, value: any): Promise<any>;
-export function arrayPush(segments: any, value: any, tree: {} | undefined, eventContext: any): number;
-export function arrayUnshift(segments: any, value: any, tree: {} | undefined, eventContext: any): number;
-export function arrayInsert(segments: any, index: any, values: any, tree: {} | undefined, eventContext: any): number;
-export function arrayPop(segments: any, tree: {} | undefined, eventContext: any): any;
-export function arrayShift(segments: any, tree: {} | undefined, eventContext: any): any;
-export function arrayRemove(segments: any, index: any, howMany: number | undefined, tree: {} | undefined, eventContext: any): any[];
-export function arrayMove(segments: any, from: any, to: any, howMany: number | undefined, tree: {} | undefined, eventContext: any): any[];
+export function arrayPush(segments: any, value: any, tree?: {}): number;
+export function arrayUnshift(segments: any, value: any, tree?: {}): number;
+export function arrayInsert(segments: any, index: any, values: any, tree?: {}): number;
+export function arrayPop(segments: any, tree?: {}): any;
+export function arrayShift(segments: any, tree?: {}): any;
+export function arrayRemove(segments: any, index: any, howMany?: number, tree?: {}): any[];
+export function arrayMove(segments: any, from: any, to: any, howMany?: number, tree?: {}): any[];
 export function incrementPublic(segments: any, byNumber: any): Promise<any>;
 export function arrayPushPublic(segments: any, value: any): Promise<any>;
 export function arrayUnshiftPublic(segments: any, value: any): Promise<any>;
@@ -24,8 +24,8 @@ export function arrayPopPublic(segments: any): Promise<any>;
 export function arrayShiftPublic(segments: any): Promise<any>;
 export function arrayRemovePublic(segments: any, index: any, howMany?: number): Promise<any>;
 export function arrayMovePublic(segments: any, from: any, to: any, howMany?: number): Promise<any>;
-export function stringInsertLocal(segments: any, index: any, text: any, tree: {} | undefined, eventContext: any): any;
-export function stringRemoveLocal(segments: any, index: any, howMany: any, tree: {} | undefined, eventContext: any): any;
+export function stringInsertLocal(segments: any, index: any, text: any, tree?: {}): any;
+export function stringRemoveLocal(segments: any, index: any, howMany: any, tree?: {}): any;
 export function stringInsertPublic(segments: any, index: any, text: any): Promise<any>;
 export function stringRemovePublic(segments: any, index: any, howMany: any): Promise<any>;
 export { isPrivateCollectionSegments } from "./rootScope.js";

package/dist/orm/dataTree.js

@@ -4,8 +4,6 @@ import diffMatchPatch from 'diff-match-patch';
 import { getConnection } from "./connection.js";
 import setDiffDeep from '../utils/setDiffDeep.js';
 import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject, isIdFieldPath } from "./idFields.js";
-import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js';
-import { isSilentContextActive } from './Compat/silentContext.js';
 import { isCompatEnv } from './compatEnv.js';
 import { isMissingShareDoc } from './missingDoc.js';
 import { getLogicalRootSnapshot as getLogicalRootSnapshotFromTree } from "./rootScope.js";
@@ -15,8 +13,6 @@ const ALLOW_PARTIAL_DOC_CREATION = false;
 export const dataTreeRaw = {};
 const dataTree = observable(dataTreeRaw);
 function getWritableTree(tree) {
-    if (isSilentContextActive())
-        return getTreeRaw(tree);
     return tree;
 }
 function getTreeRaw(tree) {
@@ -24,22 +20,6 @@ function getTreeRaw(tree) {
         return dataTreeRaw;
     return raw(tree) || tree;
 }
-function shouldEmitModelEvents(tree, eventContext) {
-    return (tree === dataTree || eventContext?.rootId != null) &&
-        isModelEventsEnabled() &&
-        !isSilentContextActive();
-}
-function emitModelEvent(segments, prevValue, meta, tree = dataTree, eventContext) {
-    if (!shouldEmitModelEvents(tree, eventContext))
-        return;
-    const treeRaw = getTreeRaw(tree);
-    const value = get(segments, treeRaw);
-    const logicalSegments = eventContext?.logicalSegments || segments;
-    const modelEventMeta = eventContext?.rootId != null
-        ? { ...meta, rootId: eventContext.rootId }
-        : meta;
-    emitModelChange(logicalSegments, value, prevValue, modelEventMeta);
-}
 export function resolveStorageSegments(rootId, logicalSegments) {
     return logicalSegments;
 }
@@ -59,10 +39,8 @@ export function get(segments, tree = dataTree) {
 export function getRaw(segments) {
     return get(segments, dataTreeRaw);
 }
-export function set(segments, value, tree = dataTree, eventContext) {
+export function set(segments, value, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     let dataNodeRaw = getTreeRaw(writableTree);
     for (let i = 0; i < segments.length - 1; i++) {
@@ -87,7 +65,6 @@ export function set(segments, value, tree = dataTree, eventContext) {
         return;
     if (value == null || typeof value !== 'object') {
         dataNode[key] = value;
-        emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext);
         return;
     }
     // instead of just setting the new value `dataNode[key] = value` we want
@@ -97,7 +74,6 @@ export function set(segments, value, tree = dataTree, eventContext) {
     // (we just set it to this value)
     if (dataNode[key] !== newValue)
         dataNode[key] = newValue;
-    emitModelEvent(segments, prevValue, { op: 'set' }, tree, eventContext);
 }
 function hasOwnDataKey(node, key) {
     if (node == null)
@@ -107,10 +83,8 @@ function hasOwnDataKey(node, key) {
     return Object.prototype.hasOwnProperty.call(node, key);
 }
 // Like set(), but always assigns the value without equality checks or delete-on-null behavior
-export function setReplace(segments, value, tree = dataTree, eventContext) {
+export function setReplace(segments, value, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -127,12 +101,9 @@ export function setReplace(segments, value, tree = dataTree, eventContext) {
     }
     const key = segments[segments.length - 1];
     dataNode[key] = value;
-    emitModelEvent(segments, prevValue, { op: 'setReplace' }, tree, eventContext);
 }
-export function del(segments, tree = dataTree, eventContext) {
+export function del(segments, tree = dataTree) {
     const writableTree = getWritableTree(tree);
-    const shouldEmit = shouldEmitModelEvents(tree, eventContext);
-    const prevValue = shouldEmit ? get(segments, getTreeRaw(tree)) : undefined;
     let dataNode = writableTree;
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -154,7 +125,6 @@ export function del(segments, tree = dataTree, eventContext) {
             return;
         delete dataNode[key];
     }
-    emitModelEvent(segments, prevValue, { op: 'del' }, tree, eventContext);
 }
 export async function setPublicDoc(segments, value, deleteValue = false) {
     if (segments.length === 0)
@@ -506,56 +476,38 @@ function getArrayNode(segments, tree = dataTree, create = true) {
     }
     return dataNode;
 }
-export function arrayPush(segments, value, tree = dataTree, eventContext) {
+export function arrayPush(segments, value, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const index = arr.length;
-    const result = arr.push(value);
-    emitModelEvent(segments.concat(index), undefined, { op: 'arrayPush', index }, tree, eventContext);
-    return result;
+    return arr.push(value);
 }
-export function arrayUnshift(segments, value, tree = dataTree, eventContext) {
+export function arrayUnshift(segments, value, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const result = arr.unshift(value);
-    emitModelEvent(segments.concat(0), undefined, { op: 'arrayUnshift', index: 0 }, tree, eventContext);
-    return result;
+    return arr.unshift(value);
 }
-export function arrayInsert(segments, index, values, tree = dataTree, eventContext) {
+export function arrayInsert(segments, index, values, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     const inserted = Array.isArray(values) ? values : [values];
     arr.splice(index, 0, ...inserted);
-    for (let i = 0; i < inserted.length; i++) {
-        emitModelEvent(segments.concat(index + i), undefined, { op: 'arrayInsert', index: index + i }, tree, eventContext);
-    }
     return arr.length;
 }
-export function arrayPop(segments, tree = dataTree, eventContext) {
+export function arrayPop(segments, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     if (!arr.length)
         return;
-    const index = arr.length - 1;
-    const previous = arr.pop();
-    emitModelEvent(segments.concat(index), previous, { op: 'arrayPop', index }, tree, eventContext);
-    return previous;
+    return arr.pop();
 }
-export function arrayShift(segments, tree = dataTree, eventContext) {
+export function arrayShift(segments, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
     if (!arr.length)
         return;
-    const previous = arr.shift();
-    emitModelEvent(segments.concat(0), previous, { op: 'arrayShift', index: 0 }, tree, eventContext);
-    return previous;
+    return arr.shift();
 }
-export function arrayRemove(segments, index, howMany = 1, tree = dataTree, eventContext) {
+export function arrayRemove(segments, index, howMany = 1, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const removed = arr.splice(index, howMany);
-    for (let i = 0; i < removed.length; i++) {
-        emitModelEvent(segments.concat(index + i), removed[i], { op: 'arrayRemove', index: index + i, howMany }, tree, eventContext);
-    }
-    return removed;
+    return arr.splice(index, howMany);
 }
-export function arrayMove(segments, from, to, howMany = 1, tree = dataTree, eventContext) {
+export function arrayMove(segments, from, to, howMany = 1, tree = dataTree) {
     const arr = getArrayNode(segments, tree, true);
-    const prevValue = shouldEmitModelEvents(tree, eventContext) ? arr.slice() : undefined;
     const len = arr.length;
     if (from < 0)
         from += len;
@@ -563,7 +515,6 @@ export function arrayMove(segments, from, to, howMany = 1, tree = dataTree, even
         to += len;
     const moved = arr.splice(from, howMany);
     arr.splice(to, 0, ...moved);
-    emitModelEvent(segments, prevValue, { op: 'arrayMove', from, to, howMany }, tree, eventContext);
     return moved;
 }
 export async function incrementPublic(segments, byNumber) {
@@ -732,7 +683,7 @@ export async function arrayMovePublic(segments, from, to, howMany = 1) {
         doc.submitOp(op, err => err ? reject(err) : resolve(moved));
     });
 }
-export function stringInsertLocal(segments, index, text, tree = dataTree, eventContext) {
+export function stringInsertLocal(segments, index, text, tree = dataTree) {
     let dataNode = getWritableTree(tree);
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -745,17 +696,15 @@ export function stringInsertLocal(segments, index, text, tree = dataTree, eventC
     const previous = dataNode[key];
     if (previous == null) {
         dataNode[key] = text;
-        emitModelEvent(segments, previous, { op: 'stringInsert', index }, tree, eventContext);
         return previous;
     }
     if (typeof previous !== 'string') {
         throw Error(`Expected string at ${segments.join('.')}`);
     }
     dataNode[key] = previous.slice(0, index) + text + previous.slice(index);
-    emitModelEvent(segments, previous, { op: 'stringInsert', index }, tree, eventContext);
     return previous;
 }
-export function stringRemoveLocal(segments, index, howMany, tree = dataTree, eventContext) {
+export function stringRemoveLocal(segments, index, howMany, tree = dataTree) {
     let dataNode = getWritableTree(tree);
     for (let i = 0; i < segments.length - 1; i++) {
         const segment = segments[i];
@@ -771,7 +720,6 @@ export function stringRemoveLocal(segments, index, howMany, tree = dataTree, eve
         throw Error(`Expected string at ${segments.join('.')}`);
     }
     dataNode[key] = previous.slice(0, index) + previous.slice(index + howMany);
-    emitModelEvent(segments, previous, { op: 'stringRemove', index, howMany }, tree, eventContext);
     return previous;
 }
 export async function stringInsertPublic(segments, index, text) {

package/dist/orm/disposeRootContext.js

@@ -27,7 +27,6 @@ async function runDispose(rootId) {
     const context = getRootContext(rootId, false);
     if (!context)
         return;
-    context.resetModelListeners();
     for (const transportHash of Array.from(context.queryRuntimeHashes)) {
         await querySubscriptions.destroyByRuntimeHash(transportHash, { rootId, force: true });
     }

package/dist/orm/rootContext.d.ts

@@ -2,15 +2,9 @@ import type { PathSegment } from './types/path.js';
 type RootId = string | null | undefined;
 type DataTree = Record<string | number, unknown>;
 type RuntimeKind = 'query' | 'aggregation';
-type ModelEventStore = Map<string, unknown>;
 interface RootContextOptions {
     fetchOnly?: boolean;
 }
-interface ModelListeners {
-    change: ModelEventStore;
-    all: ModelEventStore;
-    [eventName: string]: ModelEventStore;
-}
 export interface DirectDocSubscriptionEntry {
     segments: PathSegment[];
     count: number;
@@ -21,13 +15,11 @@ export default class RootContext {
     fetchOnly: boolean;
     privateDataRaw: DataTree;
     privateData: DataTree;
-    readonly modelListeners: ModelListeners;
     readonly queryRuntimeHashes: Set<string>;
     readonly aggregationRuntimeHashes: Set<string>;
     readonly signalHashes: Set<string>;
     readonly directDocSubscriptions: Map<string, DirectDocSubscriptionEntry>;
     constructor(rootId: RootId, { fetchOnly }?: RootContextOptions);
-    getModelEventStore(eventName: string, create?: boolean): ModelEventStore;
     getFetchOnly(): boolean;
     setFetchOnly(value: boolean): void;
     getPrivateDataRoot(): DataTree;
@@ -43,7 +35,6 @@ export default class RootContext {
     unregisterSignalHash(signalHash: string | null | undefined): void;
     registerDirectDocSubscription(hash: string | null | undefined, segments: readonly PathSegment[], token?: unknown): void;
     unregisterDirectDocSubscription(hash: string | null | undefined, token?: unknown): void;
-    resetModelListeners(): void;
     resetRuntimeHashes(): void;
     resetPrivateData(): void;
     resetSignalHashes(): void;

package/dist/orm/rootContext.js

@@ -12,10 +12,6 @@ export default class RootContext {
     fetchOnly;
     privateDataRaw;
     privateData;
-    modelListeners = {
-        change: new Map(),
-        all: new Map()
-    };
     queryRuntimeHashes = new Set();
     aggregationRuntimeHashes = new Set();
     signalHashes = new Set();
@@ -26,14 +22,6 @@ export default class RootContext {
         this.privateDataRaw = {};
         this.privateData = observable(this.privateDataRaw);
     }
-    getModelEventStore(eventName, create = false) {
-        let store = this.modelListeners[eventName];
-        if (!store && create) {
-            store = new Map();
-            this.modelListeners[eventName] = store;
-        }
-        return store;
-    }
     getFetchOnly() {
         return !!this.fetchOnly;
     }
@@ -122,11 +110,6 @@ export default class RootContext {
         if (entry.count === 0)
             this.directDocSubscriptions.delete(hash);
     }
-    resetModelListeners() {
-        for (const store of Object.values(this.modelListeners)) {
-            store.clear();
-        }
-    }
     resetRuntimeHashes() {
         this.queryRuntimeHashes.clear();
         this.aggregationRuntimeHashes.clear();
@@ -143,7 +126,6 @@ export default class RootContext {
     }
     isRuntimeEmpty() {
         return (isPlainObjectEmpty(this.privateData) &&
-            Object.values(this.modelListeners).every(store => store.size === 0) &&
             this.queryRuntimeHashes.size === 0 &&
             this.aggregationRuntimeHashes.size === 0 &&
             this.signalHashes.size === 0 &&

package/dist/server.d.ts

@@ -1,7 +1,6 @@
 export function createBackend(options?: {}): any;
-export function initConnection(backend: any, { fetchOnly, publicOnly, idFields, ...options }?: {
+export function initConnection(backend: any, { fetchOnly, idFields, ...options }?: {
     fetchOnly?: boolean | undefined;
-    publicOnly?: boolean | undefined;
 }): {
     middleware: (req: any, res: any, next: any) => Promise<any>;
     upgrade: (req: any, socket: any, upgradeHead: any) => Promise<void>;

package/dist/server.js

@@ -1,7 +1,7 @@
 import createChannel from '@teamplay/channel/server';
 import backendCreateBackend from '@teamplay/backend';
 import { getModels } from "./orm/initModels.js";
-import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from "./orm/connection.js";
+import { connection, setConnection, setDefaultFetchOnly } from "./orm/connection.js";
 import { configureTeamplay } from "./config.js";
 export { default as ShareDB } from 'sharedb';
 export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite, getRedis, Redis, getRedisOptions, redisPrefix, generateRedisPrefix } from '@teamplay/backend';
@@ -17,7 +17,7 @@ export function createBackend(options = {}) {
     return backendCreateBackend(nextOptions);
 }
 export default createBackend;
-export function initConnection(backend, { fetchOnly = true, publicOnly = true, idFields, ...options } = {}) {
+export function initConnection(backend, { fetchOnly = true, idFields, ...options } = {}) {
     if (!backend)
         throw Error('backend is required');
     if (connection)
@@ -26,6 +26,5 @@ export function initConnection(backend, { fetchOnly = true, publicOnly = true, i
         configureTeamplay({ idFields });
     setConnection(backend.connect());
     setDefaultFetchOnly(fetchOnly);
-    setPublicOnly(publicOnly);
     return createChannel(backend, options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.35",
+  "version": "0.5.0-alpha.36",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -138,5 +138,6 @@
       "<rootDir>/test_client/helpers"
     ]
   },
-  "license": "MIT"
+  "license": "MIT",
+  "gitHead": "c83e516afe64e94e7703529d04aed73ac3b27bfa"
 }

package/dist/orm/Compat/modelEvents.d.ts

@@ -1,6 +0,0 @@
-export function isModelEventsEnabled(): boolean;
-export function normalizePattern(pattern: any, methodName: any): string | null;
-export function onModelEvent(rootId: any, eventName: any, pattern: any, handler: any): any;
-export function removeModelListener(rootId: any, eventName: any, handler: any): void;
-export function emitModelChange(path: any, value: any, prevValue: any, meta: any): void;
-export function __resetModelEventsForTests(): void;

package/dist/orm/Compat/modelEvents.js

@@ -1,143 +0,0 @@
-import { isCompatEnv } from '../compatEnv.js';
-import { isSilentContextActive, isModelEventsSilentContextActive } from './silentContext.js';
-import { normalizeRootId } from "../rootScope.js";
-import { getRootContext, getRootContexts } from "../rootContext.js";
-const MODEL_EVENT_NAMES = ['change', 'all'];
-export function isModelEventsEnabled() {
-    return isCompatEnv();
-}
-export function normalizePattern(pattern, methodName) {
-    if (pattern && typeof pattern.path === 'function')
-        pattern = pattern.path();
-    if (pattern == null || typeof pattern !== 'string') {
-        if (methodName)
-            throw Error(`${methodName} expects a string path or a signal`);
-        return null;
-    }
-    return pattern.split('.').filter(Boolean).join('.');
-}
-export function onModelEvent(rootId, eventName, pattern, handler) {
-    if (typeof handler !== 'function')
-        throw Error('Model event handler must be a function');
-    if (!MODEL_EVENT_NAMES.includes(eventName))
-        throw Error(`Unsupported model event: ${eventName}`);
-    const store = getModelEventRootStore(eventName, rootId, true);
-    const normalized = normalizePattern(pattern);
-    let entry = store.get(normalized);
-    if (!entry) {
-        entry = {
-            pattern: normalized,
-            segments: splitPattern(normalized),
-            handlers: new Set()
-        };
-        store.set(normalized, entry);
-    }
-    entry.handlers.add(handler);
-    return handler;
-}
-export function removeModelListener(rootId, eventName, handler) {
-    const store = getModelEventRootStore(eventName, rootId);
-    if (!store)
-        return;
-    for (const [pattern, entry] of store) {
-        entry.handlers.delete(handler);
-        if (!entry.handlers.size)
-            store.delete(pattern);
-    }
-}
-export function emitModelChange(path, value, prevValue, meta) {
-    if (!isModelEventsEnabled())
-        return;
-    if (isSilentContextActive() || isModelEventsSilentContextActive())
-        return;
-    const initialSegments = splitPath(path);
-    const eventName = meta?.eventName || 'change';
-    const rootIds = getTargetRootIds(meta?.rootId);
-    for (const rootId of rootIds) {
-        emitForEvent(rootId, 'change', initialSegments, value, prevValue, meta);
-        emitForEvent(rootId, 'all', initialSegments, value, prevValue, meta, eventName);
-    }
-}
-export function __resetModelEventsForTests() {
-    for (const context of getRootContexts()) {
-        context.resetModelListeners();
-    }
-}
-function emitForEvent(rootId, eventName, pathSegments, value, prevValue, meta, resolvedEventName = eventName) {
-    const store = getModelEventRootStore(eventName, rootId);
-    if (!store || store.size === 0)
-        return;
-    for (const entry of store.values()) {
-        const captures = matchPattern(entry.segments, pathSegments);
-        if (!captures)
-            continue;
-        for (const handler of entry.handlers) {
-            if (eventName === 'all') {
-                handler(...captures, resolvedEventName, value, prevValue, meta);
-            }
-            else {
-                handler(...captures, value, prevValue, meta);
-            }
-        }
-    }
-}
-function splitPattern(pattern) {
-    if (!pattern)
-        return [];
-    return pattern.split('.').filter(Boolean);
-}
-function getModelEventRootStore(eventName, rootId, create = false) {
-    return getRootContext(normalizeRootId(rootId), create)?.getModelEventStore(eventName, create);
-}
-function getModelEventRootIds() {
-    const rootIds = new Set();
-    for (const context of getRootContexts()) {
-        for (const store of Object.values(context.modelListeners)) {
-            if (store.size)
-                rootIds.add(context.rootId);
-        }
-    }
-    return rootIds;
-}
-function getTargetRootIds(rootId) {
-    if (rootId != null)
-        return [normalizeRootId(rootId)];
-    return getModelEventRootIds();
-}
-function splitPath(path) {
-    if (Array.isArray(path))
-        return path.map(segment => String(segment));
-    if (!path)
-        return [];
-    return String(path).split('.').filter(Boolean);
-}
-function matchPattern(patternSegments, pathSegments) {
-    function walk(patternIndex, pathIndex) {
-        if (patternIndex === patternSegments.length) {
-            return pathIndex === pathSegments.length ? [] : null;
-        }
-        const segment = patternSegments[patternIndex];
-        if (segment === '**') {
-            for (let i = pathIndex; i <= pathSegments.length; i++) {
-                const rest = walk(patternIndex + 1, i);
-                if (rest !== null) {
-                    const capture = pathSegments.slice(pathIndex, i).join('.');
-                    return [capture, ...rest];
-                }
-            }
-            return null;
-        }
-        if (pathIndex >= pathSegments.length)
-            return null;
-        if (segment === '*') {
-            const rest = walk(patternIndex + 1, pathIndex + 1);
-            if (rest === null)
-                return null;
-            return [pathSegments[pathIndex], ...rest];
-        }
-        if (segment !== pathSegments[pathIndex])
-            return null;
-        return walk(patternIndex + 1, pathIndex + 1);
-    }
-    return walk(0, 0);
-}

package/dist/orm/Compat/silentContext.d.ts

@@ -1,4 +0,0 @@
-export function isSilentContextActive(): boolean;
-export function isModelEventsSilentContextActive(): boolean;
-export function runInModelEventsSilentContext(fn: any): any;
-export function __resetSilentContextForTests(): void;

package/dist/orm/Compat/silentContext.js

@@ -1,19 +0,0 @@
-let modelEventsSilentDepth = 0;
-export function isSilentContextActive() {
-    return false;
-}
-export function isModelEventsSilentContextActive() {
-    return modelEventsSilentDepth > 0;
-}
-export function runInModelEventsSilentContext(fn) {
-    modelEventsSilentDepth += 1;
-    try {
-        return fn();
-    }
-    finally {
-        modelEventsSilentDepth -= 1;
-    }
-}
-export function __resetSilentContextForTests() {
-    modelEventsSilentDepth = 0;
-}