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

package/dist/react/useSub.js

@@ -1,11 +1,17 @@
 import { useRef, useDeferredValue } from 'react';
 import sub from "../orm/sub.js";
-import { useScheduleUpdate, useCache, useDefer, useId } from "./helpers.js";
+import { useScheduleUpdate, useCache, useDefer } from "./helpers.js";
 import executionContextTracker from "./executionContextTracker.js";
 import * as promiseBatcher from "./promiseBatcher.js";
-import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { getPrivateData } from '../orm/privateData.js';
+import { isDocReady } from '../orm/Compat/queryReadiness.js';
+import { getRoot, ROOT_ID } from "../orm/Root.js";
+import { COLLECTION_NAME, HASH, IS_QUERY, PARAMS, QUERIES, querySubscriptions, materializeQueryDataDocsToCollection } from '../orm/Query.js';
+import { AGGREGATIONS, IS_AGGREGATION, aggregationSubscriptions } from '../orm/Aggregation.js';
+import { SEGMENTS } from "../orm/signalSymbols.js";
+import { isPublicDocumentSignal } from "../orm/Signal.js";
 const runtimeSub = sub;
+const USE_SUB_OPTION_KEYS = new Set(['async', 'defer', 'batch']);
 let TEST_THROTTLING = false;
 // experimental feature to leverage useDeferredValue() to handle re-subscriptions.
 // Currently it does lead to issues with extra rerenders and requires further investigation
@@ -13,12 +19,39 @@ let USE_DEFERRED_VALUE = true;
 // by default we want to defer stuff if possible instead of throwing promises
 let DEFAULT_DEFER = true;
 export function useAsyncSub(signal, params, options) {
-    return runUseSub(signal, params, { ...options, async: true });
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, { ...normalized.options, async: true });
+}
+export function useBatchSub(signal, params, options) {
+    const callUseSub = useSub;
+    if (arguments.length === 0) {
+        return callUseSub(undefined, undefined, { batch: true });
+    }
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return callUseSub(normalized.signal, normalized.params, { ...normalized.options, async: false, batch: true });
 }
 export default function useSub(signal, params, options) {
-    return runUseSub(signal, params, options);
+    const normalized = normalizeUseSubArgs(signal, params, options);
+    return runUseSub(normalized.signal, normalized.params, normalized.options);
+}
+function normalizeUseSubArgs(signal, params, options) {
+    if (options === undefined && params !== undefined && isPublicDocumentSignal(signal) && isUseSubOptions(params)) {
+        return {
+            signal,
+            params: undefined,
+            options: params
+        };
+    }
+    return { signal, params, options };
+}
+function isUseSubOptions(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return Object.keys(value).every(key => USE_SUB_OPTION_KEYS.has(key));
 }
 function runUseSub(signal, params, options) {
+    if (isBatchBarrierCall(signal, params, options))
+        return closeBatchBarrier();
     if (USE_DEFERRED_VALUE) {
         return useSubDeferred(signal, params, options); // eslint-disable-line react-hooks/rules-of-hooks
     }
@@ -26,14 +59,19 @@ function runUseSub(signal, params, options) {
         return useSubClassic(signal, params, options); // eslint-disable-line react-hooks/rules-of-hooks
     }
 }
+function isBatchBarrierCall(signal, params, options) {
+    return signal === undefined && params === undefined && !!options?.batch;
+}
+function closeBatchBarrier() {
+    const promise = promiseBatcher.getPromiseAll();
+    if (promise)
+        throw promise;
+}
 // version of sub() which works as a react hook and throws promise for Suspense
