teamplay 0.4.0-alpha.73 → 0.4.0-alpha.75

package/orm/Compat/README.md

@@ -913,6 +913,19 @@ After `useBatch()` stops throwing in compat mode, immediate reads via
 `useLocal(...).get(...)` for already requested batch entities should not produce
 transient `undefined` caused by materialization races.
 
+### Missing ShareDB Docs
+
+Compat now mirrors Racer behavior for **missing public docs** (`type === null`,
+`version === 0`) after subscribe/fetch:
+
+- `connection.get(collection, id).data` becomes a truthy empty observable object;
+- but the compat/model path still stays unresolved, so `$.collection[id].get()`
+  continues to return `undefined` until the document is actually created.
+
+This matters for legacy consumers which read `shareDoc.data` directly (for
+example readonly rich-text paths) while still expecting normal public-doc
+creation semantics from model mutators.
+
 ## Examples
 
 ### useDoc with Suspense

package/orm/Compat/SignalCompat.js

@@ -15,6 +15,7 @@ import { IS_QUERY, getQuerySignal, querySubscriptions } from '../Query.js'
 import { IS_AGGREGATION, aggregationSubscriptions, getAggregationSignal } from '../Aggregation.js'
 import { getIdFieldsForSegments, isIdFieldPath, normalizeIdFields, isPlainObject } from '../idFields.js'
 import {
+  del as _del,
   setReplace as _setReplace,
   incrementPublic as _incrementPublic,
   arrayPush as _arrayPush,
@@ -916,8 +917,15 @@ function isMissingPublicDocDeleteError ($signal, error) {
 
 async function setDiffDeepOnSignal ($target, value) {
   if ($target[SEGMENTS].length === 0) throw Error('Can\'t set the root signal data')
-  const before = $target.get()
-  await diffDeepCompat($target, before, value)
+  // Use peek() here. compat start() writes via setDiffDeep inside an observer and must not
+  // subscribe to its own target, otherwise later local edits on child signals cause start()
+  // to rerun and overwrite them from source.
+  const before = $target.peek()
+  if (isPublicCollection($target[SEGMENTS][0])) {
+    await diffDeepCompat($target, before, value)
+    return
+  }
+  diffDeepCompatSync($target, before, value)
 }
 
 async function diffDeepCompat ($signal, before, after) {
@@ -949,6 +957,35 @@ async function diffDeepCompat ($signal, before, after) {
   await SignalCompat.prototype.set.call($signal, after)
 }
 
+function diffDeepCompatSync ($signal, before, after) {
+  if (before === after) return
+
+  if (Array.isArray(before) && Array.isArray(after)) {
+    if (deepEqualCompat(before, after)) return
+    const changedIndexes = getChangedArrayIndexes(before, after)
+    if (before.length === after.length && changedIndexes.length === 1) {
+      const index = changedIndexes[0]
+      diffDeepCompatSync(getChildSignal($signal, index), before[index], after[index])
+      return
+    }
+    setReplacePrivateCompatSync($signal, after)
+    return
+  }
+
+  if (isDiffableObject(before, after)) {
+    for (const key of Object.keys(before)) {
+      if (Object.prototype.hasOwnProperty.call(after, key)) continue
+      delPrivateCompatSync(getChildSignal($signal, key))
+    }
+    for (const key of Object.keys(after)) {
+      diffDeepCompatSync(getChildSignal($signal, key), before[key], after[key])
+    }
+    return
+  }
+
+  setReplacePrivateCompatSync($signal, after)
+}
+
 function isDiffableObject (before, after) {
   if (!isPlainObject(before) || !isPlainObject(after)) return false
   if (isReactLike(before) || isReactLike(after)) return false
@@ -972,6 +1009,26 @@ function getChildSignal ($parent, key) {
   return $child
 }
 
+function setReplacePrivateCompatSync ($signal, value) {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t set the root signal data')
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+  if (segments.length === 2) {
+    value = normalizeIdFields(value, idFields, segments[1])
+  }
+  _setReplace(segments, value)
+  mirrorRefMutationFromTarget(segments, value)
+}
+
+function delPrivateCompatSync ($signal) {
+  const segments = $signal[SEGMENTS]
+  if (segments.length === 0) throw Error('Can\'t delete the root signal data')
+  const idFields = getIdFieldsForSegments(segments)
+  if (isIdFieldPath(segments, idFields)) return
+  _del(segments)
+}
+
 function deepEqualCompat (left, right) {
   if (left === right) return true
   if (left == null || right == null) return false

package/orm/Compat/hooksCompat.js

@@ -5,6 +5,7 @@ import * as promiseBatcher from '../../react/promiseBatcher.js'
 import { getRaw } from '../dataTree.js'
 import { getConnection } from '../connection.js'
 import { isCompatEnv } from '../compatEnv.js'
+import { isMissingShareDoc } from '../missingDoc.js'
 
 const $root = getRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ })
 const emittedCompatWarnings = new Set()
@@ -393,7 +394,7 @@ function isDocReady (segments) {
   const [collection, id] = segments
   const shareDoc = getShareDoc(collection, id)
   // Missing docs should not block the batch barrier forever.
-  return !!(shareDoc && shareDoc.type === null && shareDoc.data == null)
+  return isMissingShareDoc(shareDoc)
 }
 
 function getShareDoc (collection, id) {

package/orm/Compat/startStopCompat.js

@@ -38,7 +38,12 @@ export function compatStartOnRoot ($root, targetPath, ...depsAndGetter) {
       if (isThenable(err)) return
       throw err
     }
-    const maybePromise = $target.set(detachStartValue(nextValue))
+    const detachedValue = detachStartValue(nextValue)
+    // 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
+    // start() subscribes to its own output and local child edits get immediately overwritten.
+    const maybePromise = $target.setDiffDeep(detachedValue)
     if (maybePromise?.catch) maybePromise.catch(ignorePromiseRejection)
   }, { scheduler: scheduleReaction })
   store.set(targetKey, { stop: () => unobserve(reaction) })

package/orm/Doc.js

@@ -7,6 +7,7 @@ import SubscriptionState from './SubscriptionState.js'
 import { getIdFieldsForSegments, injectIdFields, isPlainObject } from './idFields.js'
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
 import { getSubscriptionGcDelay } from './subscriptionGcDelay.js'
+import { isMissingShareDoc } from './missingDoc.js'
 
 const ERROR_ON_EXCESSIVE_UNSUBSCRIBES = false
 
@@ -103,6 +104,20 @@ class Doc {
 
   _refData () {
     const doc = getConnection().get(this.collection, this.docId)
+    // Racer/react-sharedb-hooks normalizes a missing ShareDB doc into a truthy
+    // observable placeholder on the shareDoc itself (`observable(undefined) -> {}`),
+    // while still keeping the model tree path unresolved. Some legacy consumers
+    // (for example readonly RTEditor paths) rely on this exact contract by reading
+    // `connection.get(...).data` directly and only checking for truthiness.
+    //
+    // We intentionally mirror that behavior here:
+    // - missing doc => keep model path undefined
+    // - but make shareDoc.data truthy/observable so direct ShareDB consumers behave
+    //   the same way they do under Racer.
+    if (isMissingShareDoc(doc) && doc.data === undefined) {
+      if (!isObservable(doc.data)) doc.data = observable(undefined)
+      return
+    }
     if (doc.data == null) return
     const idFields = getIdFieldsForSegments([this.collection, this.docId])
     if (isPlainObject(doc.data)) injectIdFields(doc.data, idFields, this.docId)

package/orm/dataTree.js

@@ -7,6 +7,7 @@ import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject }
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
 import { isSilentContextActive } from './Compat/silentContext.js'
 import { isCompatEnv } from './compatEnv.js'
+import { isMissingShareDoc } from './missingDoc.js'
 
 const ALLOW_PARTIAL_DOC_CREATION = false
 
@@ -344,6 +345,10 @@ function resolvePublicDocState ({
 }) {
   ensureLocalDocSyncedWithShareDoc({ collection, docId, doc, idFields })
 
+  if (isMissingShareDoc(doc)) {
+    return { exists: false, snapshot: undefined, source: 'none' }
+  }
+
   if (doc?.data != null) {
     return {
       exists: true,
@@ -390,6 +395,7 @@ function ensureLocalDocSyncedWithShareDoc ({
   doc,
   idFields
 }) {
+  if (isMissingShareDoc(doc)) return
   if (doc?.data == null) return
   if (isPlainObject(doc.data)) injectIdFields(doc.data, idFields, docId)
   const shared = raw(doc.data)

package/orm/missingDoc.js

@@ -0,0 +1,3 @@
+export function isMissingShareDoc (doc) {
+  return !!doc && doc.type === null && doc.version === 0
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.73",
+  "version": "0.4.0-alpha.75",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "d17c2236244682019cd737d8d3b4e853c771fa2b"
+  "gitHead": "e1b1ccfa91fde6dbd8fba60513c0ce0bc007c61b"
 }