teamplay 0.5.0-alpha.8 → 0.5.0

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/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

@@ -1,11 +1,10 @@
 export function createBackend(options?: {}): any;
-export function initConnection(backend: any, { fetchOnly, publicOnly, ...options }?: {
+export function initConnection(backend: any, { fetchOnly, idFields, ...options }?: {
     fetchOnly?: boolean | undefined;
-    publicOnly?: boolean | undefined;
 }): {
     middleware: (req: any, res: any, next: any) => Promise<any>;
     upgrade: (req: any, socket: any, upgradeHead: any) => Promise<void>;
     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/dist/server.js

@@ -1,7 +1,8 @@
 import createChannel from '@teamplay/channel/server';
 import backendCreateBackend from '@teamplay/backend';
 import { getModels } from "./orm/initModels.js";
-import { connection, setConnection, setDefaultFetchOnly, setPublicOnly } from "./orm/connection.js";
+import { connection, setConnection, setDefaultFetchOnly } from "./orm/connection.js";
+import { configureTeamplay } from "./config.js";
 export { default as ShareDB } from 'sharedb';
 export { mongo, mongoClient, createMongoIndex, redis, redlock, sqlite, getRedis, Redis, getRedisOptions, redisPrefix, generateRedisPrefix } from '@teamplay/backend';
 export function createBackend(options = {}) {
@@ -16,13 +17,14 @@ export function createBackend(options = {}) {
     return backendCreateBackend(nextOptions);
 }
 export default createBackend;
-export function initConnection(backend, { fetchOnly = true, publicOnly = true, ...options } = {}) {
+export function initConnection(backend, { fetchOnly = true, idFields, ...options } = {}) {
     if (!backend)
         throw Error('backend is required');
     if (connection)
         throw Error('Connection already exists');
+    if (idFields !== undefined)
+        configureTeamplay({ idFields });
     setConnection(backend.connect());
     setDefaultFetchOnly(fetchOnly);
-    setPublicOnly(publicOnly);
     return createChannel(backend, options);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.5.0-alpha.8",
+  "version": "0.5.0",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,11 @@
       "teamplay-ts": "./src/connect/index.js",
       "default": "./dist/connect/index.js"
     },
+    "./config": {
+      "teamplay-ts": "./src/config.ts",
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
     "./server": {
       "teamplay-ts": "./src/server.js",
       "types": "./dist/server.d.ts",
@@ -52,16 +57,13 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && rsync -a --include='*/' --include='*.d.ts' --include='*.cjs' --exclude='*' src/ dist/ && node ../../scripts/rewrite-dts-extensions.cjs dist",
     "prepublishOnly": "npm run build",
-    "test": "npm run test-types && npm run test-types:external && npm run test-server && npm run test-client && npm run test-compat",
+    "test": "npm run test-types && npm run test-types:external && npm run test-server && npm run test-client",
     "test-types": "tsc -p tsconfig.type-tests.json",
     "test-types:external": "tsc -p tsconfig.external-consumer.json",
     "test-types:dist": "tsc -p tsconfig.external-consumer.dist.json",
     "test-server": "NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc -C teamplay-ts\" mocha 'test/[!_]*.js'",
     "test-server-only": "NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc -C teamplay-ts\" mocha --grep '@only' 'test/[!_]*.js'",
     "test-client": "NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc --experimental-vm-modules -C teamplay-ts\" jest --runInBand",
-    "test-compat": "npm run test-server-compat && npm run test-client-compat",
-    "test-server-compat": "TEAMPLAY_COMPAT=1 NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc -C teamplay-ts\" mocha 'test/[!_]*.js'",
-    "test-client-compat": "TEAMPLAY_COMPAT=1 NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc --experimental-vm-modules -C teamplay-ts\" jest --runInBand",
     "coverage-server": "NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc -C teamplay-ts\" c8 --include 'src/orm/**' --include 'src/react/**' --include 'src/utils/**' mocha 'test/[!_]*.js'",
     "coverage-client": "NODE_OPTIONS=\"${NODE_OPTIONS:-} --expose-gc --experimental-vm-modules -C teamplay-ts\" jest --coverage --coverageDirectory=coverage-client",
     "coverage": "npm run coverage-server && npm run coverage-client"
@@ -69,20 +71,20 @@
   "dependencies": {
     "@nx-js/observer-util": "^4.1.3",
     "@startupjs/sharedb-mingo-memory": "^4.0.0-2",
-    "@teamplay/backend": "^0.5.0-alpha.7",
-    "@teamplay/cache": "^0.5.0-alpha.7",
-    "@teamplay/channel": "^0.5.0-alpha.7",
-    "@teamplay/debug": "^0.5.0-alpha.7",
-    "@teamplay/schema": "^0.5.0-alpha.7",
-    "@teamplay/utils": "^0.5.0-alpha.7",
-    "babel-plugin-teamplay": "^0.5.0-alpha.7",
+    "@teamplay/backend": "^0.5.0",
+    "@teamplay/cache": "^0.5.0",
+    "@teamplay/channel": "^0.5.0",
+    "@teamplay/debug": "^0.5.0",
+    "@teamplay/schema": "^0.5.0",
+    "@teamplay/utils": "^0.5.0",
+    "babel-plugin-teamplay": "^0.5.0",
     "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": {
@@ -134,5 +136,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "a883c9d07948ea203021c20e7d234ad390ec9835"
+  "gitHead": "4c3274c4443ab4cb59410b070fe80fd7219e6e0d"
 }

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

@@ -1,3 +0,0 @@
-import { Signal } from '../SignalBase.js'
-
-export default class SignalCompat<TValue = unknown> extends Signal<TValue> {}