@sixb/core 0.1.21 → 0.1.22

package/src/storage/objects/in-memory/read-scope.ts

@@ -7,14 +7,7 @@ import type {
   ObjectRow,
 } from "../types"
 import { fullLinkRowKey, rowIdentityKey, rowIdentityKeyParts, sourceLinkBucketKey } from "./keys"
-import type { InMemoryReadSource } from "./read-source"
-
-export interface InMemoryReadUniverse extends InMemoryReadSource {
-  readonly objects: ReadonlyMap<string, ObjectRow>
-  readonly links: ReadonlyMap<string, ObjectLinkRow>
-  readonly linksBySource: ReadonlyMap<string, readonly ObjectLinkRow[]>
-  readonly objectProperties: ReadonlyMap<string, ReadonlySet<string>>
-}
+import type { InMemoryReadSource, InMemoryScopedReadSource } from "./read-source"
 
 interface InMemoryReadPlan {
   readonly roots: readonly CompiledObjectReadRoot[]
@@ -52,7 +45,7 @@ export function resolveSelectedReadUniverse(
   source: InMemoryReadSource,
   plan: InMemoryReadPlan,
   limits: ObjectReadExecutionLimits
-): InMemoryReadUniverse {
+): InMemoryScopedReadSource {
   // Reachability stays path-sensitive until every finite selection step has run. The final
   // object/link universes union exact identities only after that traversal, so the same type
   // reached through another branch cannot inherit nested link authority.
@@ -145,7 +138,7 @@ function createReadUniverse(
   objects: ReadonlyMap<string, ObjectRow>,
   links: ReadonlyMap<string, ObjectLinkRow>,
   objectProperties: ReadonlyMap<string, ReadonlySet<string>>
-): InMemoryReadUniverse {
+): InMemoryScopedReadSource {
   const projectId = source.projectId
   const linksBySource = new Map<string, ObjectLinkRow[]>()
   for (const link of links.values()) {
@@ -156,16 +149,15 @@ function createReadUniverse(
   }
   return {
     projectId,
-    objects,
-    links,
-    linksBySource,
-    objectProperties,
+    selectsProperty: (objectTypeId, primaryId, propertyId) =>
+      objectProperties.get(rowIdentityKeyParts(objectTypeId, primaryId))?.has(propertyId) ?? false,
     getVector: (ref, profile) => {
       const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId)
       if (!objects.has(key)) return undefined
       const value = source.getVector?.(ref, profile)
       return value?.source.every((id) => objectProperties.get(key)?.has(id)) ? value : undefined
     },
+    allObjects: () => objects.values(),
     objectsOfType: (objectTypeId) =>
       [...objects.values()].filter((row) => row.objectTypeId === objectTypeId),
     getObject: (objectTypeId, primaryId) =>
@@ -173,6 +165,15 @@ function createReadUniverse(
     outgoingLinks: (objectTypeId, primaryId) =>
       linksBySource.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId)) ?? [],
     allLinks: () => links.values(),
+    // A holder outside the selection, or whose value it does not select, holds nothing here.
+    uniqueHolder: (value) => {
+      const holder = source.uniqueHolder(value)
+      if (holder === undefined) return undefined
+      const key = rowIdentityKeyParts(value.objectTypeId, holder)
+      return objects.has(key) && objectProperties.get(key)?.has(value.propertyId)
+        ? holder
+        : undefined
+    },
   }
 }
 

package/src/storage/objects/in-memory/read-source.ts

@@ -1,15 +1,25 @@
+import type { UniqueValueRef } from "../../ontology/materializations"
 import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectLinkRow, ObjectRow } from "../types"
 
