teamplay 0.4.0 → 0.5.0-alpha.1

package/dist/orm/Compat/modelEvents.js

@@ -0,0 +1,228 @@
+import { getRefLinks, getRefRootIds } from './refRegistry.js';
+import { isCompatEnv } from '../compatEnv.js';
+import { isSilentContextActive, isModelEventsSilentContextActive, runInModelEventsSilentContext } from './silentContext.js';
+import { normalizeRootId } from "../rootScope.js";
+import { getRootContext, getRootContexts } from "../rootContext.js";
+import { setReplace as setReplaceInDataTree, del as delFromDataTree } from '../dataTree.js';
+import { setReplacePrivateData, delPrivateData } from '../privateData.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) {
+        const visited = new Set();
+        const queue = [initialSegments];
+        while (queue.length) {
+            const segments = queue.shift();
+            const key = segments.join('.');
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            emitForEvent(rootId, 'change', segments, value, prevValue, meta);
+            emitForEvent(rootId, 'all', segments, value, prevValue, meta, eventName);
+            for (const link of getRefLinks(rootId).values()) {
+                if (!isPathPrefix(link.toSegments, segments))
+                    continue;
+                if (link.mirrorOnly && typeof link.onChange === 'function') {
+                    link.onChange();
+                }
+                else if (!link.mirrorOnly) {
+                    mirrorRefAliasFromTargetSegments(rootId, link, segments, value, meta);
+                }
+                const suffix = segments.slice(link.toSegments.length);
+                const nextSegments = link.fromSegments.concat(suffix);
+                const nextKey = nextSegments.join('.');
+                if (!visited.has(nextKey))
+                    queue.push(nextSegments);
+            }
+        }
+    }
+}
+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 mirrorRefAliasFromTargetSegments(rootId, link, targetSegments, value, meta) {
+    const suffix = targetSegments.slice(link.toSegments.length);
+    const fromSegments = link.fromSegments.concat(suffix);
+    const fromRootId = normalizeRootId(link.fromRootId ?? rootId);
+    const shouldDelete = shouldDeleteMirroredPath(value, meta);
+    runInModelEventsSilentContext(() => {
+        if (isPrivateSegments(fromSegments)) {
+            if (shouldDelete) {
+                delPrivateData(fromRootId, fromSegments);
+            }
+            else {
+                setReplacePrivateData(fromRootId, fromSegments, cloneValue(value));
+            }
+            return;
+        }
+        if (shouldDelete) {
+            delFromDataTree(fromSegments);
+            return;
+        }
+        setReplaceInDataTree(fromSegments, cloneValue(value));
+    });
+}
+function isPrivateSegments(segments) {
+    if (!Array.isArray(segments) || !segments.length)
+        return false;
+    return /^[_$]/.test(String(segments[0]));
+}
+function shouldDeleteMirroredPath(value, meta) {
+    if (meta?.op === 'setReplace')
+        return false;
+    if (meta?.op === 'del')
+        return true;
+    return value === undefined;
+}
+function cloneValue(value) {
+    if (Array.isArray(value))
+        return value.map(cloneValue);
+    if (value && typeof value === 'object') {
+        const cloned = {};
+        for (const key of Object.keys(value))
+            cloned[key] = cloneValue(value[key]);
+        return cloned;
+    }
+    return value;
+}
+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)];
+    const rootIds = new Set([
+        ...getModelEventRootIds(),
+        ...getRefRootIds()
+    ]);
+    return rootIds;
+}
+function splitPath(path) {
+    if (Array.isArray(path))
+        return path.map(segment => String(segment));
+    if (!path)
+        return [];
+    return String(path).split('.').filter(Boolean);
+}
+function isPathPrefix(prefixSegments, fullSegments) {
+    if (prefixSegments.length > fullSegments.length)
+        return false;
+    for (let i = 0; i < prefixSegments.length; i++) {
+        if (prefixSegments[i] !== fullSegments[i])
+            return false;
+    }
+    return true;
+}
+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/queryReadiness.d.ts

@@ -0,0 +1,5 @@
+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;

package/dist/orm/Compat/queryReadiness.js

