teamplay 0.4.0-alpha.76 → 0.4.0-alpha.78

package/orm/Compat/SignalCompat.js

@@ -13,7 +13,7 @@ import { publicOnly, fetchOnly, setFetchOnly } from '../connection.js'
 import { docSubscriptions } from '../Doc.js'
 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 { getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, isPlainObject } from '../idFields.js'
 import {
   del as _del,
   setReplace as _setReplace,
@@ -38,6 +38,7 @@ import {
   stringRemovePublic as _stringRemovePublic
 } from '../dataTree.js'
 import { on as onCustomEvent, removeListener as removeCustomEventListener } from './eventsCompat.js'
+import { waitForImperativeQueryReady } from './queryReadiness.js'
 import { normalizePattern, onModelEvent, removeModelListener } from './modelEvents.js'
 import { setRefLink, removeRefLink, getRefLinks } from './refRegistry.js'
 import { REF_TARGET, resolveRefSignalSafe, resolveRefSegmentsSafe } from './refFallback.js'
@@ -1014,7 +1015,7 @@ function setReplacePrivateCompatSync ($signal, value) {
   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) {
+  if (isPublicDocPath(segments)) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
   _setReplace(segments, value)
@@ -1064,7 +1065,7 @@ async function setReplaceOnSignal ($signal, value) {
   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) {
+  if (isPublicDocPath(segments)) {
     value = normalizeIdFields(value, idFields, segments[1])
   }
   if (isPublicCollection(segments[0])) {
@@ -1284,8 +1285,18 @@ function flattenItems (items, result = []) {
 }
 
 function subscribeSelf ($signal) {
-  if ($signal[IS_QUERY]) return querySubscriptions.subscribe($signal)
-  if ($signal[IS_AGGREGATION]) return aggregationSubscriptions.subscribe($signal)
+  if ($signal[IS_QUERY]) {
+    return (async () => {
+      await querySubscriptions.subscribe($signal)
+      await waitForImperativeQueryReady($signal)
+    })()
+  }
+  if ($signal[IS_AGGREGATION]) {
+    return (async () => {
+      await aggregationSubscriptions.subscribe($signal)
+      await waitForImperativeQueryReady($signal)
+    })()
+  }
   if (isPublicDocumentSignal($signal)) return docSubscriptions.subscribe($signal)
   if (isPublicCollectionSignal($signal)) {
     throw Error('Signal.subscribe() expects a query signal. Use .query() for collections.')

package/orm/Compat/hooksCompat.js

@@ -2,10 +2,8 @@ import { getRootSignal, GLOBAL_ROOT_ID } from '../Root.js'
 import useSub, { useAsyncSub } from '../../react/useSub.js'
 import universal$ from '../../react/universal$.js'
 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'
+import { isQueryReady } from './queryReadiness.js'
 
 const $root = getRootSignal({ rootId: GLOBAL_ROOT_ID, rootFunction: universal$ })
 const emittedCompatWarnings = new Set()
@@ -361,50 +359,6 @@ function normalizeSyncSubOptions (options) {
   }
 }
 
-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
-}
-
-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)
-}
-
-function getShareDoc (collection, id) {
-  try {
-    return getConnection().get(collection, id)
-  } catch {
-    return undefined
-  }
-}
-
 export const __COMPAT_BATCH_READY__ = {
   isQueryReady
 }

package/orm/Compat/queryReadiness.js

@@ -0,0 +1,165 @@
+import { getRaw, set as _set } from '../dataTree.js'
+import { getConnection } from '../connection.js'
+import { isMissingShareDoc } from '../missingDoc.js'
+import { QUERIES, HASH, PARAMS, COLLECTION_NAME } from '../Query.js'
+import { AGGREGATIONS, IS_AGGREGATION } from '../Aggregation.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()
+  while (true) {
+    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 params = $query[PARAMS]
+  const hasExtraResult = isExtraQuery(params)
+  if (hasExtraResult) return getRaw([QUERIES, hash, 'extra']) !== undefined
+
+  const isAggregate = !!$query[IS_AGGREGATION] || isAggregationQuery(params)
+  if (isAggregate) {
+    return isQueryReady(
+      collection,
+      [QUERIES, hash, 'ids'],
+      [QUERIES, hash, 'docs'],
+      [QUERIES, hash, 'extra'],
+      [AGGREGATIONS, hash],
+      true,
+      false
+    )
+  }
+
+  const ids = getRaw([QUERIES, hash, 'ids'])
+  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 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 ids = getRaw([QUERIES, hash, 'ids'])
+  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)
+  }
+
+  _set([QUERIES, hash, 'docs'], docs)
+}
+
+function createImperativeQueryReadinessError ($query, timeoutMs) {
+  const collection = $query[COLLECTION_NAME]
+  const hash = $query[HASH]
+  const params = $query[PARAMS]
+  const ids = getRaw([QUERIES, hash, 'ids'])
+  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/orm/SignalBase.js

@@ -45,7 +45,15 @@ import { IS_QUERY, HASH, QUERIES } from './Query.js'
 import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js'
 import { ROOT_FUNCTION, getRoot } from './Root.js'
 import { publicOnly } from './connection.js'
-import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, normalizeIdFields } from './idFields.js'
+import {
+  DEFAULT_ID_FIELDS,
+  getIdFieldsForSegments,
+  isIdFieldPath,
+  isPublicDocPath,
+  normalizeIdFields,
+  prepareAddPayload,
+  resolveAddDocId
+} from './idFields.js'
 import { isCompatEnv } from './compatEnv.js'
 import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js'
 import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js'
