teamplay 0.5.0-alpha.2 → 0.5.0-alpha.21

package/dist/orm/SignalBase.js

@@ -12,15 +12,17 @@
  * 3. If extremely late bindings are enabled, to prevent name collisions when accessing fields
  *    in the raw data tree which have the same name as signal's methods
  */
+import { raw } from '@nx-js/observer-util';
+import arrayDiff from 'arraydiff';
 import uuid from '@teamplay/utils/uuid';
-import { get as _get, setPublicDoc as _setPublicDoc, dataTreeRaw, getRaw, getLogicalRootSnapshot, incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from './dataTree.js';
+import { get as _get, setPublicDoc as _setPublicDoc, setPublicDocReplace as _setPublicDocReplace, del as _del, dataTreeRaw, getRaw, getLogicalRootSnapshot, incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from './dataTree.js';
 import getSignal, { rawSignal } from "./getSignal.js";
 import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
-import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.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, prepareAddPayload, resolveAddDocId } from "./idFields.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';
 import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js';
@@ -147,6 +149,12 @@ export class Signal extends Function {
     get [Symbol.toStringTag]() {
         return 'Signal';
     }
+    /** Return the owning root signal. */
+    root() {
+        if (arguments.length > 0)
+            throw Error('Signal.root() does not accept any arguments');
+        return getRoot(this) || this;
+    }
     /**
      * Return the parent signal `levels` above this signal.
      * @param levels Number of parent levels to walk upward. Defaults to `1`.
@@ -196,6 +204,28 @@ export class Signal extends Function {
             throw Error('Signal.getIds() does not accept any arguments');
         return getSignalIds(this, SIGNAL_READ_CONTEXT);
     }
+    /** Return query extra data, aggregation data, or undefined for ordinary signals. */
+    getExtra() {
+        if (arguments.length > 0)
+            throw Error('Signal.getExtra() does not accept any arguments');
+        if (this[IS_AGGREGATION])
+            return this.get();
+        if (this[IS_QUERY])
+            return this.extra.get();
+        return undefined;
+    }
+    /** Return a shallow copy of the current value. */
+    getCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getCopy() does not accept any arguments');
+        return shallowCopy(this.get());
+    }
+    /** Return a deep copy of the current value. */
+    getDeepCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getDeepCopy() does not accept any arguments');
+        return deepCopy(this.get());
+    }
     /** Read the current value without tracking it for reactive rendering. */
     peek() {
         if (arguments.length > 0)
@@ -205,7 +235,10 @@ export class Signal extends Function {
     /** Return the document id represented by this document signal. */
     getId() {
         const $root = getRoot(this) || this;
-        return getSignalId(this, $root?.[ROOT_ID]);
+        const rootId = $root?.[ROOT_ID];
+        return getSignalId(this, rootId, segments => (isPrivateSignalSegments(segments)
+            ? getPrivateData(rootId, segments)
+            : _get(getSignalStorageSegments({ [SEGMENTS]: segments }))));
     }
     /** Return the public collection name this signal belongs to. */
     getCollection() {
@@ -247,6 +280,86 @@ export class Signal extends Function {
             throw Error('Signal.set() expects a single argument');
         await setSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT, value);
     }
+    /**
+     * Replace this signal's value without deep-diffing object/array branches.
+     * @param value New value to store at this signal path.
+     */
+    async setReplace(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setReplace() expects a single argument');
+        const segments = this[SEGMENTS];
+        if (segments.length === 0)
+            throw Error('Can\'t set the root signal data');
+        const idFields = getIdFieldsForSegments(segments);
+        if (isIdFieldPath(segments, idFields))
+            return;
+        const nextValue = isPublicDocPath(segments)
+            ? normalizeIdFields(value, idFields, segments[1])
+            : value;
+        if (isPublicCollection(segments[0])) {
+            if (value === undefined) {
+                await _setPublicDoc(segments, nextValue);
+                if (segments.length === 2) {
+                    _del(segments);
+                }
+            }
+            else {
+                await _setPublicDocReplace(segments, nextValue);
+            }
+            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. */
+    async setNull(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setNull() expects a single argument');
+        if (this.get() != null)
+            return;
+        await this.setReplace(value);
+    }
+    /** Replace the current value unless it is exactly equal to the new value. */
+    async setDiff(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setDiff() expects a single argument');
+        const before = this.peek();
+        if (racerEqual(before, value))
+            return;
+        await this.setReplace(value);
+    }
+    /** Recursively diff objects and arrays at the current signal path. */
+    async setDiffDeep(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setDiffDeep() expects a single argument');
+        await runInBatch(() => setDiffDeepOnSignal(this, value));
+    }
+    /**
+     * Set multiple object fields with per-key replace semantics.
+     * Unlike assign(), null is stored as null and undefined follows setReplace() semantics.
+     * @param object Object containing fields to set.
+     */
+    async setEach(object) {
+        if (arguments.length > 1)
+            throw Error('Signal.setEach() expects a single argument');
+        if (!object)
+            return;
+        if (typeof object !== 'object') {
+            throw Error('Signal.setEach() expects an object argument, got: ' + typeof object);
+        }
+        await runInBatch(async () => {
+            const promises = [];
+            for (const key of Object.keys(object)) {
+                promises.push(this[key].setReplace(object[key]));
+            }
+            await Promise.all(promises);
+        });
+    }
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.
@@ -477,6 +590,183 @@ export class Signal extends Function {
         await deleteSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT);
     }
 }
+async function setDiffDeepOnSignal($target, value) {
+    if ($target[SEGMENTS].length === 0)
+        throw Error('Can\'t set the root signal data');
+    await diffDeepOnSignal($target, $target.peek(), value);
+}
+async function diffDeepOnSignal($signal, before, after) {
+    if (before === after)
+        return;
+    if (Array.isArray(before) && Array.isArray(after)) {
+        const diff = arrayDiff(before, after, deepEqual);
+        if (!diff.length)
+            return;
+        const index = getSingleArrayReplacementIndex(diff);
+        if (index != null) {
+            await diffDeepOnSignal(getChildSignal($signal, index), before[index], after[index]);
+            return;
+        }
+        await applyArrayDiff($signal, diff);
+        return;
+    }
+    if (isDiffableObject(before, after)) {
+        const preservePath = $signal[SEGMENTS];
+        for (const key of Object.keys(before)) {
+            if (Object.prototype.hasOwnProperty.call(after, key))
+                continue;
+            await deleteForDiffDeep(getChildSignal($signal, key), preservePath);
+        }
+        for (const key of Object.keys(after)) {
+            await diffDeepOnSignal(getChildSignal($signal, key), before[key], after[key]);
+        }
+        return;
+    }
+    await $signal.setReplace(after);
+}
+function isDiffableObject(before, after) {
+    if (!isPlainObject(before) || !isPlainObject(after))
+        return false;
+    if (isReactLike(before) || isReactLike(after))
+        return false;
+    return true;
+}
+function isReactLike(value) {
+    return !!(value && typeof value === 'object' && typeof value.$$typeof === 'symbol');
+}
+function getSingleArrayReplacementIndex(diff) {
+    if (!Array.isArray(diff) || diff.length !== 2)
+        return null;
+    const first = diff[0];
+    const second = diff[1];
+    if (first instanceof arrayDiff.RemoveDiff &&
+        second instanceof arrayDiff.InsertDiff &&
+        first.index === second.index &&
+        first.howMany === 1 &&
+        second.values.length === 1) {
+        return first.index;
+    }
+    return null;
+}
+async function applyArrayDiff($signal, diff) {
+    for (const item of diff) {
+        if (item instanceof arrayDiff.InsertDiff) {
+            await $signal.insert(item.index, item.values);
+            continue;
+        }
+        if (item instanceof arrayDiff.RemoveDiff) {
+            await $signal.remove(item.index, item.howMany);
+            continue;
+        }
+        if (item instanceof arrayDiff.MoveDiff) {
+            await $signal.move(item.from, item.to, item.howMany);
+        }
+    }
+}
+async function deleteForDiffDeep($signal, preservePath) {
+    const segments = $signal[SEGMENTS];
+    const idFields = getIdFieldsForSegments(segments);
+    if (isIdFieldPath(segments, idFields))
+        return;
+    if (isPublicCollection(segments[0])) {
+        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) {
+    return getSignal(getRoot($parent) || $parent, [...$parent[SEGMENTS], key]);
+}
+function deepEqual(left, right) {
+    if (left === right)
+        return true;
+    if (left == null || right == null)
+        return false;
+    if (typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left)) {
+        if (left.length !== right.length)
+            return false;
+        for (let i = 0; i < left.length; i++) {
+            if (!deepEqual(left[i], right[i]))
+                return false;
+        }
+        return true;
+    }
+    if (!isPlainObject(left) || !isPlainObject(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key))
+            return false;
+        if (!deepEqual(left[key], right[key]))
+            return false;
+    }
+    return true;
+}
+function racerEqual(left, right) {
+    return left === right || (Number.isNaN(left) && Number.isNaN(right));
+}
+function shallowCopy(value) {
+    const rawValue = raw(value);
+    if (Array.isArray(rawValue))
+        return rawValue.slice();
+    if (rawValue && typeof rawValue === 'object')
+        return { ...rawValue };
+    return rawValue;
+}
+function deepCopy(value) {
+    const rawValue = raw(value);
+    if (!rawValue || typeof rawValue !== 'object')
+        return rawValue;
+    if (typeof globalThis.structuredClone === 'function') {
+        try {
+            return globalThis.structuredClone(rawValue);
+        }
+        catch { }
+    }
+    return racerDeepCopy(rawValue);
+}
+// Racer-style deep copy:
+// - Preserves prototypes by instantiating via `new value.constructor()`
+// - Copies own enumerable props recursively
+// - Keeps functions as-is (no cloning)
+// - Handles Date by creating a new Date
+// Limitations: does not handle cyclic refs, Map/Set/RegExp/TypedArray, non-enumerables.
+function racerDeepCopy(value) {
+    if (value instanceof Date)
+        return new Date(value);
+    if (typeof value === 'object') {
+        if (value === null)
+            return null;
+        if (Array.isArray(value)) {
+            const array = [];
+            for (let i = value.length; i--;) {
+                array[i] = racerDeepCopy(value[i]);
+            }
+            return array;
+        }
+        const object = new value.constructor();
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                object[key] = racerDeepCopy(value[key]);
+            }
+        }
+        return object;
+    }
+    return value;
+}
 // dot syntax returns a child signal only if no such method or property exists
 export const regularBindings = {
     apply(signal, thisArg, argumentsList) {
@@ -510,8 +800,9 @@ export const extremelyLateBindings = {
         if (segments[0] === AGGREGATIONS) {
             const aggregationDocId = getAggregationDocId(segments, getRoot(signal)?.[ROOT_ID]);
             if (aggregationDocId) {
-                if (segments.length === 3 && key === 'set')
+                if (segments.length === 3 && (key === 'set' || key === 'setReplace')) {
                     throw Error(ERRORS.setAggregationDoc(segments, key));
+                }
                 const collectionName = getAggregationCollectionName(segments);
                 const subDocSegments = segments.slice(3);
                 const $original = getSignal(getRoot(signal), [collectionName, aggregationDocId, ...subDocSegments]);

package/dist/orm/addModel.d.ts

@@ -1,6 +1,13 @@
 import type { SignalClass } from './Signal.js';
-import type { TeamplayModels } from '../index.js';
+import type { TeamplayModels, TeamplayPluginModels } from '../index.js';
 import type { PathSegment } from './types/path.js';
 export declare const MODELS: Record<string, SignalClass<any>>;
-export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof TeamplayModels ? TeamplayModels[TPattern] : SignalClass<any>): void;
+type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+type RegistryValues<TRegistry> = TRegistry[keyof TRegistry & string];
+type MergeRegistry<TRegistry> = [
+    RegistryValues<TRegistry>
+] extends [never] ? {} : UnionToIntersection<RegistryValues<TRegistry>>;
+type EffectiveTeamplayModels = TeamplayModels & MergeRegistry<TeamplayPluginModels>;
+export default function addModel<TPattern extends string>(pattern: TPattern, Model: TPattern extends keyof EffectiveTeamplayModels ? EffectiveTeamplayModels[TPattern] : SignalClass<any>): void;
 export declare function findModel(segments: PathSegment[]): SignalClass<any> | undefined;
+export {};

package/dist/orm/getSignal.js

@@ -94,8 +94,6 @@ function getDefaultProxyHandlers({ useExtremelyLateBindings } = {}) {
                     return undefined;
                 }
             }
-            if (key === 'root')
-                return Reflect.get(signal, key, receiver);
             return baseHandlers.get
                 ? baseHandlers.get(signal, key, receiver)
                 : Reflect.get(signal, key, receiver);

package/dist/orm/index.d.ts

@@ -1,6 +1,6 @@
 export { belongsTo, hasMany, hasOne } from './associations.js';
-export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QuerySignal, RegisteredAggregationInput, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
-export type { RootSignal, TeamplayCollections, TeamplayModels, TeamplaySignalFields } from '../index.js';
+export type { AggregationSignal, ArraySignal, CollectionAggregationSignal, CollectionQuerySignal, CollectionSignal, CollectionSignalFromSpec, CollectionSpec, CollectionsFromManifest, ComputedQueryParamsInput, DocumentSignal, FromJsonSchema, JsonSchema, JsonSchemaSpec, ModelEntry, ModelManifest, PathModelsFromManifest, PrivateCollectionsFromManifest, PrivateSignalFromSpec, PublicSignal, RuntimeSignalConstructor, RuntimeSignalInstance, WildcardPathSegment, WildcardSignalPath, AppendPath, JoinPath, QueryParams, QueryParamsInput, QuerySignal, RegisteredAggregationInput, RootPrivateCollections, SignalBaseInstance, SignalClass, SignalChild, SignalConstructor, SignalForKind, SignalKind, SignalModelConstructor, TypedAggregationInput, TypedAggregationSignal, TypedSignal, ZodLikeSchema, ZodSchemaSpec } from './Signal.js';
+export type { RootSignal, TeamplayCollections, TeamplayFeature, TeamplayFeatures, TeamplayModels, TeamplayPluginCollections, TeamplayPluginPrivateCollections, TeamplayPluginModels, TeamplayPluginOption, TeamplayPluginOptions, TeamplayPluginSignalFields, TeamplayPrivateCollections, TeamplaySignalFields } from '../index.js';
 export declare const BaseModel: import("./Signal.js").SignalConstructor;
 export default BaseModel;
 export { defineModels, default as initModels, getModels, resetModelsForTests } from './initModels.js';

package/dist/orm/privateData.d.ts

@@ -1,22 +1,7 @@
-export function getPrivateDataRoot(rootId: any, create?: boolean): {
-    [x: string]: unknown;
-    [x: number]: unknown;
-};
-export function getPrivateDataRawRoot(rootId: any, create?: boolean): {
-    [x: string]: unknown;
-    [x: number]: unknown;
-};
-export function getPrivateData(rootId: any, logicalSegments: any, raw?: boolean): unknown;
-export function setPrivateData(rootId: any, logicalSegments: any, value: any): void;
-export function setReplacePrivateData(rootId: any, logicalSegments: any, value: any): void;
-export function delPrivateData(rootId: any, logicalSegments: any, options?: {}): void;
-export function arrayPushPrivateData(rootId: any, logicalSegments: any, value: any): number | undefined;
-export function arrayUnshiftPrivateData(rootId: any, logicalSegments: any, value: any): number | undefined;
-export function arrayInsertPrivateData(rootId: any, logicalSegments: any, index: any, values: any): number | undefined;
-export function arrayPopPrivateData(rootId: any, logicalSegments: any): any;
-export function arrayShiftPrivateData(rootId: any, logicalSegments: any): any;
-export function arrayRemovePrivateData(rootId: any, logicalSegments: any, index: any, howMany?: number): any[] | undefined;
-export function arrayMovePrivateData(rootId: any, logicalSegments: any, from: any, to: any, howMany?: number): any[] | undefined;
-export function stringInsertPrivateData(rootId: any, logicalSegments: any, index: any, text: any): any;
-export function stringRemovePrivateData(rootId: any, logicalSegments: any, index: any, howMany: any): any;
-export function getPrivateDataSnapshot(rootId: any): any;
+import type { PathSegment } from './types/path.js'
+
+export function getPrivateData (
+  rootId: string | undefined,
+  logicalSegments: readonly PathSegment[],
+  raw?: boolean
+): unknown

package/dist/orm/signalMetadata.d.ts

@@ -12,6 +12,6 @@ export declare function getSignalPath($signal: Pick<SignalMetadataOwner, typeof
 export declare function getSignalLeaf($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>): string;
 export declare function getSignalParentSegments($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, levels: unknown, argumentCount: number): PathSegment[];
 export declare function normalizeParentLevels(levels: unknown, argumentCount: number): number;
-export declare function getSignalId($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, rootId?: string): string | number | undefined;
+export declare function getSignalId($signal: Pick<SignalMetadataOwner, typeof SEGMENTS>, rootId?: string, readPath?: (segments: PathSegment[]) => unknown): string | undefined;
 export declare function getSignalCollection($signal: SignalMetadataOwner): PathSegment | undefined;
 export declare function getSignalAssociations($rawSignal: Pick<SignalMetadataOwner, 'constructor'>): readonly unknown[];

package/dist/orm/signalMetadata.js

@@ -1,4 +1,5 @@
 import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
+import { isPrivateCollectionSegments } from "./rootScope.js";
 import { SEGMENTS } from "./signalSymbols.js";
 export function getSignalPath($signal) {
     return $signal[SEGMENTS].join('.');
@@ -27,16 +28,23 @@ export function normalizeParentLevels(levels, argumentCount) {
         throw Error('Signal.parent() expects a positive integer');
     return levels;
 }
-export function getSignalId($signal, rootId) {
+export function getSignalId($signal, rootId, readPath) {
     const segments = $signal[SEGMENTS];
     if (segments.length === 0)
         throw Error('Can\'t get the id of the root signal');
     if (segments.length === 1)
         throw Error('Can\'t get the id of a collection');
+    if (isDirectPublicDocumentSegments(segments))
+        return getLeafId(segments);
     if (segments[0] === AGGREGATIONS && segments.length === 3) {
-        return getAggregationDocId(segments, rootId);
+        return getAggregationDocId(segments, rootId, readPath);
     }
-    return segments[segments.length - 1];
+    if (readPath) {
+        const valueId = getValueIdFromPaths(segments, readPath);
+        if (valueId.found)
+            return valueId.id;
+    }
+    return getLeafId(segments);
 }
 export function getSignalCollection($signal) {
     const segments = $signal[SEGMENTS];
@@ -54,3 +62,21 @@ export function getSignalCollection($signal) {
 export function getSignalAssociations($rawSignal) {
     return $rawSignal.constructor.associations || [];
 }
+function getValueIdFromPaths(segments, readPath) {
+    const underscoreId = readPath([...segments, '_id']);
+    if (typeof underscoreId === 'string')
+        return { found: true, id: underscoreId };
+    const id = readPath([...segments, 'id']);
+    if (typeof id === 'string')
+        return { found: true, id };
+    if (underscoreId !== undefined || id !== undefined)
+        return { found: true };
+    return { found: false };
+}
+function isDirectPublicDocumentSegments(segments) {
+    return segments.length === 2 && !isPrivateCollectionSegments(segments);
+}
+function getLeafId(segments) {
+    const leaf = segments[segments.length - 1];
+    return typeof leaf === 'string' ? leaf : undefined;
+}

package/dist/orm/signalReads.d.ts

@@ -21,6 +21,6 @@ export interface SignalReadContext<TSignal extends SignalReadOwner> {
 }
 export declare function readSignalValue<TSignal extends SignalReadOwner, TValue>($signal: TSignal, context: SignalReadContext<TSignal>, method: SignalReadMethod<TValue>, rawMethod: SignalReadMethod): TValue;
 export declare function getSignalValue<TSignal extends SignalReadOwner, TValue>($signal: TSignal, context: SignalReadContext<TSignal>, method: SignalReadMethod<TValue>, rawMethod: SignalReadMethod): TValue;
-export declare function getSignalIds<TSignal extends SignalReadOwner>($signal: TSignal, context: SignalReadContext<TSignal>): Array<string | number>;
+export declare function getSignalIds<TSignal extends SignalReadOwner>($signal: TSignal, context: SignalReadContext<TSignal>): string[];
 export declare function isQueryIdsValueSignal<TSignal extends SignalReadOwner>($signal: TSignal): boolean;
 export declare function isAggregationValueSignal<TSignal extends SignalReadOwner>($signal: TSignal): boolean;

package/dist/orm/signalReads.js

@@ -1,4 +1,4 @@
-import { AGGREGATIONS, IS_AGGREGATION } from './Aggregation.js';
+import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationRowId } from './Aggregation.js';
 import { HASH, IS_QUERY, QUERIES } from './Query.js';
 import { SEGMENTS } from "./signalSymbols.js";
 export function readSignalValue($signal, context, method, rawMethod) {
@@ -23,7 +23,7 @@ export function getSignalValue($signal, context, method, rawMethod) {
             context.warn('Signal.get() on Query didn\'t find ids', $signal[SEGMENTS]);
             return [];
         }
-        return ids;
+        return ids.filter(isString);
     }
     return readSignalValue($signal, context, method, rawMethod);
 }
@@ -35,13 +35,14 @@ export function getSignalIds($signal, context) {
             context.warn('Signal.getIds() on Query didn\'t find ids', [QUERIES, getQueryHashSegment($signal), 'ids']);
             return [];
         }
-        return ids;
+        return ids.filter(isString);
     }
     if ($signal[IS_AGGREGATION]) {
         const docs = context.readPrivateData(rootId, $signal[SEGMENTS], false);
         if (!Array.isArray(docs))
             return [];
-        return docs.map(getAggregationRowId);
+        const collectionName = getAggregationCollectionName($signal[SEGMENTS]);
+        return docs.map(doc => getAggregationRowId(doc, collectionName)).filter(isString);
     }
     context.error('Signal.getIds() can only be used on query signals or aggregation signals. ' +
         'Received a regular signal: ' + JSON.stringify($signal[SEGMENTS]));
@@ -55,9 +56,8 @@ export function isAggregationValueSignal($signal) {
     const segments = $signal[SEGMENTS];
     return segments.length >= 2 && segments[0] === AGGREGATIONS;
 }
-function getAggregationRowId(doc) {
-    const row = doc;
-    return row._id || row.id;
+function isString(value) {
+    return typeof value === 'string';
 }
 function getQueryHashSegment($signal) {
     return $signal[HASH];

package/dist/orm/signalSymbols.js

@@ -2,4 +2,4 @@ export const SEGMENTS = Symbol('path segments targeting the particular node in t
 export const ARRAY_METHOD = Symbol('run array method on the signal');
 export const GET = Symbol('get the value of the signal - either observed or raw');
 export const GETTERS = Symbol('get the list of this signal\'s getters');
-export const DEFAULT_GETTERS = ['path', 'id', 'get', 'peek', 'getId', 'map', 'reduce', 'find', 'getIds', 'getExtra', 'getCollection'];
+export const DEFAULT_GETTERS = ['path', 'root', 'id', 'get', 'peek', 'getId', 'map', 'reduce', 'find', 'getIds', 'getExtra', 'getCopy', 'getDeepCopy', 'getCollection'];

package/dist/orm/sub.d.ts

@@ -1,5 +1,5 @@
 import type { AggregationFunction, AggregationParams, ClientAggregationFunction } from '@teamplay/utils/aggregation';
-import type { CollectionSignal, DocumentSignal, MaybePromise, MaybePromiseSubResult, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from './Signal.js';
+import type { CollectionSignal, ComputedQueryParamsInput, DocumentSignal, MaybePromise, MaybePromiseSubResult, QueryParams, RegisteredAggregationInput, SignalModelConstructor, SubResult, TypedAggregationInput, TypedAggregationSignal, WildcardSignalPath } from './Signal.js';
 /**
  * Subscribe to an aggregation with explicit output typing outside React.
  * @param $aggregation Typed aggregation input.
@@ -35,3 +35,11 @@ export default function sub<TSignal extends DocumentSignal<any, any, any>>($sign
  * @param params Mongo-style query params, including filters and `$sort`.
  */
 export default function sub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath>($collection: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: QueryParams<TDocument>): MaybePromiseSubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, QueryParams<TDocument>>;
+/**
+ * Subscribe to a collection query with computed string keys outside React.
+ * This fallback preserves Mongo-style computed paths such as `{ [`likes.${id}`]: true }`.
+ * Literal query objects should use the stricter overload above.
+ * @param $collection Collection signal to query.
+ * @param params Mongo-style query params with a widened computed key.
+ */
+export default function sub<TDocument, TCollectionModel extends SignalModelConstructor<TDocument[]>, TDocumentModel extends SignalModelConstructor<TDocument>, TCollectionPath extends WildcardSignalPath, TParams extends object>($collection: CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, params: TParams & ComputedQueryParamsInput<TParams>): MaybePromiseSubResult<CollectionSignal<TDocument, TCollectionModel, TDocumentModel, TCollectionPath>, TParams>;

package/dist/orm/subscriptionGcDelay.js

@@ -1,6 +1,4 @@
-import { isCompatEnv } from './compatEnv.js';
-const DEFAULT_COMPAT_SUBSCRIPTION_GC_DELAY = 3000;
-const DEFAULT_SUBSCRIPTION_GC_DELAY = 0;
+const DEFAULT_SUBSCRIPTION_GC_DELAY = 3000;
 let subscriptionGcDelay = getDefaultSubscriptionGcDelay();
 export function getSubscriptionGcDelay() {
     return subscriptionGcDelay;
@@ -17,9 +15,7 @@ export function setSubscriptionGcDelay(ms) {
     return subscriptionGcDelay;
 }
 export function getDefaultSubscriptionGcDelay() {
-    return isCompatEnv()
-        ? DEFAULT_COMPAT_SUBSCRIPTION_GC_DELAY
-        : DEFAULT_SUBSCRIPTION_GC_DELAY;
+    return DEFAULT_SUBSCRIPTION_GC_DELAY;
 }
 export function __resetSubscriptionGcDelayForTests() {
     subscriptionGcDelay = getDefaultSubscriptionGcDelay();

package/dist/orm/types/baseMethods.d.ts

@@ -6,7 +6,7 @@ export interface SignalMetadataMethods {
     readonly [Symbol.toStringTag]: string;
     parent: (levels?: number) => unknown;
     id: () => string;
-    getId: () => string | number;
+    getId: () => string | undefined;
     getCollection: () => string;
     getAssociations: () => readonly unknown[];
 }
@@ -14,6 +14,7 @@ export interface SignalValueMethods<TValue> {
     get: () => TValue;
     peek: () => TValue;
     set: (value: TValue) => Promise<void>;
+    setReplace: (value: TValue) => Promise<void>;
     assign: (value: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never) => Promise<void>;
     del: () => Promise<void>;
     increment: (value?: number) => Promise<number>;

package/dist/orm/types/jsonSchema.d.ts

@@ -38,7 +38,7 @@ type SimplifiedProperties<TSchema> = {
 type HasSimplifiedProperties<TSchema> = keyof SimplifiedProperties<TSchema> extends never ? false : true;
 type SchemaProperties<TSchema> = TSchema extends {
     readonly properties: infer Properties;
-} ? IsFullObjectSchema<TSchema> extends true ? Properties : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<string, never> : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<string, never>;
+} ? IsFullObjectSchema<TSchema> extends true ? Properties : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<never, never> : IsFullObjectSchema<TSchema> extends true ? Record<never, never> : HasSimplifiedProperties<TSchema> extends true ? SimplifiedProperties<TSchema> : Record<never, never>;
 type ExplicitRequiredKeys<TSchema, TProperties> = TSchema extends {
     readonly required?: infer Required;
 } ? Required extends readonly string[] ? Extract<Required[number], keyof TProperties & string> : never : never;
@@ -50,10 +50,10 @@ type SimplifiedRequiredKeys<TProperties> = {
 type RequiredKeys<TSchema, TProperties> = ExplicitRequiredKeys<TSchema, TProperties> | SimplifiedRequiredKeys<TProperties>;
 type PatternPropertiesFromJsonSchema<TSchema> = TSchema extends {
     readonly patternProperties?: infer PatternProperties;
-} ? PatternProperties extends Record<string, infer PatternSchema> ? Record<string, FromJsonSchema<PatternSchema>> : {} : {};
+} ? PatternProperties extends object ? keyof PatternProperties extends never ? {} : Record<string, FromJsonSchema<PatternProperties[keyof PatternProperties]>> : {} : {};
 type AdditionalPropertiesFromJsonSchema<TSchema> = TSchema extends {
     readonly additionalProperties?: infer AdditionalProperties;
-} ? AdditionalProperties extends JsonSchema ? Record<string, FromJsonSchema<AdditionalProperties>> : {} : {};
+} ? AdditionalProperties extends false ? {} : AdditionalProperties extends JsonSchema ? Record<string, FromJsonSchema<AdditionalProperties>> : {} : {};
 type ObjectFromJsonSchema<TSchema> = SchemaProperties<TSchema> extends infer Properties ? Properties extends Record<string, unknown> ? Prettify<{
     [K in RequiredKeys<TSchema, Properties>]-?: FromJsonSchema<Properties[K]>;
 } & {