-export function useSubDeferred(signal, params, { async = false, defer, batch = false, compatAttemptCleanup = false } = {}) {
+export function useSubDeferred(signal, params, { async = false, defer, batch = false } = {}) {
     const $signalRef = useRef();
-    const componentId = useId();
     const scheduleUpdate = useScheduleUpdate();
     const observerDefer = useDefer();
-    if (compatAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     defer ??= observerDefer ?? DEFAULT_DEFER;
@@ -46,20 +84,20 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
     // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
     if (isThenable(promiseOrSignal)) {
         const promise = maybeThrottle(promiseOrSignal);
+        const readyPromise = batch ? getBatchReadyPromise(promise) : promise;
         const hasPreviousSignal = !!$signalRef.current;
         if (batch) {
             // Batch suspense must block only on initial load.
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (compatAttemptCleanup)
-                    registerCompatAttemptCleanup(signal, params);
+                addBatchReadinessCheck(promise);
             }
             else {
-                scheduleUpdate(promise);
+                scheduleUpdate(readyPromise);
             }
             if (async)
-                scheduleUpdate(promise);
+                scheduleUpdate(readyPromise);
             return $signalRef.current;
         }
         if (async) {
@@ -71,13 +109,13 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
             scheduleUpdate(promise);
             return $signalRef.current;
         }
-        if (compatAttemptCleanup)
-            registerCompatAttemptCleanup(signal, params);
         throw promise;
         // 2. if it's a signal, we save it into ref to make sure it's not garbage collected while component exists
     }
     else {
         const $signal = promiseOrSignal;
+        if (batch && !$signalRef.current)
+            addBatchReadinessCheckForSignal($signal);
         if ($signalRef.current !== $signal)
             $signalRef.current = $signal;
         return $signal;
@@ -85,33 +123,30 @@ export function useSubDeferred(signal, params, { async = false, defer, batch = f
 }
 // classic version which initially throws promise for Suspense
 // but if we get a promise second time, we return the last signal and wait for promise to resolve
-export function useSubClassic(signal, params, { async = false, batch = false, compatAttemptCleanup = false } = {}) {
+export function useSubClassic(signal, params, { async = false, batch = false } = {}) {
     const id = executionContextTracker.newHookId();
-    const componentId = useId();
     const cache = useCache(undefined);
     const scheduleUpdate = useScheduleUpdate();
-    if (compatAttemptCleanup)
-        markCompatComponent(componentId);
     if (batch)
         promiseBatcher.activate();
     const promiseOrSignal = params != null ? runtimeSub(signal, params) : runtimeSub(signal);
     // 1. if it's a promise, throw it so that Suspense can catch it and wait for subscription to finish
     if (isThenable(promiseOrSignal)) {
         const promise = maybeThrottle(promiseOrSignal);
+        const readyPromise = batch ? getBatchReadyPromise(promise) : promise;
         if (batch) {
             const hasPreviousSignal = cache.has(id);
             // Batch suspense must block only on initial load.
             // On resubscribe we keep rendering previous signal and refresh in background.
             if (!hasPreviousSignal) {
                 promiseBatcher.add(promise);
-                if (compatAttemptCleanup)
-                    registerCompatAttemptCleanup(signal, params);
+                addBatchReadinessCheck(promise);
             }
             else {
-                scheduleUpdate(promise);
+                scheduleUpdate(readyPromise);
             }
             if (async)
-                scheduleUpdate(promise);
+                scheduleUpdate(readyPromise);
             if (hasPreviousSignal)
                 return cache.get(id);
             return;
@@ -126,8 +161,6 @@ export function useSubClassic(signal, params, { async = false, batch = false, co
                 scheduleUpdate(promise);
                 return;
             }
-            if (compatAttemptCleanup)
-                registerCompatAttemptCleanup(signal, params);
             // in regular mode we throw the promise to be caught by Suspense
             // this way we guarantee that the signal with all the data
             // will always be there when component is rendered
@@ -140,6 +173,8 @@ export function useSubClassic(signal, params, { async = false, batch = false, co
     }
     else {
         const $signal = promiseOrSignal;
+        if (batch && !cache.has(id))
+            addBatchReadinessCheckForSignal($signal);
         if (cache.get(id) !== $signal) {
             cache.set(id, $signal);
         }
@@ -175,15 +210,139 @@ function maybeThrottle(promise) {
         }, delay);
     });
 }
+function addBatchReadinessCheck(promise) {
+    let resolvedSignal;
+    let resolved = false;
+    promise.then(signal => {
+        resolvedSignal = signal;
+        resolved = true;
+    }, () => {
+        resolved = true;
+    });
+    promiseBatcher.addCheck({
+        key: promise,
+        type: 'subscription',
+        isReady: () => resolved && isBatchSignalReady(resolvedSignal),
+        getState: () => getBatchSignalState(resolvedSignal)
+    });
+}
+function getBatchReadyPromise(promise) {
+    return Promise.resolve(promise).then(async (signal) => {
+        await waitForBatchSignalReady(signal);
+        return signal;
+    });
+}
+async function waitForBatchSignalReady(signal) {
+    while (!isBatchSignalReady(signal)) {
+        await new Promise(resolve => setTimeout(resolve, 16));
+    }
+}
+function addBatchReadinessCheckForSignal(signal) {
+    if (isBatchSignalReady(signal))
+        return;
+    const promise = Promise.resolve(signal);
+    promiseBatcher.add(promise);
+    addBatchReadinessCheck(promise);
+}
+function isBatchSignalReady(signal) {
+    if (isPublicDocumentSignal(signal)) {
+        const $doc = signal;
+        return isDocReady($doc[SEGMENTS]);
+    }
+    if (isQuerySignal(signal))
+        return isBatchQueryReady(signal);
+    return true;
+}
+function isBatchQueryReady(signal) {
+    const collection = signal[COLLECTION_NAME];
+    const params = signal[PARAMS];
+    if (!isBatchQueryTransportStable(signal))
+        return false;
+    const hasExtraResult = isExtraQuery(params);
+    if (hasExtraResult)
+        return readQueryExtra(signal) !== undefined;
+    const isAggregate = !!signal[IS_AGGREGATION] || isAggregationQuery(params);
+    const docs = signal.get();
+    if (isAggregate) {
+        if (Array.isArray(docs))
+            return true;
+        return readQueryExtra(signal) !== undefined;
+    }
+    if (!Array.isArray(docs))
+        return false;
+    materializeQueryDataDocsToCollection(collection, docs);
+    const ids = signal.getIds();
+    for (const id of ids) {
+        if (id == null)
+            continue;
+        if (!isDocReady([collection, id]))
+            return false;
+    }
+    return true;
+}
+function isBatchQueryTransportStable(signal) {
+    const subscriptions = signal[IS_AGGREGATION] ? aggregationSubscriptions : querySubscriptions;
+    const entry = subscriptions.entries.get(signal[HASH]);
+    if (!entry)
+        return false;
+    return entry.phase === 'stable' && entry.mode === entry.targetMode;
+}
+function getBatchSignalState(signal) {
+    if (isPublicDocumentSignal(signal)) {
+        const $doc = signal;
+        return {
+            kind: 'doc',
+            path: $doc[SEGMENTS],
+            ready: isDocReady($doc[SEGMENTS])
+        };
+    }
+    if (!isQuerySignal(signal))
+        return { kind: 'unknown', resolved: !!signal };
+    const rootId = getRoot(signal)?.[ROOT_ID];
+    const hash = signal[HASH];
+    const collection = signal[COLLECTION_NAME];
+    return {
+        kind: signal[IS_AGGREGATION] ? 'aggregation' : 'query',
+        collection,
+        hash,
+        ids: getPrivateData(rootId, [QUERIES, hash, 'ids'], true),
+        hasDocs: Array.isArray(getPrivateData(rootId, [QUERIES, hash, 'docs'], true)),
+        hasExtra: getPrivateData(rootId, [QUERIES, hash, 'extra'], true) !== undefined,
+        hasAggregation: getPrivateData(rootId, [AGGREGATIONS, hash], true) !== undefined
+    };
+}
+function readQueryExtra(signal) {
+    try {
+        return signal.extra.get();
+    }
+    catch (err) {
+        if (isThenable(err))
+            return undefined;
+        throw err;
+    }
+}
+function isQuerySignal(signal) {
+    return !!signal &&
+        (typeof signal === 'object' || typeof signal === 'function') &&
+        !!signal[IS_QUERY] &&
+        typeof signal[COLLECTION_NAME] === 'string' &&
+        typeof signal[HASH] === 'string';
+}
+function isExtraQuery(query) {
+    if (!query || typeof query !== 'object')
+        return false;
+    return !!(query.$count ||
+        query.$queryName ||
+        query.$aggregationName);
+}
+function isAggregationQuery(query) {
+    if (!query || typeof query !== 'object')
+        return false;
+    return !!(query.$aggregate ||
+        query.$aggregationName);
+}
 function isThenable(value) {
     return !!value &&
         (typeof value === 'object' || typeof value === 'function') &&
         typeof value.then === 'function';
 }
-function registerCompatAttemptCleanup(_signal, _params) {
-    // Compat hooks don't build per-hook init objects like Racer.
-    // We still need a marker so trapRender can defer observer-shell cleanup
-    // only when a real attempt cleanup exists.
-    // This path must not arm suspense-gate keep-alive by itself.
-    renderAttemptDestroyer.armCompatAttemptCleanup();
-}

package/dist/react/useSuspendMemo.js

@@ -1,13 +1,11 @@
 import executionContextTracker from "./executionContextTracker.js";
-import { useCache, useId } from "./helpers.js";
-import { markCompatComponent } from "./compatComponentRegistry.js";
+import { useCache } from "./helpers.js";
 import renderAttemptDestroyer from "./renderAttemptDestroyer.js";
 const IN_FLIGHT_BY_KEY = new Map();
 export default function useSuspendMemo(factory, deps) {
     if (typeof factory !== 'function')
         throw Error('useSuspendMemo() expects a factory function');
     deps = normalizeDeps(deps);
-    const componentId = useId();
     const cache = useCache(undefined);
     const hookId = executionContextTracker.newHookId();
     const cacheKey = `suspendMemo:${hookId}`;
@@ -24,7 +22,6 @@ export default function useSuspendMemo(factory, deps) {
     if (entry.status === 'done')
         return entry.value;
     if (entry.status === 'pending') {
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw entry.promise;
     }
@@ -45,7 +42,6 @@ export default function useSuspendMemo(factory, deps) {
         });
         entry.status = 'pending';
         entry.promise = promise;
-        markCompatComponent(componentId);
         renderAttemptDestroyer.armSuspenseGate();
         throw promise;
     }

package/dist/server.d.ts

@@ -8,4 +8,4 @@ export function initConnection(backend: any, { fetchOnly, publicOnly, ...options
     wss: any;
 };
 export default createBackend;
-export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite } from "@teamplay/backend";
+export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite, getRedis } from "@teamplay/backend";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.2",
+  "version": "0.5.0-alpha.21",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -69,20 +69,20 @@
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
     "@startupjs/sharedb-mingo-memory": "^4.0.0-2",
-    "@teamplay/backend": "^0.5.0-alpha.1",
-    "@teamplay/cache": "^0.5.0-alpha.0",
-    "@teamplay/channel": "^0.5.0-alpha.0",
-    "@teamplay/debug": "^0.5.0-alpha.0",
-    "@teamplay/schema": "^0.5.0-alpha.1",
-    "@teamplay/utils": "^0.5.0-alpha.0",
-    "babel-plugin-teamplay": "^0.5.0-alpha.1",
+    "@teamplay/backend": "^0.5.0-alpha.13",
+    "@teamplay/cache": "^0.5.0-alpha.7",
+    "@teamplay/channel": "^0.5.0-alpha.10",
+    "@teamplay/debug": "^0.5.0-alpha.7",
+    "@teamplay/schema": "^0.5.0-alpha.13",
+    "@teamplay/utils": "^0.5.0-alpha.7",
+    "babel-plugin-teamplay": "^0.5.0-alpha.13",
     "diff-match-patch": "^1.0.5",
     "events": "^3.3.0",
     "json0-ot-diff": "^1.1.2",
     "localforage": "^1.10.0",
     "lodash": "^4.17.20",
     "pluralize": "^8.0.0",
-    "sharedb": "^5.0.0",
+    "sharedb": "5.2.2",
     "stream": "npm:readable-stream@^4.7.0"
   },
   "devDependencies": {
@@ -116,6 +116,12 @@
     "transform": {
       "^.+\\.ts$": "./test/ts-transform.cjs"
     },
+    "testEnvironmentOptions": {
+      "customExportConditions": [
+        "teamplay-ts",
+        "browser"
+      ]
+    },
     "extensionsToTreatAsEsm": [
       ".ts"
     ],
@@ -128,5 +134,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "6d03dc309c39801dac31320a089dc30327613123"
+  "gitHead": "9a68b281123d93db5af433fc3e76c6e086b09ac5"
 }

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

@@ -1,33 +0,0 @@
-export const useValue: any
-export const useValue$: any
-export const useModel: any
-export const useLocal: any
-export const useLocal$: any
-export const useLocalDoc: any
-export const useLocalDoc$: any
-export const useSession: any
-export const useSession$: any
-export const usePage: any
-export const usePage$: any
-export const useBatch: any
-export const useDoc: any
-export const useDoc$: any
-export const useBatchDoc: any
-export const useBatchDoc$: any
-export const useAsyncDoc: any
-export const useAsyncDoc$: any
-export const useQuery: any
-export const useQuery$: any
-export const useAsyncQuery: any
-export const useAsyncQuery$: any
-export const useBatchQuery: any
-export const useBatchQuery$: any
-export const useQueryIds: any
-export const useBatchQueryIds: any
-export const useAsyncQueryIds: any
-export const useQueryDoc: any
-export const useQueryDoc$: any
-export const useBatchQueryDoc: any
-export const useBatchQueryDoc$: any
-export const useAsyncQueryDoc: any
-export const useAsyncQueryDoc$: any