-/** Project-bound read input shared by ordinary and selected in-memory queries. */
+/** Read input shared by ordinary and scoped in-memory queries; every method reads one project. */
 export interface InMemoryReadSource {
   readonly projectId: string
   getVector?(
     ref: { objectTypeId: string; primaryId: string },
     profile: string
   ): StoredObjectVector | undefined
+  allObjects(): Iterable<ObjectRow>
   objectsOfType(objectTypeId: string): readonly ObjectRow[]
   getObject(objectTypeId: string, primaryId: string): ObjectRow | undefined
   outgoingLinks(objectTypeId: string, primaryId: string): Iterable<ObjectLinkRow>
   allLinks(): Iterable<ObjectLinkRow>
+  /** The primary id of the object holding a unique value. */
+  uniqueHolder(value: UniqueValueRef): string | undefined
+}
+
+/** What a scoped reader sees of the store, resolved again for each of its operations. */
+export interface InMemoryScopedReadSource extends InMemoryReadSource {
+  /** Whether a property of a visible object may be read, whether or not it holds a value. */
+  selectsProperty(objectTypeId: string, primaryId: string, propertyId: string): boolean
 }

package/src/storage/objects/in-memory/scoped-reader.ts

@@ -0,0 +1,243 @@
+import { hasVectorProfile } from "../../../objects/vectors/query"
+import {
+  assertObjectReadFacetCount,
+  assertObjectReadOutputWithinLimit,
+  type ObjectReadExecutionLimits,
+} from "../execution-limits"
+import { type ObjectBatchKey, objectBatchKey } from "../keys"
+import { assertObjectReaderProject } from "../read-scope"
+import type {
+  CountObjectsInput,
+  ExistsObjectsInput,
+  FacetObjectsInput,
+  LinkDirection,
+  ObjectLinkRow,
+  ObjectQueryCapabilities,
+  ObjectReadStorage,
+  ObjectRow,
+  QueryObjectsInput,
+} from "../types"
+import { fullLinkRowKey } from "./keys"
+import {
+  buildFacetResults,
+  collectLinksBatch,
+  evaluateObjectQuery,
+  queryLinksFrom,
+  stripOuterRowShape,
+} from "./query"
+import type { InMemoryScopedReadSource } from "./read-source"
+
+/**
+ * Answer every terminal from what a scope leaves visible, resolved again for each operation so
+ * reads stay live. Rows leave detached; output budgets apply when the scope carries them.
+ */
+export function createInMemoryScopedReader(params: {
+  projectId: string
+  resolve: () => InMemoryScopedReadSource
+  limits?: ObjectReadExecutionLimits
+  queryCapabilities: () => ObjectQueryCapabilities
+}): ObjectReadStorage {
+  const { projectId, resolve, limits, queryCapabilities } = params
+  const assertProject = (actualProjectId: string) =>
+    assertObjectReaderProject(projectId, actualProjectId)
+  const visible = <T>(value: T): T => {
+    if (limits) assertObjectReadOutputWithinLimit(value, limits)
+    return value
+  }
+  const visibleMap = <TKey, TValue>(value: Map<TKey, TValue>): Map<TKey, TValue> => {
+    if (limits) assertObjectReadOutputWithinLimit([...value.entries()], limits)
+    return value
+  }
+  const selectsObjectProperties: ObjectReadStorage["selectsObjectProperties"] = async (input) => {
+    assertProject(input.projectId)
+    const source = resolve()
+    return visible(
+      input.items.map((item) =>
+        source.selectsProperty(item.objectTypeId, item.primaryId, item.propertyId)
+      )
+    )
+  }
+
+  return Object.freeze({
+    queryCapabilities,
+    queryObjects: async (input: QueryObjectsInput) => {
+      assertProject(input.projectId)
+      const result = evaluateObjectQuery(input.query, resolve())
+      return visible({
+        objects: result.entries.map((entry) => ({
+          ...structuredClone(entry.row),
+          ...(hasVectorProfile(input.query) ? { score: entry.score } : {}),
+        })),
+        hasMore: result.hasMore,
+        nextPageToken: result.nextPageToken,
+        ...(input.includeTotal === false ? {} : { total: result.total }),
+      })
+    },
+    countObjects: async (input: CountObjectsInput) => {
+      assertProject(input.projectId)
+      return visible({
+        count: evaluateObjectQuery(stripOuterRowShape(input.query), resolve()).total,
+      })
+    },
+    existsObjects: async (input: ExistsObjectsInput) => {
+      assertProject(input.projectId)
+      return visible({
+        exists: evaluateObjectQuery(stripOuterRowShape(input.query), resolve()).total > 0,
+      })
+    },
+    facetObjects: async (input: FacetObjectsInput) => {
+      assertProject(input.projectId)
+      assertObjectReadFacetCount(input.facets.length)
+      const result = evaluateObjectQuery(stripOuterRowShape(input.query), resolve())
+      return visible(
+        structuredClone({
+          total: result.entries.length,
+          facets: buildFacetResults(
+            result.entries.map((entry) => entry.row),
+            input.facets
+          ),
+        })
+      )
+    },
+    getByPrimaryId: async (input) => {
+      assertProject(input.projectId)
+      const row = resolve().getObject(input.objectTypeId, input.primaryId)
+      return visible(row ? structuredClone(row) : null)
+    },
+    getByUniqueValue: async (input) => {
+      assertProject(input.projectId)
+      const source = resolve()
+      const holder = source.uniqueHolder(input)
+      const row = holder === undefined ? undefined : source.getObject(input.objectTypeId, holder)
+      return visible(row ? structuredClone(row) : null)
+    },
+    selectsObjectProperties,
+    listLinks: async (input) => {
+      assertProject(input.projectId)
+      return visible(listScopedLinks(resolve(), input).map((row) => structuredClone(row)))
+    },
+    getByPrimaryIdBatch: async (input) => {
+      assertProject(input.projectId)
+      const source = resolve()
+      const rows = new Map<ObjectBatchKey, ObjectRow>()
+      for (const item of input.items) {
+        const row = source.getObject(item.objectTypeId, item.primaryId)
+        if (row) {
+          rows.set(objectBatchKey(item.objectTypeId, item.primaryId), structuredClone(row))
+        }
+      }
+      return visibleMap(rows)
+    },
+    listLinksBatch: async (input) => {
+      assertProject(input.projectId)
+      const source = resolve()
+      return visibleMap(
+        collectLinksBatch(
+          {
+            all: () => source.allLinks(),
+            outgoing: (item) => source.outgoingLinks(item.objectTypeId, item.objectId),
+          },
+          input,
+          true
+        )
+      )
+    },
+    queryLinks: async (input) => {
+      assertProject(input.projectId)
+      const source = resolve()
+      return visible(
+        structuredClone(await queryLinksFrom(input, (item) => listScopedLinks(source, item)))
+      )
+    },
+    list: async (input) => {
+      assertProject(input.projectId)
+      return visible(listRows(input, [...resolve().allObjects()]))
+    },
+  } satisfies ObjectReadStorage)
+}
+
+function listScopedLinks(
+  source: InMemoryScopedReadSource,
+  params: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly objectId: string
+    readonly linkId?: string
+    readonly direction?: LinkDirection
+  }
+): ObjectLinkRow[] {
+  const direction = params.direction ?? "outgoing"
+  const matches = (row: ObjectLinkRow) => !params.linkId || row.linkId === params.linkId
+  const rows: ObjectLinkRow[] = []
+
+  if (direction === "outgoing" || direction === "both") {
+    for (const row of source.outgoingLinks(params.objectTypeId, params.objectId)) {
+      if (matches(row)) rows.push(row)
+    }
+  }
+  if (direction === "incoming" || direction === "both") {
+    for (const row of source.allLinks()) {
+      if (
+        row.targetTypeId === params.objectTypeId &&
+        row.targetId === params.objectId &&
+        matches(row)
+      ) {
+        rows.push(row)
+      }
+    }
+  }
+
+  if (direction !== "both") return rows
+  return [...new Map(rows.map((row) => [fullLinkRowKey(row), row])).values()]
+}
+
+function listRows(
+  params: Parameters<ObjectReadStorage["list"]>[0],
+  candidates: readonly ObjectRow[]
+): { objects: readonly ObjectRow[]; hasMore: boolean; total: number } {
+  const requestedTypes =
+    params.objectTypeId === undefined
+      ? undefined
+      : new Set(
+          typeof params.objectTypeId === "string" ? [params.objectTypeId] : params.objectTypeId
+        )
+  let rows = candidates.filter(
+    (row) =>
+      row.projectId === params.projectId &&
+      (!requestedTypes || requestedTypes.has(row.objectTypeId))
+  )
+
+  rows = rows.filter(
+    (row) =>
+      (!params.primaryIdPrefix || row.primaryId.startsWith(params.primaryIdPrefix)) &&
+      (!params.primaryIdSuffix || row.primaryId.endsWith(params.primaryIdSuffix)) &&
+      (!params.updatedAfter || row.updatedAt >= params.updatedAfter) &&
+      (!params.updatedBefore || row.updatedAt <= params.updatedBefore) &&
+      (!params.createdAfter || row.createdAt >= params.createdAfter) &&
+      (!params.createdBefore || row.createdAt <= params.createdBefore)
+  )
+
+  const total = rows.length
+  const offset = params.offset ?? 0
+  const limit = params.limit ?? 50
+  if (limit === 0) return { objects: [], hasMore: offset < total, total }
+
+  const orderBy = params.orderBy ?? "updatedAt"
+  const order = params.order ?? "desc"
+  rows.sort((left, right) => {
+    const comparison =
+      orderBy === "primaryId"
+        ? left.primaryId.localeCompare(right.primaryId)
+        : orderBy === "createdAt"
+          ? left.createdAt.getTime() - right.createdAt.getTime()
+          : left.updatedAt.getTime() - right.updatedAt.getTime()
+    return order === "desc" ? -comparison : comparison
+  })
+
+  const objects = rows.slice(offset, offset + limit).map((row) => structuredClone(row))
+  return {
+    objects,
+    hasMore: offset + limit < total,
+    total,
+  }
+}

