@sixb/core 0.1.6 → 0.1.8

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

@@ -0,0 +1,211 @@
+import { type ObjectReadExecutionLimits, ObjectReadLimitExceededError } from "../execution-limits"
+import type {
+  CompiledObjectReadRoot,
+  CompiledObjectReadStep,
+  CompiledSelectedObjectReadScope,
+  ObjectLinkRow,
+  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>>
+}
+
+interface InMemoryReadPlan {
+  readonly roots: readonly CompiledObjectReadRoot[]
+  readonly selectionsByNode: ReadonlyMap<number, ReadonlyMap<string, ReadonlySet<string>>>
+  readonly steps: readonly CompiledObjectReadStep[]
+}
+
+export function prepareReadPlan(scope: CompiledSelectedObjectReadScope): InMemoryReadPlan {
+  const selectionsByNode = new Map<number, Map<string, ReadonlySet<string>>>()
+  for (const selection of scope.objects) {
+    const byType = selectionsByNode.get(selection.nodeId) ?? new Map()
+    byType.set(selection.objectTypeId, new Set(selection.propertyIds))
+    selectionsByNode.set(selection.nodeId, byType)
+  }
+
+  // The compiler allocates node ids parent-first. Resolve every step from lower parent ids to
+  // higher child ids so a node reached through several concrete definitions is complete before
+  // its nested selections run.
+  const steps = [...scope.steps].sort(
+    (left, right) =>
+      left.parentNodeId - right.parentNodeId ||
+      left.nodeId - right.nodeId ||
+      left.sourceObjectTypeId.localeCompare(right.sourceObjectTypeId) ||
+      left.linkId.localeCompare(right.linkId) ||
+      left.targetObjectTypeId.localeCompare(right.targetObjectTypeId)
+  )
+  return {
+    roots: scope.roots,
+    selectionsByNode,
+    steps,
+  }
+}
+
+export function resolveSelectedReadUniverse(
+  source: InMemoryReadSource,
+  plan: InMemoryReadPlan,
+  limits: ObjectReadExecutionLimits
+): InMemoryReadUniverse {
+  // 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.
+  const reachableByNode = new Map<number, Map<string, ObjectRow>>()
+  const rawObjects = new Map<string, ObjectRow>()
+  const objectProperties = new Map<string, Set<string>>()
+  const authorizedLinks = new Map<
+    string,
+    { readonly row: ObjectLinkRow; readonly propertyIds: Set<string> }
+  >()
+  let traversalFacts = 0
+  const consumeTraversalFact = (): void => {
+    traversalFacts += 1
+    if (traversalFacts > limits.maxTraversalFacts) {
+      throw new ObjectReadLimitExceededError("traversalFacts", limits.maxTraversalFacts)
+    }
+  }
+
+  const addReachable = (nodeId: number, row: ObjectRow): void => {
+    const selectedProperties = plan.selectionsByNode.get(nodeId)?.get(row.objectTypeId)
+    if (!selectedProperties) return
+    const key = rowIdentityKey(row)
+    const reachable = reachableByNode.get(nodeId) ?? new Map<string, ObjectRow>()
+    reachable.set(key, row)
+    reachableByNode.set(nodeId, reachable)
+    rawObjects.set(key, row)
+    unionInto(objectProperties, key, selectedProperties)
+  }
+
+  for (const root of plan.roots) {
+    const row = source.getObject(root.objectTypeId, root.primaryId)
+    if (row) {
+      consumeTraversalFact()
+      addReachable(root.nodeId, row)
+    }
+  }
+
+  for (const step of plan.steps) {
+    const parents = reachableByNode.get(step.parentNodeId)
+    if (!parents) continue
+    for (const parent of parents.values()) {
+      if (parent.objectTypeId !== step.sourceObjectTypeId) continue
+      for (const link of source.outgoingLinks(parent.objectTypeId, parent.primaryId)) {
+        if (link.linkId !== step.linkId || link.targetTypeId !== step.targetObjectTypeId) {
+          continue
+        }
+        const target = source.getObject(link.targetTypeId, link.targetId)
+        if (!target) continue
+        consumeTraversalFact()
+        addReachable(step.nodeId, target)
+
+        const linkKey = fullLinkRowKey(link)
+        const selected = authorizedLinks.get(linkKey)
+        if (selected) {
+          for (const propertyId of step.propertyIds) selected.propertyIds.add(propertyId)
+        } else {
+          authorizedLinks.set(linkKey, {
+            row: link,
+            propertyIds: new Set(step.propertyIds),
+          })
+        }
+      }
+    }
+  }
+
+  const objects = new Map<string, ObjectRow>()
+  for (const [key, propertyIds] of objectProperties) {
+    const row = rawObjects.get(key)
+    if (row) objects.set(key, redactObjectRow(row, propertyIds))
+  }
+
+  const links = new Map<string, ObjectLinkRow>()
+  for (const [key, selected] of authorizedLinks) {
+    // Both endpoint identities must remain live and selected. This also prevents a stale link
+    // from exposing metadata after its target object disappears.
+    if (
+      !objects.has(rowIdentityKeyParts(selected.row.sourceTypeId, selected.row.sourceId)) ||
+      !objects.has(rowIdentityKeyParts(selected.row.targetTypeId, selected.row.targetId))
+    ) {
+      continue
+    }
+    links.set(key, redactLinkRow(selected.row, selected.propertyIds))
+  }
+
+  return createReadUniverse(source.projectId, objects, links, objectProperties)
+}
+
+function createReadUniverse(
+  projectId: string,
+  objects: ReadonlyMap<string, ObjectRow>,
+  links: ReadonlyMap<string, ObjectLinkRow>,
+  objectProperties: ReadonlyMap<string, ReadonlySet<string>>
+): InMemoryReadUniverse {
+  const linksBySource = new Map<string, ObjectLinkRow[]>()
+  for (const link of links.values()) {
+    const key = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId)
+    const bucket = linksBySource.get(key) ?? []
+    bucket.push(link)
+    linksBySource.set(key, bucket)
+  }
+  return {
+    projectId,
+    objects,
+    links,
+    linksBySource,
+    objectProperties,
+    objectsOfType: (objectTypeId) =>
+      [...objects.values()].filter((row) => row.objectTypeId === objectTypeId),
+    getObject: (objectTypeId, primaryId) =>
+      objects.get(rowIdentityKeyParts(objectTypeId, primaryId)),
+    outgoingLinks: (objectTypeId, primaryId) =>
+      linksBySource.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId)) ?? [],
+    allLinks: () => links.values(),
+  }
+}
+
+function unionInto(
+  target: Map<string, Set<string>>,
+  key: string,
+  values: ReadonlySet<string>
+): void {
+  const union = target.get(key) ?? new Set<string>()
+  for (const value of values) union.add(value)
+  target.set(key, union)
+}
+
+function redactObjectRow(row: ObjectRow, propertyIds: ReadonlySet<string>): ObjectRow {
+  const clone = structuredClone(row)
+  delete clone.links
+  clone.properties = redactProperties(clone.properties, propertyIds)
+  return clone
+}
+
+function redactLinkRow(row: ObjectLinkRow, propertyIds: ReadonlySet<string>): ObjectLinkRow {
+  const clone = structuredClone(row)
+  const properties = redactProperties(clone.properties ?? {}, propertyIds)
+  if (Object.keys(properties).length === 0) {
+    delete clone.properties
+  } else {
+    clone.properties = properties
+  }
+  return clone
+}
+
+function redactProperties(
+  properties: Readonly<Record<string, unknown>>,
+  propertyIds: ReadonlySet<string>
+): Record<string, unknown> {
+  // Object.fromEntries uses CreateDataProperty, so valid ontology ids such as `__proto__` remain
+  // ordinary own properties without changing the returned object's prototype.
+  return Object.fromEntries(
+    [...propertyIds]
+      .filter((propertyId) => Object.hasOwn(properties, propertyId))
+      .map((propertyId) => [propertyId, properties[propertyId]])
+  )
+}

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

@@ -0,0 +1,10 @@
+import type { ObjectLinkRow, ObjectRow } from "../types"
+
+/** Project-bound read input shared by ordinary and selected in-memory queries. */
+export interface InMemoryReadSource {
+  readonly projectId: string
+  objectsOfType(objectTypeId: string): readonly ObjectRow[]
+  getObject(objectTypeId: string, primaryId: string): ObjectRow | undefined
+  outgoingLinks(objectTypeId: string, primaryId: string): Iterable<ObjectLinkRow>
+  allLinks(): Iterable<ObjectLinkRow>
+}

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

@@ -0,0 +1,252 @@
+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 type { InMemoryReadSource } from "./read-source"
+
+/** Capture a selection once, then resolve its live data and enforce budgets per operation. */
+export function createInMemorySelectedReader(
+  source: InMemoryReadSource,
+  params: {
+    scope: CompiledSelectedObjectReadScope
+    limits: ObjectReadExecutionLimits
+  },
+  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({
+    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)),
+        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({
+          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,
+  }
+}