@@ -0,0 +1,185 @@
+import { getRaw } from '../dataTree.js';
+import { getConnection } from "../connection.js";
+import { isMissingShareDoc } from '../missingDoc.js';
+import { QUERIES, HASH, PARAMS, COLLECTION_NAME, querySubscriptions } from '../Query.js';
+import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../Aggregation.js';
+import { getPrivateData, setPrivateData } from '../privateData.js';
+import { getRoot, ROOT_ID } from "../Root.js";
+import { isRootContextClosed } from "../rootContext.js";
+import { getScopedSignalHash, normalizeRootId } from "../rootScope.js";
+let imperativeQueryReadyTimeoutMs = 1000;
+export function isQueryReady(collection, idsSegments, docsSegments, extraSegments, aggregationSegments, isAggregate, hasExtraResult) {
+    if (hasExtraResult) {
+        return getRaw(extraSegments) !== undefined;
+    }
+    if (isAggregate) {
+        const docs = getRaw(docsSegments);
+        if (Array.isArray(docs))
+            return true;
+        if (getRaw(extraSegments) !== undefined)
+            return true;
+        return getRaw(aggregationSegments) !== undefined;
+    }
+    const ids = getRaw(idsSegments);
+    if (!Array.isArray(ids))
+        return false;
+    for (const id of ids) {
+        if (id == null)
+            continue;
+        if (!isDocReady([collection, id]))
+            return false;
+    }
+    return true;
+}
+export function isDocReady(segments) {
+    const rawDoc = getRaw(segments);
+    if (rawDoc !== undefined)
+        return true;
+    const [collection, id] = segments;
+    const shareDoc = getShareDoc(collection, id);
+    // Missing docs should not block the batch barrier forever.
+    return isMissingShareDoc(shareDoc);
+}
+export async function waitForImperativeQueryReady($query) {
+    const timeoutMs = imperativeQueryReadyTimeoutMs;
+    const startedAt = Date.now();
+    const ownerState = createImperativeOwnerState($query);
+    while (true) {
+        if (isImperativeQueryCancelled($query, ownerState))
+            return;
+        if (isImperativeQueryReady($query)) {
+            syncQueryDocsFromCollection($query);
+            return;
+        }
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw createImperativeQueryReadinessError($query, timeoutMs);
+        }
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+}
+export function __setImperativeQueryReadyTimeoutForTests(timeoutMs) {
+    imperativeQueryReadyTimeoutMs = timeoutMs;
+}
+export function __resetImperativeQueryReadyTimeoutForTests() {
+    imperativeQueryReadyTimeoutMs = 1000;
+}
+function isImperativeQueryReady($query) {
+    const collection = $query[COLLECTION_NAME];
+    const hash = $query[HASH];
+    const rootId = getRoot($query)?.[ROOT_ID];
+    const params = $query[PARAMS];
+    const hasExtraResult = isExtraQuery(params);
+    if (hasExtraResult)
+        return getPrivateData(rootId, [QUERIES, hash, 'extra'], true) !== undefined;
+    const isAggregate = !!$query[IS_AGGREGATION] || isAggregationQuery(params);
+    if (isAggregate) {
+        const docs = getPrivateData(rootId, [QUERIES, hash, 'docs'], true);
+        if (Array.isArray(docs))
+            return true;
+        if (getPrivateData(rootId, [QUERIES, hash, 'extra'], true) !== undefined)
+            return true;
+        return getPrivateData(rootId, [AGGREGATIONS, hash], true) !== undefined;
+    }
+    const ids = getPrivateData(rootId, [QUERIES, hash, 'ids'], true);
+    if (!Array.isArray(ids))
+        return false;
+    for (const id of ids) {
+        if (id == null)
+            continue;
+        if (getRaw([collection, id]) === undefined)
+            return false;
+    }
+    return true;
+}
+function isImperativeQueryCancelled($query, ownerState) {
+    const rootId = getRoot($query)?.[ROOT_ID];
+    if (isRootContextClosed(rootId))
+        return true;
+    if (!ownerState?.wasTracked)
+        return false;
+    const trackedOwnerCount = ownerState.subscriptions.getTrackedOwnerCount(ownerState.ownerKey);
+    return trackedOwnerCount == null || trackedOwnerCount <= 0;
+}
+function createImperativeOwnerState($query) {
+    const hash = $query[HASH];
+    const rootId = normalizeRootId(getRoot($query)?.[ROOT_ID]);
+    const subscriptions = ($query[IS_AGGREGATION] || isAggregationQuery($query[PARAMS]))
+        ? aggregationSubscriptions
+        : querySubscriptions;
+    const ownerKey = getScopedSignalHash(rootId, hash, 'queryOwner');
+    return {
+        subscriptions,
+        ownerKey,
+        wasTracked: subscriptions.getTrackedOwnerCount(ownerKey) != null
+    };
+}
+function syncQueryDocsFromCollection($query) {
+    const params = $query[PARAMS];
+    if ($query[IS_AGGREGATION] || isAggregationQuery(params) || isExtraQuery(params))
+        return;
+    const collection = $query[COLLECTION_NAME];
+    const hash = $query[HASH];
+    const rootId = getRoot($query)?.[ROOT_ID];
+    const ids = getPrivateData(rootId, [QUERIES, hash, 'ids'], true);
+    if (!Array.isArray(ids))
+        return;
+    const docs = [];
+    for (const id of ids) {
+        if (id == null)
+            continue;
+        const doc = getRaw([collection, id]);
+        if (doc === undefined) {
+            throw createImperativeQueryReadinessError($query, imperativeQueryReadyTimeoutMs);
+        }
+        docs.push(doc);
+    }
+    setPrivateData(rootId, [QUERIES, hash, 'docs'], docs);
+}
+function createImperativeQueryReadinessError($query, timeoutMs) {
+    const collection = $query[COLLECTION_NAME];
+    const hash = $query[HASH];
+    const rootId = getRoot($query)?.[ROOT_ID];
+    const params = $query[PARAMS];
+    const ids = getPrivateData(rootId, [QUERIES, hash, 'ids'], true);
+    const missingDocs = [];
+    if (Array.isArray(ids)) {
+        for (const id of ids) {
+            if (id == null)
+                continue;
+            const doc = getRaw([collection, id]);
+            if (doc !== undefined)
+                continue;
+            const shareDoc = getShareDoc(collection, id);
+            missingDocs.push({
+                id,
+                missingShareDoc: isMissingShareDoc(shareDoc)
+            });
+        }
+    }
+    return Error(`
+    Compat query did not fully materialize within ${timeoutMs}ms.
+      Collection: ${collection}
+      Params: ${JSON.stringify(params)}
+      Hash: ${hash}
+      Ids: ${JSON.stringify(ids)}
+      Missing docs: ${JSON.stringify(missingDocs)}
+  `);
+}
+function getShareDoc(collection, id) {
+    try {
+        return getConnection().get(collection, id);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isExtraQuery(query) {
+    if (!query || typeof query !== 'object')
+        return false;
+    return !!(query.$count || query.$queryName);
+}
+function isAggregationQuery(query) {
+    if (!query || typeof query !== 'object')
+        return false;
+    return !!(query.$aggregate || query.$aggregationName);
+}

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

@@ -0,0 +1,13 @@
+import type { PathSegment } from '../types/path.js'
+import type { SignalBaseInstance } from '../Signal.js'
+
+export const REF_TARGET: unique symbol
+export function resolveRefSignalSafe<TSignal extends SignalBaseInstance> (
+  $signal: TSignal | undefined,
+  maxDepth?: number
+): TSignal | undefined
+export function resolveRefSegmentsSafe (
+  segments: readonly PathSegment[],
+  rootId?: string,
+  maxDepth?: number
+): PathSegment[] | undefined

package/dist/orm/Compat/refFallback.js

@@ -0,0 +1,65 @@
+import { getRefLinks } from './refRegistry.js';
+import { GLOBAL_ROOT_ID } from "../Root.js";
+export const REF_TARGET = Symbol.for('teamplay.compat.refTarget');
+export function resolveRefSignalSafe($signal, maxDepth = 32) {
+    let current = $signal;
+    const seen = new Set();
+    for (let i = 0; i < maxDepth; i++) {
+        if (!current)
+            return undefined;
+        const next = current[REF_TARGET];
+        if (!next)
+            return current;
+        if (seen.has(current))
+            return undefined;
+        seen.add(current);
+        current = next;
+    }
+    return undefined;
+}
+export function resolveRefSegmentsSafe(segments, rootId = GLOBAL_ROOT_ID, maxDepth = 32) {
+    if (!Array.isArray(segments) || segments.length === 0)
+        return undefined;
+    let current = [...segments];
+    const visited = new Set([toPathKey(current)]);
+    let changed = false;
+    for (let i = 0; i < maxDepth; i++) {
+        const link = findBestMatchingLink(current, rootId);
+        if (!link)
+            return changed ? current : undefined;
+        const suffix = current.slice(link.fromSegments.length);
+        const next = link.toSegments.concat(suffix);
+        const key = toPathKey(next);
+        if (visited.has(key))
+            return undefined;
+        visited.add(key);
+        current = next;
+        changed = true;
+    }
+    return undefined;
+}
+function findBestMatchingLink(segments, rootId) {
+    let best;
+    for (const link of getRefLinks(rootId).values()) {
+        if (link.mirrorOnly)
+            continue;
+        if (!isPathPrefix(link.fromSegments, segments))
+            continue;
+        if (!best || link.fromSegments.length > best.fromSegments.length) {
+            best = link;
+        }
+    }
+    return best;
+}
+function isPathPrefix(prefixSegments, fullSegments) {
+    if (prefixSegments.length > fullSegments.length)
+        return false;
+    for (let i = 0; i < prefixSegments.length; i++) {
+        if (prefixSegments[i] !== String(fullSegments[i]))
+            return false;
+    }
+    return true;
+}
+function toPathKey(segments) {
+    return segments.map(segment => String(segment)).join('.');
+}

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

@@ -0,0 +1,6 @@
+export function setRefLink(rootId: any, fromPath: any, toPath: any, fromSegments: any, toSegments: any, options?: {}): void;
+export function removeRefLink(rootId: any, fromPath: any): void;
+export function getRefLinks(rootId?: string): Map<string, unknown>;
+export function getAllRefLinks(): Generator<unknown, void, unknown>;
+export function getRefRootIds(): string[];
+export function __resetRefLinksForTests(): void;

package/dist/orm/Compat/refRegistry.js

@@ -0,0 +1,54 @@
+import { GLOBAL_ROOT_ID } from "../Root.js";
+import { normalizeRootId } from "../rootScope.js";
+import { getRootContext, getRootContexts } from "../rootContext.js";
+const EMPTY_MAP = new Map();
+export function setRefLink(rootId, fromPath, toPath, fromSegments, toSegments, options = {}) {
+    if (typeof fromPath !== 'string' || typeof toPath !== 'string')
+        return;
+    const normalizedFromSegments = Array.isArray(fromSegments)
+        ? fromSegments.map(segment => String(segment))
+        : splitPath(fromPath);
+    const normalizedToSegments = Array.isArray(toSegments)
+        ? toSegments.map(segment => String(segment))
+        : splitPath(toPath);
+    getRefStore(rootId, true).set(fromPath, {
+        fromPath,
+        toPath,
+        fromSegments: normalizedFromSegments,
+        toSegments: normalizedToSegments,
+        fromRootId: normalizeRootId(rootId),
+        toRootId: options.toRootId,
+        mirrorOnly: !!options.mirrorOnly,
+        onChange: typeof options.onChange === 'function' ? options.onChange : undefined
+    });
+}
+export function removeRefLink(rootId, fromPath) {
+    const store = getRefStore(rootId);
+    if (!store)
+        return;
+    store.delete(fromPath);
+}
+export function getRefLinks(rootId = GLOBAL_ROOT_ID) {
+    return getRefStore(rootId) || EMPTY_MAP;
+}
+export function* getAllRefLinks() {
+    for (const context of getRootContexts()) {
+        yield* context.refLinks.values();
+    }
+}
+export function getRefRootIds() {
+    return Array.from(getRootContexts())
+        .filter(context => context.refLinks.size > 0)
+        .map(context => context.rootId);
+}
+export function __resetRefLinksForTests() {
+    for (const context of getRootContexts()) {
+        context.resetRefs();
+    }
+}
+function splitPath(path) {
+    return path.split('.').filter(Boolean);
+}
+function getRefStore(rootId, create = false) {
+    return getRootContext(normalizeRootId(rootId), create)?.refLinks;
+}

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

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

package/dist/orm/Compat/silentContext.js

@@ -0,0 +1,48 @@
+let silentDepth = 0;
+let modelEventsSilentDepth = 0;
+export function isSilentContextActive() {
+    return silentDepth > 0;
+}
+export function isModelEventsSilentContextActive() {
+    return modelEventsSilentDepth > 0;
+}
+export function runInSilentContext(fn) {
+    silentDepth += 1;
+    let result;
+    try {
+        result = fn();
+    }
+    catch (error) {
+        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();
+    }
+    catch (error) {
+        modelEventsSilentDepth -= 1;
+        throw error;
+    }
+    if (result?.then) {
+        return Promise.resolve(result).finally(() => {
+            modelEventsSilentDepth -= 1;
+        });
+    }
+    modelEventsSilentDepth -= 1;
+    return result;
+}
+export function __resetSilentContextForTests() {
+    silentDepth = 0;
+    modelEventsSilentDepth = 0;
+}

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

@@ -0,0 +1,3 @@
+export function compatStartOnRoot($root: any, targetPath: any, ...depsAndGetter: any[]): any;
+export function compatStopOnRoot($root: any, targetPath: any): void;
+export function joinScopePath(scopePath: any, relativePath: any): string;