package/src/storage/objects/in-memory/selected-reader.ts

@@ -1,38 +1,15 @@
-import { hasVectorProfile } from "../../../objects/vectors/query"
 import {
-  assertObjectReadFacetCount,
-  assertObjectReadOutputWithinLimit,
   type ObjectReadExecutionLimits,
   snapshotObjectReadExecutionLimits,
 } from "../execution-limits"
-import { type ObjectBatchKey, objectBatchKey } from "../keys"
-import { assertObjectReaderProject } from "../read-scope"
 import type {
   CompiledSelectedObjectReadScope,
-  CountObjectsInput,
-  ExistsObjectsInput,
-  FacetObjectsInput,
-  LinkDirection,
-  ObjectLinkRow,
   ObjectQueryCapabilities,
   ObjectReadStorage,
-  ObjectRow,
-  QueryObjectsInput,
 } from "../types"
-import { fullLinkRowKey, rowIdentityKeyParts, sourceLinkBucketKey } from "./keys"
-import {
-  buildFacetResults,
-  collectLinksBatch,
-  evaluateObjectQuery,
-  queryLinksFrom,
-  stripOuterRowShape,
-} from "./query"
-import {
-  type InMemoryReadUniverse,
-  prepareReadPlan,
-  resolveSelectedReadUniverse,
-} from "./read-scope"
+import { prepareReadPlan, resolveSelectedReadUniverse } from "./read-scope"
 import type { InMemoryReadSource } from "./read-source"
