teamplay 0.5.0-alpha.21 → 0.5.0-alpha.23

package/dist/orm/Compat/SignalCompat.js

@@ -2,7 +2,6 @@ import { raw, observe, unobserve } from '@nx-js/observer-util';
 import arrayDiff from 'arraydiff';
 import { Signal, GETTERS, DEFAULT_GETTERS, SEGMENTS, isPublicCollection, isPublicCollectionSignal, isPublicDocumentSignal } from "../SignalBase.js";
 import { getRoot, ROOT, ROOT_ID, getRootSignal, GLOBAL_ROOT_ID, unregisterRootFinalizer } from "../Root.js";
-import { isPrivateMutationForbidden } from "../connection.js";
 import { docSubscriptions } from '../Doc.js';
 import { IS_QUERY, getQuerySignal, querySubscriptions } from '../Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions, getAggregationSignal } from '../Aggregation.js';
@@ -150,22 +149,6 @@ class SignalCompat extends Signal {
             return Signal.prototype.set.call(this, value);
         return setReplaceOnSignal(this, value);
     }
-    async add(collectionOrValue, value) {
-        const isRoot = this[SEGMENTS].length === 0;
-        const isRootCollectionCall = isRoot && typeof collectionOrValue === 'string';
-        if (isRootCollectionCall) {
-            if (arguments.length !== 2)
-                throw Error('Signal.add() expects (collection, object)');
-            if (!value || typeof value !== 'object')
-                throw Error('Signal.add() expects an object argument');
-            const $root = getRoot(this) || this;
-            const $collection = resolveSignal($root, [collectionOrValue]);
-            return $collection.add(value);
-        }
-        if (arguments.length > 1)
-            throw Error('Signal.add() expects a single argument');
-        return Signal.prototype.add.call(this, collectionOrValue);
-    }
     async setNull(value) {
         const forwarded = forwardRef(this, 'setNull', arguments);
         if (forwarded)
@@ -928,8 +911,6 @@ async function setReplaceOnSignal($signal, value) {
         }
         return result;
     }
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     const result = setReplacePrivateData(getOwningRootId($signal), segments, value);
     if (shouldMirrorPrivateRefMutationLocally()) {
         mirrorRefMutationFromTarget(segments, value);
@@ -956,8 +937,6 @@ async function incrementOnSignal($signal, byNumber) {
         await _incrementPublic(segments, byNumber);
         return currentValue + byNumber;
     }
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     setReplacePrivateData(getOwningRootId($signal), segments, currentValue + byNumber);
     return currentValue + byNumber;
 }
