@sixb/core 0.1.20 → 0.1.22

package/src/storage/objects/in-memory/query.ts

@@ -1,13 +1,6 @@
-import type {
-  ObjectQuery,
-  ObjectQueryPredicate,
-  ObjectQuerySortField,
-  QueryScalarKind,
-} from "../../../objects/query"
-import {
-  compareQueryScalarValues,
-  queryScalarValuesEqual,
-} from "../../../objects/query/scalar-values"
+import type { ObjectQuery, ObjectQuerySortField } from "../../../objects/query"
+import { matchesPredicate } from "../../../objects/query/matches-predicate"
+import { compareQueryScalarValues } from "../../../objects/query/scalar-values"
 import { vectorSources } from "../../../objects/vectors/profile"
 import type { LinkBatchKey } from "../keys"
 import {
@@ -60,6 +53,7 @@ export const IN_MEMORY_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     in: true,
     exists: true,
     contains: true,
+    constant: true,
   },
   sortKinds: {
     property: true,
@@ -364,97 +358,6 @@ function completeEvaluation(entries: QueryEntry[]): QueryEvaluation {
   }
 }
 
-function matchesPredicate(row: ObjectRow, predicate: ObjectQueryPredicate): boolean {
-  switch (predicate.op) {
-    case "and":
-      return predicate.items.every((item) => matchesPredicate(row, item))
-    case "or":
-      return predicate.items.some((item) => matchesPredicate(row, item))
-    case "not":
-      return !matchesPredicate(row, predicate.item)
-    case "eq":
-      return queryScalarValuesEqual(
-        row.properties[predicate.propertyId],
-        predicate.value,
-        predicate.scalarKind
-      )
-    case "neq":
-      return !queryScalarValuesEqual(
-        row.properties[predicate.propertyId],
-        predicate.value,
-        predicate.scalarKind
-      )
-    case "lt":
-      return (
-        compareQueryScalarValues(
-          row.properties[predicate.propertyId],
-          predicate.value,
-          predicate.scalarKind
-        ) < 0
-      )
-    case "lte":
-      return (
-        compareQueryScalarValues(
-          row.properties[predicate.propertyId],
-          predicate.value,
-          predicate.scalarKind
-        ) <= 0
-      )
-    case "gt":
-      return (
-        compareQueryScalarValues(
-          row.properties[predicate.propertyId],
-          predicate.value,
-          predicate.scalarKind
-        ) > 0
-      )
-    case "gte":
-      return (
-        compareQueryScalarValues(
-          row.properties[predicate.propertyId],
-          predicate.value,
-          predicate.scalarKind
-        ) >= 0
-      )
-    case "in":
-      return predicate.values.some((value) =>
-        queryScalarValuesEqual(row.properties[predicate.propertyId], value, predicate.scalarKind)
-      )
-    case "exists": {
-      const exists =
-        Object.hasOwn(row.properties, predicate.propertyId) &&
-        row.properties[predicate.propertyId] !== undefined
-      return predicate.value ? exists : !exists
-    }
-    case "contains":
-      return containsValue(
-        row.properties[predicate.propertyId],
-        predicate.value,
-        predicate.scalarKind
-      )
-  }
-}
-
-function containsValue(
-  actual: unknown,
-  expected: unknown,
-  itemScalarKind: QueryScalarKind | undefined
-): boolean {
-  if (typeof actual === "string" && typeof expected === "string") {
-    return actual.includes(expected)
-  }
-
-  if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind))
-  }
-
-  if (isPlainObject(actual) && typeof expected === "string") {
-    return Object.hasOwn(actual, expected)
-  }
-
-  return false
-}
-
 function textScore(
   row: ObjectRow,
   query: string,
@@ -774,7 +677,3 @@ function decodePageOffset(token: string | undefined): number {
   }
   return offset
 }
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}

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,
+  }
+}