@@ -262,7 +270,7 @@ export class Signal extends Function {
     if (this[SEGMENTS].length === 0) throw Error('Can\'t set the root signal data')
     const idFields = getIdFieldsForSegments(this[SEGMENTS])
     if (isIdFieldPath(this[SEGMENTS], idFields)) return
-    if (this[SEGMENTS].length === 2) {
+    if (isPublicDocPath(this[SEGMENTS])) {
       value = normalizeIdFields(value, idFields, this[SEGMENTS][1])
     }
     if (isPublicCollection(this[SEGMENTS][0])) {
@@ -424,24 +432,9 @@ export class Signal extends Function {
 
   async add (value) {
     if (arguments.length > 1) throw Error('Signal.add() expects a single argument')
-    if (!value || typeof value !== 'object') throw Error('Signal.add() expects an object argument')
-    const hasId = value.id != null
-    const hasUnderscoreId = value._id != null
-    if (hasId && hasUnderscoreId && value.id !== value._id) {
-      throw Error(
-        `Signal.add() got conflicting "id" (${JSON.stringify(value.id)}) and "_id" (${JSON.stringify(value._id)})`
-      )
-    }
-    let id = value.id ?? value._id
-    id ??= uuid()
+    const id = resolveAddDocId(value, uuid)
     const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id])
-    if (idFields.includes('_id')) value._id = id
-    if (idFields.includes('id')) {
-      value.id = id
-    } else if (value.id === id) {
-      delete value.id
-    }
-    await this[id].set(value)
+    await this[id].set(prepareAddPayload(value, idFields, id))
     return id
   }
 

package/orm/dataTree.js

@@ -3,7 +3,7 @@ import jsonDiff from 'json0-ot-diff'
 import diffMatchPatch from 'diff-match-patch'
 import { getConnection } from './connection.js'
 import setDiffDeep from '../utils/setDiffDeep.js'
-import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject } from './idFields.js'
+import { getIdFieldsForSegments, injectIdFields, stripIdFields, isPlainObject, isIdFieldPath } from './idFields.js'
 import { emitModelChange, isModelEventsEnabled } from './Compat/modelEvents.js'
 import { isSilentContextActive } from './Compat/silentContext.js'
 import { isCompatEnv } from './compatEnv.js'
@@ -158,7 +158,7 @@ export async function setPublicDoc (segments, value, deleteValue = false) {
   if (docId === 'undefined') throw Error(ERRORS.publicDocIdUndefined(segments))
   if (!(collection && docId)) throw Error(ERRORS.publicDoc(segments))
   const idFields = getIdFieldsForSegments([collection, docId])
-  if (segments.length >= 3 && idFields.includes(segments[segments.length - 1])) return
+  if (isIdFieldPath(segments, idFields)) return
   const doc = getConnection().get(collection, docId)
   let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData: true })
   if (!docState.exists && segments.length > 2) {
@@ -247,7 +247,7 @@ export async function setPublicDocReplace (segments, value) {
   if (docId === 'undefined') throw Error(ERRORS.publicDocIdUndefined(segments))
   if (!(collection && docId)) throw Error(ERRORS.publicDoc(segments))
   const idFields = getIdFieldsForSegments([collection, docId])
-  if (segments.length >= 3 && idFields.includes(segments[segments.length - 1])) return
+  if (isIdFieldPath(segments, idFields)) return
   const doc = getConnection().get(collection, docId)
   let docState = resolvePublicDocState({ collection, docId, doc, idFields, hydrateCompatDocData: true })
   if (!docState.exists && segments.length > 2) {

package/orm/idFields.js

@@ -50,8 +50,39 @@ export function stripIdFields (value, idFields) {
   return next
 }
 
+export function resolveAddDocId (value, getDefaultId) {
+  if (!value || typeof value !== 'object') throw Error('Signal.add() expects an object argument')
+  const hasId = value.id != null
+  const hasUnderscoreId = value._id != null
+  if (hasId && hasUnderscoreId && value.id !== value._id) {
+    throw Error(
+      `Signal.add() got conflicting "id" (${JSON.stringify(value.id)}) and "_id" (${JSON.stringify(value._id)})`
+    )
+  }
+  return value.id ?? value._id ?? getDefaultId()
+}
+
+export function prepareAddPayload (value, idFields, docId) {
+  if (idFields.includes('_id')) value._id = docId
+  if (idFields.includes('id')) {
+    value.id = docId
+  } else if (value.id === docId) {
+    delete value.id
+  }
+  return value
+}
+
+export function isPublicDocPath (segments) {
+  if (!Array.isArray(segments) || segments.length !== 2) return false
+  const [collection, docId] = segments
+  if (typeof collection !== 'string' || !collection) return false
+  if (collection[0] === '_' || collection[0] === '$') return false
+  return docId != null
+}
+
 export function isIdFieldPath (segments, idFields) {
-  if (segments.length < 3) return false
-  const last = segments[segments.length - 1]
+  if (!Array.isArray(segments) || segments.length !== 3) return false
+  if (!isPublicDocPath(segments.slice(0, 2))) return false
+  const last = segments[2]
   return idFields.includes(last)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamplay",
-  "version": "0.4.0-alpha.76",
+  "version": "0.4.0-alpha.78",
   "description": "Full-stack signals ORM with multiplayer",
   "type": "module",
   "main": "index.js",
@@ -83,5 +83,5 @@
     ]
   },
   "license": "MIT",
-  "gitHead": "954f4352b0641286b46c015a152175929eb979bc"
+  "gitHead": "6ced13d745e3ccb000b2fc9c34a31e51810cadbc"
 }