@@ -993,8 +972,6 @@ async function arrayPushOnSignal($signal, value) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayPushPublic(segments, value);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayPushPrivateData(getOwningRootId($signal), segments, value);
 }
 async function arrayUnshiftOnSignal($signal, value) {
@@ -1004,8 +981,6 @@ async function arrayUnshiftOnSignal($signal, value) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayUnshiftPublic(segments, value);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayUnshiftPrivateData(getOwningRootId($signal), segments, value);
 }
 async function arrayInsertOnSignal($signal, index, values) {
@@ -1015,8 +990,6 @@ async function arrayInsertOnSignal($signal, index, values) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayInsertPublic(segments, index, values);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayInsertPrivateData(getOwningRootId($signal), segments, index, values);
 }
 async function arrayPopOnSignal($signal) {
@@ -1026,8 +999,6 @@ async function arrayPopOnSignal($signal) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayPopPublic(segments);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayPopPrivateData(getOwningRootId($signal), segments);
 }
 async function arrayShiftOnSignal($signal) {
@@ -1037,8 +1008,6 @@ async function arrayShiftOnSignal($signal) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayShiftPublic(segments);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayShiftPrivateData(getOwningRootId($signal), segments);
 }
 async function arrayRemoveOnSignal($signal, index, howMany) {
@@ -1048,8 +1017,6 @@ async function arrayRemoveOnSignal($signal, index, howMany) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayRemovePublic(segments, index, howMany);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayRemovePrivateData(getOwningRootId($signal), segments, index, howMany);
 }
 async function arrayMoveOnSignal($signal, from, to, howMany) {
@@ -1059,8 +1026,6 @@ async function arrayMoveOnSignal($signal, from, to, howMany) {
         return;
     if (isPublicCollection(segments[0]))
         return _arrayMovePublic(segments, from, to, howMany);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return arrayMovePrivateData(getOwningRootId($signal), segments, from, to, howMany);
 }
 async function stringInsertOnSignal($signal, index, text) {
@@ -1070,8 +1035,6 @@ async function stringInsertOnSignal($signal, index, text) {
         return;
     if (isPublicCollection(segments[0]))
         return _stringInsertPublic(segments, index, text);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return stringInsertPrivateData(getOwningRootId($signal), segments, index, text);
 }
 async function stringRemoveOnSignal($signal, index, howMany) {
@@ -1081,8 +1044,6 @@ async function stringRemoveOnSignal($signal, index, howMany) {
         return;
     if (isPublicCollection(segments[0]))
         return _stringRemovePublic(segments, index, howMany);
-    if (isPrivateMutationForbidden())
-        throw Error(ERRORS.publicOnly);
     return stringRemovePrivateData(getOwningRootId($signal), segments, index, howMany);
 }
 function getOwningRootId($signal) {
@@ -1264,11 +1225,5 @@ function racerDeepCopy(value) {
     }
     return value;
 }
-const ERRORS = {
-    publicOnly: `
-    Can't modify private collections data when 'publicOnly' is enabled.
-    On the server you can only work with public collections.
-  `
-};
 export { SignalCompat };
 export default SignalCompat;

package/dist/orm/SignalBase.js

@@ -21,7 +21,6 @@ import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
 import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
 import { ROOT_FUNCTION, ROOT_ID, getRoot } from "./Root.js";
-import { isPrivateMutationForbidden } from "./connection.js";
 import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
 import { isCompatEnv } from './compatEnv.js';
 import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js';
@@ -83,7 +82,6 @@ const SIGNAL_READ_CONTEXT = {
 const SIGNAL_VALUE_MUTATION_CONTEXT = {
     getOwningRootId: getSignalOwningRootId,
     isPublicCollection,
-    isPrivateMutationForbidden,
     setPublicDoc: _setPublicDoc,
     setPrivateData,
     deletePublicDoc(segments) {
@@ -308,12 +306,6 @@ export class Signal extends Function {
             }
             return;
         }
-        if (isPrivateMutationForbidden()) {
-            throw Error(`
-        Can't modify private collections data when 'publicOnly' is enabled.
-        On the server you can only work with public collections.
-      `);
-        }
         setReplacePrivateData(getSignalOwningRootId(this), segments, nextValue);
     }
     /** Set the current value only when it is null or undefined. */
@@ -672,12 +664,6 @@ async function deleteForDiffDeep($signal, preservePath) {
         await $signal.del();
         return;
     }
-    if (isPrivateMutationForbidden()) {
-        throw Error(`
-      Can't modify private collections data when 'publicOnly' is enabled.
-      On the server you can only work with public collections.
-    `);
-    }
     delPrivateData(getSignalOwningRootId($signal), segments, { preservePath });
 }
 function getChildSignal($parent, key) {

package/dist/orm/connection.d.ts

@@ -16,11 +16,18 @@ export interface TeamplayConnection {
     [key: string]: unknown;
 }
 export declare let connection: TeamplayConnection | undefined;
-export declare let publicOnly: boolean | 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,7 @@
-import { isCompatEnv } from './compatEnv.js';
 export let connection;
 let defaultFetchOnly;
-export let publicOnly;
+/** @deprecated Root-scoped private data made the publicOnly write guard obsolete. */
+export const publicOnly = false;
 export function setConnection(_connection) {
     connection = _connection;
 }
@@ -20,11 +20,16 @@ export function getDefaultFetchOnly() {
 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) {
-    publicOnly = _publicOnly;
 }
+/** @deprecated publicOnly no longer blocks private writes. */
 export function isPrivateMutationForbidden() {
-    return !!publicOnly && !isCompatEnv();
+    return false;
 }
 const ERRORS = {
     notSet: `

package/dist/orm/privateData.js

@@ -1,6 +1,11 @@
+import isServer from "../utils/isServer.js";
 import { getRootContext } from "./rootContext.js";
-import { getPrivateDataSegments, isPrivateCollectionSegments } from "./rootScope.js";
+import { getPrivateDataSegments, isGlobalRootId, isPrivateCollectionSegments } from "./rootScope.js";
 import { arrayInsert as _arrayInsert, arrayMove as _arrayMove, arrayPop as _arrayPop, arrayPush as _arrayPush, arrayRemove as _arrayRemove, arrayShift as _arrayShift, arrayUnshift as _arrayUnshift, del as _del, set as _set, setReplace as _setReplace, stringInsertLocal as _stringInsertLocal, stringRemoveLocal as _stringRemoveLocal } from './dataTree.js';
+const warnedGlobalRootPrivateCollections = new Set();
+export function __resetPrivateDataWarningsForTests() {
+    warnedGlobalRootPrivateCollections.clear();
+}
 export function getPrivateDataRoot(rootId, create = false) {
     return getRootContext(rootId, create)?.getPrivateDataRoot();
 }
@@ -24,6 +29,7 @@ export function setPrivateData(rootId, logicalSegments, value) {
     const context = getRootContext(rootId, true);
     if (!context)
         return;
+    warnGlobalRootPrivateMutation(rootId, logicalSegments);
     const segments = getPrivateDataSegments(logicalSegments);
     _set(segments, value, context.getPrivateDataRoot(), getModelEventContext(rootId, logicalSegments));
 }
@@ -34,6 +40,7 @@ export function setReplacePrivateData(rootId, logicalSegments, value) {
     const context = getRootContext(rootId, true);
     if (!context)
         return;
+    warnGlobalRootPrivateMutation(rootId, logicalSegments);
     const segments = getPrivateDataSegments(logicalSegments);
     _setReplace(segments, value, context.getPrivateDataRoot(), getModelEventContext(rootId, logicalSegments));
 }
@@ -43,6 +50,7 @@ export function delPrivateData(rootId, logicalSegments, options = {}) {
     const context = getRootContext(rootId, false);
     if (!context)
         return;
+    warnGlobalRootPrivateMutation(rootId, logicalSegments);
     const segments = getPrivateDataSegments(logicalSegments);
     _del(segments, context.getPrivateDataRoot(), getModelEventContext(rootId, logicalSegments));
     pruneEmptyPrivateParents(context.getPrivateDataRoot(), context.getPrivateDataRawRoot(), segments, options);
@@ -108,8 +116,19 @@ function getRequiredPrivateContext(rootId, logicalSegments, methodName) {
     if (!isPrivateCollectionSegments(logicalSegments)) {
         throw Error(`${methodName} expects private collection segments`);
     }
+    warnGlobalRootPrivateMutation(rootId, logicalSegments);
     return getRootContext(rootId, true);
 }
+function warnGlobalRootPrivateMutation(rootId, logicalSegments) {
+    if (!isServer || !isGlobalRootId(rootId) || !isPrivateCollectionSegments(logicalSegments))
+        return;
+    const collection = String(logicalSegments[0]);
+    if (warnedGlobalRootPrivateCollections.has(collection))
+        return;
+    warnedGlobalRootPrivateCollections.add(collection);
+    console.warn(`[teamplay] Writing to private collection "${collection}" on the global server root. ` +
+        'Use a request-scoped root, getRootSignal({ rootId }), or req.model for per-request private state.');
+}
 function getModelEventContext(rootId, logicalSegments) {
     return {
         rootId,

package/dist/orm/signalStorageMutations.d.ts

@@ -3,7 +3,6 @@ type MaybePromise<TValue> = TValue | Promise<TValue>;
 export interface SignalStorageMutationContext<TSignal> {
     getOwningRootId: ($signal: TSignal) => string | undefined;
     isPublicCollection: (segment: PathSegment | undefined) => boolean;
-    isPrivateMutationForbidden: () => boolean;
 }
 export interface SignalStorageMutationHandlers<TResult> {
     public: (segments: PathSegment[]) => MaybePromise<TResult>;
@@ -14,5 +13,4 @@ export interface SignalStorageMutationResult<TResult> {
     value: TResult | undefined;
 }
 export declare function runSignalStorageMutation<TSignal, TResult>($signal: TSignal, context: SignalStorageMutationContext<TSignal>, segments: PathSegment[], handlers: SignalStorageMutationHandlers<TResult>): Promise<SignalStorageMutationResult<TResult>>;
-export declare function ensurePrivateMutationAllowed<TSignal>(context: Pick<SignalStorageMutationContext<TSignal>, 'isPrivateMutationForbidden'>): void;
 export {};

package/dist/orm/signalStorageMutations.js

@@ -10,17 +10,8 @@ export async function runSignalStorageMutation($signal, context, segments, handl
             value: await handlers.public(segments)
         };
     }
-    ensurePrivateMutationAllowed(context);
     return {
         skipped: false,
         value: await handlers.private(context.getOwningRootId($signal), segments)
     };
 }
-export function ensurePrivateMutationAllowed(context) {
-    if (!context.isPrivateMutationForbidden())
-        return;
-    throw Error(`
-    Can't modify private collections data when 'publicOnly' is enabled.
-    On the server you can only work with public collections.
-  `);
-}

package/dist/orm/signalValueMutations.d.ts

@@ -1,4 +1,4 @@
-import { type SignalStorageMutationContext } from './signalStorageMutations.js';
+import type { SignalStorageMutationContext } from './signalStorageMutations.js';
 import { SEGMENTS } from './signalSymbols.js';
 import type { PathSegment } from './types/path.js';
 export interface SignalValueMutationOwner {

package/dist/orm/signalValueMutations.js

@@ -1,5 +1,4 @@
 import { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields } from "./idFields.js";
-import { ensurePrivateMutationAllowed } from "./signalStorageMutations.js";
 import { SEGMENTS } from "./signalSymbols.js";
 export async function setSignalValue($signal, context, value) {
     const segments = $signal[SEGMENTS];
@@ -15,7 +14,6 @@ export async function setSignalValue($signal, context, value) {
         await context.setPublicDoc(segments, nextValue);
         return;
     }
-    ensurePrivateMutationAllowed(context);
     context.setPrivateData(context.getOwningRootId($signal), segments, nextValue);
 }
 export async function deleteSignalValue($signal, context) {
@@ -31,6 +29,5 @@ export async function deleteSignalValue($signal, context) {
         await context.deletePublicDoc(segments);
         return;
     }
-    ensurePrivateMutationAllowed(context);
     context.deletePrivateData(context.getOwningRootId($signal), segments);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.21",
+  "version": "0.5.0-alpha.23",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -134,5 +134,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "9a68b281123d93db5af433fc3e76c6e086b09ac5"
+  "gitHead": "b3dcd5e4b680a5a380fe68ce41f6da93b1deeb85"
 }