+import { createInMemoryScopedReader } from "./scoped-reader"
 
 /** Capture a selection once, then resolve its live data and enforce budgets per operation. */
 export function createInMemorySelectedReader(
@@ -43,215 +20,13 @@ export function createInMemorySelectedReader(
   },
   queryCapabilities: () => ObjectQueryCapabilities
 ): ObjectReadStorage {
-  const projectId = source.projectId
   const plan = prepareReadPlan(params.scope)
   const limits = snapshotObjectReadExecutionLimits(params.limits)
-  const assertProject = (actualProjectId: string) =>
-    assertObjectReaderProject(projectId, actualProjectId)
-  const visible = <T>(value: T): T => {
-    assertObjectReadOutputWithinLimit(value, limits)
-    return value
-  }
-  const visibleMap = <TKey, TValue>(value: Map<TKey, TValue>): Map<TKey, TValue> => {
-    assertObjectReadOutputWithinLimit([...value.entries()], limits)
-    return value
-  }
-  const selectsObjectProperties: ObjectReadStorage["selectsObjectProperties"] = async (input) => {
-    assertProject(input.projectId)
-    const universe = resolveSelectedReadUniverse(source, plan, limits)
-    return visible(
-      input.items.map((item) => {
-        const key = rowIdentityKeyParts(item.objectTypeId, item.primaryId)
-        if (!universe.objects.has(key)) return false
-        return universe.objectProperties.get(key)?.has(item.propertyId) ?? false
-      })
-    )
-  }
 
-  return Object.freeze({
+  return createInMemoryScopedReader({
+    projectId: source.projectId,
+    resolve: () => resolveSelectedReadUniverse(source, plan, limits),
+    limits,
     queryCapabilities,
-    queryObjects: async (input: QueryObjectsInput) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      const result = evaluateObjectQuery(input.query, universe)
-      return visible({
-        objects: result.entries.map((entry) => ({
-          ...structuredClone(entry.row),
-          ...(hasVectorProfile(input.query) ? { score: entry.score } : {}),
-        })),
-        hasMore: result.hasMore,
-        nextPageToken: result.nextPageToken,
-        ...(input.includeTotal === false ? {} : { total: result.total }),
-      })
-    },
-    countObjects: async (input: CountObjectsInput) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visible({
-        count: evaluateObjectQuery(stripOuterRowShape(input.query), universe).total,
-      })
-    },
-    existsObjects: async (input: ExistsObjectsInput) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visible({
-        exists: evaluateObjectQuery(stripOuterRowShape(input.query), universe).total > 0,
-      })
-    },
-    facetObjects: async (input: FacetObjectsInput) => {
-      assertProject(input.projectId)
-      assertObjectReadFacetCount(input.facets.length)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      const result = evaluateObjectQuery(stripOuterRowShape(input.query), universe)
-      return visible(
-        structuredClone({
-          total: result.entries.length,
-          facets: buildFacetResults(
-            result.entries.map((entry) => entry.row),
-            input.facets
-          ),
-        })
-      )
-    },
-    getByPrimaryId: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      const row = universe.objects.get(rowIdentityKeyParts(input.objectTypeId, input.primaryId))
-      return visible(row ? structuredClone(row) : null)
-    },
-    selectsObjectProperties,
-    listLinks: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visible(listUniverseLinks(universe, input).map((row) => structuredClone(row)))
-    },
-    getByPrimaryIdBatch: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      const rows = new Map<ObjectBatchKey, ObjectRow>()
-      for (const item of input.items) {
-        const row = universe.objects.get(rowIdentityKeyParts(item.objectTypeId, item.primaryId))
-        if (row) {
-          rows.set(objectBatchKey(item.objectTypeId, item.primaryId), structuredClone(row))
-        }
-      }
-      return visibleMap(rows)
-    },
-    listLinksBatch: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visibleMap(
-        collectLinksBatch(
-          {
-            all: () => universe.links.values(),
-            outgoing: (item) =>
-              universe.linksBySource.get(
-                sourceLinkBucketKey(projectId, item.objectTypeId, item.objectId)
-              ) ?? [],
-          },
-          input,
-          true
-        )
-      )
-    },
-    queryLinks: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visible(
-        structuredClone(await queryLinksFrom(input, (item) => listUniverseLinks(universe, item)))
-      )
-    },
-    list: async (input) => {
-      assertProject(input.projectId)
-      const universe = resolveSelectedReadUniverse(source, plan, limits)
-      return visible(listRows(input, [...universe.objects.values()]))
-    },
-  } satisfies ObjectReadStorage)
-}
-
-function listUniverseLinks(
-  universe: InMemoryReadUniverse,
-  params: {
-    readonly projectId: string
-    readonly objectTypeId: string
-    readonly objectId: string
-    readonly linkId?: string
-    readonly direction?: LinkDirection
-  }
-): ObjectLinkRow[] {
-  const direction = params.direction ?? "outgoing"
-  const matches = (row: ObjectLinkRow) => !params.linkId || row.linkId === params.linkId
-  const rows: ObjectLinkRow[] = []
-
-  if (direction === "outgoing" || direction === "both") {
-    const outgoing = universe.linksBySource.get(
-      sourceLinkBucketKey(params.projectId, params.objectTypeId, params.objectId)
-    )
-    if (outgoing) rows.push(...outgoing.filter(matches))
-  }
-  if (direction === "incoming" || direction === "both") {
-    for (const row of universe.links.values()) {
-      if (
-        row.targetTypeId === params.objectTypeId &&
-        row.targetId === params.objectId &&
-        matches(row)
-      ) {
-        rows.push(row)
-      }
-    }
-  }
-
-  if (direction !== "both") return rows
-  return [...new Map(rows.map((row) => [fullLinkRowKey(row), row])).values()]
-}
-
-function listRows(
-  params: Parameters<ObjectReadStorage["list"]>[0],
-  candidates: readonly ObjectRow[]
-): { objects: readonly ObjectRow[]; hasMore: boolean; total: number } {
-  const requestedTypes =
-    params.objectTypeId === undefined
-      ? undefined
-      : new Set(
-          typeof params.objectTypeId === "string" ? [params.objectTypeId] : params.objectTypeId
-        )
-  let rows = candidates.filter(
-    (row) =>
-      row.projectId === params.projectId &&
-      (!requestedTypes || requestedTypes.has(row.objectTypeId))
-  )
-
-  rows = rows.filter(
-    (row) =>
-      (!params.primaryIdPrefix || row.primaryId.startsWith(params.primaryIdPrefix)) &&
-      (!params.primaryIdSuffix || row.primaryId.endsWith(params.primaryIdSuffix)) &&
-      (!params.updatedAfter || row.updatedAt >= params.updatedAfter) &&
-      (!params.updatedBefore || row.updatedAt <= params.updatedBefore) &&
-      (!params.createdAfter || row.createdAt >= params.createdAfter) &&
-      (!params.createdBefore || row.createdAt <= params.createdBefore)
-  )
-
-  const total = rows.length
-  const offset = params.offset ?? 0
-  const limit = params.limit ?? 50
-  if (limit === 0) return { objects: [], hasMore: offset < total, total }
-
-  const orderBy = params.orderBy ?? "updatedAt"
-  const order = params.order ?? "desc"
-  rows.sort((left, right) => {
-    const comparison =
-      orderBy === "primaryId"
-        ? left.primaryId.localeCompare(right.primaryId)
-        : orderBy === "createdAt"
-          ? left.createdAt.getTime() - right.createdAt.getTime()
-          : left.updatedAt.getTime() - right.updatedAt.getTime()
-    return order === "desc" ? -comparison : comparison
   })
-
-  const objects = rows.slice(offset, offset + limit).map((row) => structuredClone(row))
-  return {
-    objects,
-    hasMore: offset + limit < total,
-    total,
-  }
 }