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

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

@@ -1,5 +1,13 @@
-export function isQueryReady(collection: any, idsSegments: any, docsSegments: any, extraSegments: any, aggregationSegments: any, isAggregate: any, hasExtraResult: any): boolean;
-export function isDocReady(segments: any): boolean;
-export function waitForImperativeQueryReady($query: any): Promise<void>;
-export function __setImperativeQueryReadyTimeoutForTests(timeoutMs: any): void;
-export function __resetImperativeQueryReadyTimeoutForTests(): void;
+import type { PathSegment } from '../types/path.js'
+
+export function isDocReady (segments: readonly PathSegment[]): boolean
+
+export function isQueryReady (
+  collection: string,
+  idsSegments: readonly PathSegment[],
+  docsSegments: readonly PathSegment[],
+  extraSegments: readonly PathSegment[],
+  aggregationSegments: readonly PathSegment[],
+  isAggregate: boolean,
+  hasExtraResult: boolean
+): boolean

package/dist/orm/Compat/silentContext.js

@@ -8,39 +8,21 @@ export function isModelEventsSilentContextActive() {
 }
 export function runInSilentContext(fn) {
     silentDepth += 1;
-    let result;
     try {
-        result = fn();
+        return fn();
     }
-    catch (error) {
+    finally {
         silentDepth -= 1;
-        throw error;
     }
-    if (result?.then) {
-        return Promise.resolve(result).finally(() => {
-            silentDepth -= 1;
-        });
-    }
-    silentDepth -= 1;
-    return result;
 }
 export function runInModelEventsSilentContext(fn) {
     modelEventsSilentDepth += 1;
-    let result;
     try {
-        result = fn();
+        return fn();
     }
-    catch (error) {
+    finally {
         modelEventsSilentDepth -= 1;
-        throw error;
-    }
-    if (result?.then) {
-        return Promise.resolve(result).finally(() => {
-            modelEventsSilentDepth -= 1;
-        });
     }
-    modelEventsSilentDepth -= 1;
-    return result;
 }
 export function __resetSilentContextForTests() {
     silentDepth = 0;

package/dist/orm/Compat/startStopCompat.js

@@ -1,4 +1,5 @@
 import { observe, raw, unobserve } from '@nx-js/observer-util';
+import { getActiveDocOpContext } from '../Doc.js';
 import { getRoot } from "../Root.js";
 import { scheduleReaction } from '../batchScheduler.js';
 const START_REACTIONS = Symbol('compat start reactions');
@@ -19,11 +20,15 @@ export function compatStartOnRoot($root, targetPath, ...depsAndGetter) {
     const targetSegments = parsePathSegments(targetPath);
     const $target = resolveSignal($root, targetSegments);
     const targetKey = $target.path();
+    const depPaths = deps
+        .map(dep => getStartDepPath(dep, $root))
+        .filter(Boolean);
     const store = getStartStore($root);
     const existing = store.get(targetKey);
     if (existing)
         existing.stop();
     let lastSourceSnapshot = UNSET;
+    let lastTargetSnapshot = UNSET;
     const reaction = observe(() => {
         const resolvedDeps = [];
         for (const dep of deps) {
@@ -45,8 +50,23 @@ export function compatStartOnRoot($root, targetPath, ...depsAndGetter) {
         if (lastSourceSnapshot !== UNSET && deepEqualStartValue(lastSourceSnapshot, sourceSnapshot)) {
             return;
         }
+        const currentTargetSnapshot = lastTargetSnapshot === UNSET
+            ? UNSET
+            : detachStartValue($target.peek());
+        if (currentTargetSnapshot !== UNSET && deepEqualStartValue(currentTargetSnapshot, sourceSnapshot)) {
+            lastSourceSnapshot = sourceSnapshot;
+            lastTargetSnapshot = sourceSnapshot;
+            return;
+        }
+        if (currentTargetSnapshot !== UNSET &&
+            !deepEqualStartValue(lastTargetSnapshot, currentTargetSnapshot) &&
+            isActiveLocalDocOpForDeps(depPaths)) {
+            lastSourceSnapshot = sourceSnapshot;
+            return;
+        }
         lastSourceSnapshot = sourceSnapshot;
         const detachedValue = detachStartValue(sourceSnapshot);
+        lastTargetSnapshot = detachStartValue(detachedValue);
         // Keep the detached snapshot to avoid aliasing source and target.
         // Old racer start() writes through diffDeep by default. In compat mode we must preserve
         // that behavior, but also avoid reading the target reactively inside start(), otherwise
@@ -104,9 +124,22 @@ function resolveStartDep(dep, $root) {
         throw err;
     }
 }
+function getStartDepPath(dep, $root) {
+    if (isSignalLike(dep))
+        return dep.path();
+    if (typeof dep === 'string')
+        return resolveSignal($root, parsePathSegments(dep)).path();
+}
 function getStartDepValue($signal) {
     return readReactiveSnapshot($signal.get());
 }
+function isActiveLocalDocOpForDeps(depPaths) {
+    const context = getActiveDocOpContext();
+    if (!context?.source)
+        return false;
+    const docPath = `${context.collection}.${context.docId}`;
+    return depPaths.some(depPath => depPath === docPath || depPath.startsWith(docPath + '.'));
+}
 function readReactiveSnapshot(value) {
     if (!value || typeof value !== 'object')
         return value;

package/dist/orm/Doc.js

@@ -12,6 +12,43 @@ import { getRoot, ROOT_ID, GLOBAL_ROOT_ID, getRootTransportMode } from "./Root.j
 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) {
@@ -149,7 +186,15 @@ class Doc {
         doc.on('create', () => this._refData());
         doc.on('del', () => this._refMissingData());
         if (isModelEventsEnabled()) {
-            doc.on('op', op => emitDocOp(this.collection, this.docId, op));
+            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() {
@@ -870,7 +915,7 @@ function createPendingDestroyEntry() {
         reject: rejectPending
     };
 }
-function emitDocOp(collection, docId, op) {
+function emitDocOp(collection, docId, op, source) {
     if (!isModelEventsEnabled())
         return;
     const ops = Array.isArray(op) ? op : [op];
@@ -879,7 +924,7 @@ function emitDocOp(collection, docId, op) {
             continue;
         const baseSegments = [collection, docId];
         let pathSegments = baseSegments.concat(component.p);
-        const meta = {};
+        const meta = { source };
         let value;
         let prevValue;
         if (has(component, 'si') || has(component, 'sd')) {

package/dist/orm/Query.d.ts

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

package/dist/orm/Query.js

@@ -465,7 +465,7 @@ export class QuerySubscriptions {
     }
     subscribe($query, { intent = 'subscribe' } = {}) {
         const collectionName = $query[COLLECTION_NAME];
-        const params = cloneQueryParams($query[PARAMS]);
+        const params = cloneQueryParams(collectionName, $query[PARAMS]);
         const transportHash = $query[HASH];
         const rootId = getOwningRootId($query);
         const ownerKey = getQueryOwnerKey(rootId, transportHash);
@@ -901,8 +901,26 @@ function maybeMaterializeQueryDocsToCollection(collectionName, shareDocs) {
         _set([collectionName, doc.id], raw(doc.data));
     }
 }
+export function materializeQueryDataDocsToCollection(collectionName, docs) {
+    if (!Array.isArray(docs))
+        return;
+    for (const doc of docs) {
+        const rawDoc = raw(doc);
+        if (!isPlainObject(rawDoc))
+            continue;
+        const docId = rawDoc._id ?? rawDoc.id;
+        if (docId == null)
+            continue;
+        const existing = getRaw([collectionName, docId]);
+        if (existing != null)
+            continue;
+        const idFields = getIdFieldsForSegments([collectionName, docId]);
+        injectIdFields(rawDoc, idFields, docId);
+        _set([collectionName, docId], rawDoc);
+    }
+}
 export function hashQuery(collectionName, params) {
-    params = normalizeQueryParamsForHash(params);
+    params = normalizeQueryParamsForHash(collectionName, params);
     // TODO: probably makes sense to use fast-stable-json-stringify for this because of the params
     return JSON.stringify({ query: [collectionName, params] });
 }
@@ -916,7 +934,7 @@ export function parseQueryHash(hash) {
     }
 }
 export function getQuerySignal(collectionName, params, options) {
-    params = cloneQueryParams(params);
+    params = cloneQueryParams(collectionName, params);
     const transportHash = hashQuery(collectionName, params);
     const { root, signalOptions } = parseQuerySignalOptions(options);
     const signalHash = getScopedSignalHash(root?.[ROOT_ID] ?? signalOptions.rootId, transportHash, 'querySignal');
@@ -969,10 +987,9 @@ function getOwningRootId($query) {
 function getQueryOwnerKey(rootId, transportHash) {
     return getScopedSignalHash(rootId, transportHash, 'queryOwner');
 }
-function cloneQueryParams(params) {
-    if (!isCompatEnv())
-        return JSON.parse(JSON.stringify(params));
-    return cloneQueryParamsCompat(params);
+export function cloneQueryParams(collectionName, params) {
+    warnIfCompatQueryParamsHaveUndefinedFields(collectionName, params);
+    return JSON.parse(JSON.stringify(params));
 }
 function parseQuerySignalOptions(options) {
     if (!options || typeof options !== 'object') {
@@ -984,27 +1001,55 @@ function parseQuerySignalOptions(options) {
     const { root, ...signalOptions } = options;
     return { root, signalOptions };
 }
-function normalizeQueryParamsForHash(params) {
+function normalizeQueryParamsForHash(collectionName, params) {
+    warnIfCompatQueryParamsHaveUndefinedFields(collectionName, params);
+    return params;
+}
+const warnedUndefinedQueryParamKeys = new Set();
+function warnIfCompatQueryParamsHaveUndefinedFields(collectionName, params) {
     if (!isCompatEnv())
-        return params;
-    return cloneQueryParamsCompat(params);
+        return;
+    const paths = getUndefinedQueryParamFieldPaths(params);
+    if (paths.length === 0)
+        return;
+    const key = `${collectionName || '<unknown>'}:${paths.join(',')}`;
+    if (warnedUndefinedQueryParamKeys.has(key))
+        return;
+    warnedUndefinedQueryParamKeys.add(key);
+    console.warn('[teamplay] Compat query params contain object fields with undefined values. ' +
+        'TeamPlay now clones query params like non-compat mode, so these fields are dropped ' +
+        'instead of being converted to null. Normalize query params explicitly.', {
+        collectionName,
+        paths
+    }, new Error().stack);
+}
+function getUndefinedQueryParamFieldPaths(value) {
+    const paths = [];
+    collectUndefinedQueryParamFieldPaths(value, '', paths, new WeakSet());
+    return paths;
 }
-// Racer compat: keep query keys with undefined values by normalizing them to null
-// instead of dropping them via JSON serialization.
-function cloneQueryParamsCompat(value) {
-    if (value === undefined)
-        return null;
+function collectUndefinedQueryParamFieldPaths(value, path, paths, seen) {
     if (value == null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map(item => cloneQueryParamsCompat(item));
-    const object = {};
+        return;
+    if (seen.has(value))
+        return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            collectUndefinedQueryParamFieldPaths(value[i], `${path}[${i}]`, paths, seen);
+        }
+        return;
+    }
     for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-            object[key] = cloneQueryParamsCompat(value[key]);
+        if (!Object.prototype.hasOwnProperty.call(value, key))
+            continue;
+        const childPath = path ? `${path}.${key}` : key;
+        if (value[key] === undefined) {
+            paths.push(childPath);
+            continue;
         }
+        collectUndefinedQueryParamFieldPaths(value[key], childPath, paths, seen);
     }
-    return object;
 }
 function createPendingDestroyEntry() {
     let resolvePending;

package/dist/orm/Signal.d.ts

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

package/dist/orm/SignalBase.d.ts

@@ -29,6 +29,8 @@ export declare class Signal<TValue = unknown> extends Function {
     toString(): string;
     /** Customize Object.prototype.toString.call($signal) for debugging. */
     get [Symbol.toStringTag](): string;
+    /** Return the owning root signal. */
+    root(): this | import("./Root.js").RootSignalRuntime;
     /**
      * Return the parent signal `levels` above this signal.
      * @param levels Number of parent levels to walk upward. Defaults to `1`.
@@ -51,11 +53,17 @@ export declare class Signal<TValue = unknown> extends Function {
     /** Read the current value and track it for reactive rendering. */
     get(): TValue;
     /** Return document ids for a query or aggregation signal. */
-    getIds(): Array<string | number>;
+    getIds(): string[];
+    /** Return query extra data, aggregation data, or undefined for ordinary signals. */
+    getExtra(): unknown;
+    /** Return a shallow copy of the current value. */
+    getCopy(): TValue;
+    /** Return a deep copy of the current value. */
+    getDeepCopy(): TValue;
     /** Read the current value without tracking it for reactive rendering. */
     peek(): TValue;
     /** Return the document id represented by this document signal. */
-    getId(): string | number;
+    getId(): string | undefined;
     /** Return the public collection name this signal belongs to. */
     getCollection(): string;
     /** Return association metadata registered on this signal's model class. */
@@ -98,6 +106,23 @@ export declare class Signal<TValue = unknown> extends Function {
      * @param value New value to store at this signal path.
      */
     set(value: TValue): Promise<void>;
+    /**
+     * Replace this signal's value without deep-diffing object/array branches.
+     * @param value New value to store at this signal path.
+     */
+    setReplace(value: TValue): Promise<void>;
+    /** Set the current value only when it is null or undefined. */
+    setNull(value: TValue): Promise<void>;
+    /** Replace the current value unless it is exactly equal to the new value. */
+    setDiff(value: TValue): Promise<void>;
+    /** Recursively diff objects and arrays at the current signal path. */
+    setDiffDeep(value: TValue): Promise<void>;
+    /**
+     * 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.
+     */
+    setEach(object: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never): Promise<void>;
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.