@sixb/core 0.1.20 → 0.1.22

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

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

@@ -1,9 +1,18 @@
 import type { EffectiveLinkSnapshot, EffectiveObjectSnapshot } from "../../../materialization/model"
 import { hasVectorProfile } from "../../../objects/vectors/query"
+import { uniqueValueKey } from "../../../ontology/unique-values"
+import type {
+  ExactUniqueValueClaim,
+  ExactUniqueValueWrite,
+  UniqueValueRef,
+} from "../../ontology/materializations"
+import { uniqueValueViolation } from "../../ontology/provider-work"
+import type { PreparedUniqueProperty, UniqueValueEntry } from "../../ontology/unique-values"
 import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectReadExecutionLimits } from "../execution-limits"
 import { type LinkBatchKey, type ObjectBatchKey, objectBatchKey } from "../keys"
 import type {
+  CompiledConditionalObjectReadScope,
   CompiledSelectedObjectReadScope,
   CountObjectsInput,
   CountObjectsResult,
@@ -22,6 +31,7 @@ import type {
   QueryObjectsInput,
   QueryObjectsResult,
 } from "../types"
+import { createInMemoryConditionalReader } from "./conditional-reader"
 import {
   compareStrings,
   fullLinkRowKey,
@@ -44,6 +54,13 @@ import { createInMemorySelectedReader } from "./selected-reader"
 export interface InMemoryObjectStorageSnapshot {
   readonly rows: Map<string, Map<string, ObjectRow>>
   readonly links: Map<string, Map<string, ObjectLinkRow>>
+  readonly uniqueValues: Map<string, Map<string, string>>
+  readonly uniqueProperties: Map<string, InMemoryPreparedUniqueProperty>
+}
+
+interface InMemoryPreparedUniqueProperty extends PreparedUniqueProperty {
+  readonly projectId: string
+  readonly preparedAt: string
 }
 
 type VectorReader = (
@@ -84,6 +101,19 @@ interface InMemoryObjectMaterializerAdapter {
     linkId: string,
     visit: (row: ObjectLinkRow) => void
   ): void
+  getUniqueHolder(projectId: string, value: UniqueValueRef): string | null
+  releaseUniqueValue(projectId: string, value: ExactUniqueValueWrite): void
+  /** Throws `UniqueValueViolationError` when another object holds the value. */
+  claimUniqueValue(projectId: string, value: ExactUniqueValueClaim): void
+  listPreparedUniqueProperties(projectId: string): PreparedUniqueProperty[]
+  clearUniqueProperty(projectId: string, objectTypeId: string, propertyId: string): void
+  insertUniqueValues(
+    projectId: string,
+    objectTypeId: string,
+    propertyId: string,
+    entries: readonly UniqueValueEntry[]
+  ): void
+  markUniquePropertyPrepared(input: InMemoryPreparedUniqueProperty): void
 }
 
 const materializerAdapters = new WeakMap<InMemoryObjectStorage, InMemoryObjectMaterializerAdapter>()
@@ -100,6 +130,9 @@ export function getInMemoryObjectMaterializerAdapter(
 export class InMemoryObjectStorage implements ObjectStorage {
   private readonly rows = new Map<string, Map<string, ObjectRow>>()
   private readonly links = new Map<string, Map<string, ObjectLinkRow>>()
+  /** Holder primary ids by value key, for each unique property of a project. */
+  private readonly uniqueValues = new Map<string, Map<string, string>>()
+  private readonly uniqueProperties = new Map<string, InMemoryPreparedUniqueProperty>()
 
   private vectorReader?: VectorReader
 
@@ -130,6 +163,34 @@ export class InMemoryObjectStorage implements ObjectStorage {
           if (row.linkId === linkId) visit(structuredClone(row))
         }
       },
+      getUniqueHolder: (projectId, value) => this.uniqueHolder(projectId, value) ?? null,
+      releaseUniqueValue: (projectId, value) => this.releaseUniqueValue(projectId, value),
+      claimUniqueValue: (projectId, value) => this.claimUniqueValue(projectId, value),
+      listPreparedUniqueProperties: (projectId) =>
+        [...this.uniqueProperties.values()]
+          .filter((prepared) => prepared.projectId === projectId)
+          .map(({ objectTypeId, propertyId, keyKind, keyVersion }) => ({
+            objectTypeId,
+            propertyId,
+            keyKind,
+            keyVersion,
+          })),
+      clearUniqueProperty: (projectId, objectTypeId, propertyId) => {
+        const key = uniquePropertyKey(projectId, objectTypeId, propertyId)
+        this.uniqueValues.delete(key)
+        this.uniqueProperties.delete(key)
+      },
+      insertUniqueValues: (projectId, objectTypeId, propertyId, entries) => {
+        for (const { valueKey, primaryId } of entries) {
+          this.holdUniqueValue(projectId, { objectTypeId, propertyId, valueKey, primaryId })
+        }
+      },
+      markUniquePropertyPrepared: (input) => {
+        this.uniqueProperties.set(
+          uniquePropertyKey(input.projectId, input.objectTypeId, input.propertyId),
+          { ...input }
+        )
+      },
     })
   }
 
@@ -137,6 +198,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
     return {
       rows: cloneObjectBuckets(this.rows),
       links: cloneLinkBuckets(this.links),
+      uniqueValues: cloneUniqueValues(this.uniqueValues),
+      uniqueProperties: new Map(this.uniqueProperties),
     }
   }
 
@@ -150,6 +213,75 @@ export class InMemoryObjectStorage implements ObjectStorage {
     for (const [key, bucket] of cloneLinkBuckets(snapshot.links)) {
       this.links.set(key, bucket)
     }
+
+    this.uniqueValues.clear()
+    for (const [key, holders] of cloneUniqueValues(snapshot.uniqueValues)) {
+      this.uniqueValues.set(key, holders)
+    }
+
+    this.uniqueProperties.clear()
+    for (const [key, prepared] of snapshot.uniqueProperties) {
+      this.uniqueProperties.set(key, prepared)
+    }
+  }
+
+  /** The object holding a unique value, or undefined when none does. */
+  private uniqueHolder(projectId: string, value: UniqueValueRef): string | undefined {
+    return this.uniqueValues
+      .get(uniquePropertyKey(projectId, value.objectTypeId, value.propertyId))
+      ?.get(value.valueKey)
+  }
+
+  private releaseUniqueValue(projectId: string, value: ExactUniqueValueWrite): void {
+    if (this.uniqueHolder(projectId, value) !== value.primaryId) return
+    this.uniqueValues
+      .get(uniquePropertyKey(projectId, value.objectTypeId, value.propertyId))
+      ?.delete(value.valueKey)
+  }
+
+  private claimUniqueValue(projectId: string, claim: ExactUniqueValueClaim): void {
+    this.prepareUniqueProperty(projectId, claim)
+    this.holdUniqueValue(projectId, claim)
+  }
+
+  /**
+   * The in-memory store holds every object, so it builds a property's values the first time a
+   * claim needs them, where SQL stores refuse until `sixb db migrate` built them. A boot
+   * therefore needs no preparation, and a store shared by two ontologies rebuilds what changed.
+   */
+  private prepareUniqueProperty(projectId: string, claim: ExactUniqueValueClaim): void {
+    const key = uniquePropertyKey(projectId, claim.objectTypeId, claim.propertyId)
+    const prepared = this.uniqueProperties.get(key)
+    if (prepared?.keyKind === claim.keyKind && prepared.keyVersion === claim.keyVersion) return
+
+    this.uniqueValues.delete(key)
+    const bucket = this.rows.get(objectRowKey(projectId, claim.objectTypeId))
+    for (const row of bucket?.values() ?? []) {
+      const valueKey = uniqueValueKey(claim.keyKind, row.properties[claim.propertyId])
+      if (valueKey === null) continue
+      this.holdUniqueValue(projectId, { ...claim, valueKey, primaryId: row.primaryId })
+    }
+
+    this.uniqueProperties.set(key, {
+      projectId,
+      objectTypeId: claim.objectTypeId,
+      propertyId: claim.propertyId,
+      keyKind: claim.keyKind,
+      keyVersion: claim.keyVersion,
+      preparedAt: new Date().toISOString(),
+    })
+  }
+
+  private holdUniqueValue(projectId: string, value: ExactUniqueValueWrite): void {
+    const holder = this.uniqueHolder(projectId, value)
+    if (holder !== undefined && holder !== value.primaryId) {
+      throw uniqueValueViolation(value, holder, value.primaryId)
+    }
+
+    const key = uniquePropertyKey(projectId, value.objectTypeId, value.propertyId)
+    const holders = this.uniqueValues.get(key) ?? new Map<string, string>()
+    this.uniqueValues.set(key, holders)
+    holders.set(value.valueKey, value.primaryId)
   }
 
   private getExactObjectRow(
@@ -253,11 +385,21 @@ export class InMemoryObjectStorage implements ObjectStorage {
     )
   }
 
+  createConditionalReadScope(params: {
+    projectId: string
+    scope: CompiledConditionalObjectReadScope
+  }): ObjectReadStorage {
+    return createInMemoryConditionalReader(this.readSource(params.projectId), params.scope, () =>
+      this.queryCapabilities()
+    )
+  }
+
   private readSource(projectId: string): InMemoryReadSource {
     // Keep indexed access live across writes and snapshot restores; do not capture individual buckets.
     return {
       projectId,
       getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
+      allObjects: () => projectObjectRows(this.rows, projectId),
       objectsOfType: (objectTypeId) => [
         ...(this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []),
       ],
@@ -265,7 +407,8 @@ export class InMemoryObjectStorage implements ObjectStorage {
         this.rows.get(objectRowKey(projectId, objectTypeId))?.get(primaryId),
       outgoingLinks: (objectTypeId, primaryId) =>
         this.links.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId))?.values() ?? [],
-      allLinks: () => allLinkRows(this.links),
+      allLinks: () => projectLinkRows(this.links, projectId),
+      uniqueHolder: (value) => this.uniqueHolder(projectId, value),
     }
   }
 
@@ -330,6 +473,14 @@ export class InMemoryObjectStorage implements ObjectStorage {
     return bucket.get(params.primaryId) ?? null
   }
 
+  async getByUniqueValue(
+    params: Parameters<ObjectReadStorage["getByUniqueValue"]>[0]
+  ): Promise<ObjectRow | null> {
+    const holder = this.uniqueHolder(params.projectId, params)
+    if (holder === undefined) return null
+    return this.getByPrimaryId({ ...params, primaryId: holder })
+  }
+
   async selectsObjectProperties(
     params: Parameters<ObjectReadStorage["selectsObjectProperties"]>[0]
   ): Promise<readonly boolean[]> {
@@ -588,6 +739,16 @@ function cloneObjectBuckets(
   return clone
 }
 
+function uniquePropertyKey(projectId: string, objectTypeId: string, propertyId: string): string {
+  return JSON.stringify([projectId, objectTypeId, propertyId])
+}
+
+function cloneUniqueValues(
+  values: Map<string, Map<string, string>>
+): Map<string, Map<string, string>> {
+  return new Map([...values].map(([key, holders]) => [key, new Map(holders)]))
+}
+
 function cloneLinkBuckets(
   links: Map<string, Map<string, ObjectLinkRow>>
 ): Map<string, Map<string, ObjectLinkRow>> {
@@ -601,6 +762,27 @@ function cloneLinkBuckets(
   return clone
 }
 
+function* projectObjectRows(
+  buckets: ReadonlyMap<string, ReadonlyMap<string, ObjectRow>>,
+  projectId: string
+): Iterable<ObjectRow> {
+  const prefix = objectRowProjectPrefix(projectId)
+  for (const [key, bucket] of buckets) {
+    if (key.startsWith(prefix)) yield* bucket.values()
+  }
+}
+
+/** Link buckets are keyed like object buckets, project first. */
+function* projectLinkRows(
+  buckets: ReadonlyMap<string, ReadonlyMap<string, ObjectLinkRow>>,
+  projectId: string
+): Iterable<ObjectLinkRow> {
+  const prefix = objectRowProjectPrefix(projectId)
+  for (const [key, bucket] of buckets) {
+    if (key.startsWith(prefix)) yield* bucket.values()
+  }
+}
+
 function* allLinkRows(
   buckets: ReadonlyMap<string, ReadonlyMap<string, ObjectLinkRow>>
 ): Iterable<ObjectLinkRow> {

package/src/storage/objects/index.ts

@@ -12,12 +12,18 @@ export {
   objectBatchKey,
   objectLinkCursor,
 } from "./keys"
-export { assertObjectReaderProject, compileSelectedObjectReadScope } from "./read-scope"
+export {
+  assertObjectReaderProject,
+  compileConditionalObjectReadScope,
+  compileSelectedObjectReadScope,
+} from "./read-scope"
 export type {
+  CompiledConditionalObjectReadScope,
   CompiledObjectReadObjectSelection,
   CompiledObjectReadRoot,
   CompiledObjectReadStep,
   CompiledSelectedObjectReadScope,
+  ConditionalObjectReadScope,
   CountObjectsInput,
   CountObjectsResult,
   ExistsObjectsInput,
@@ -36,6 +42,7 @@ export type {
   ObjectQueryCapabilityMap,
   ObjectQueryScalarOperation,
   ObjectQueryScalarOperations,
+  ObjectReadCondition,
   ObjectReadLinkDefinitionSelection,
   ObjectReadLinkSelection,
   ObjectReadNode,
@@ -45,6 +52,7 @@ export type {
   ObjectReadStorage,
   ObjectRow,
   ObjectRowLinks,
+  ObjectRowUsers,
   ObjectStorage,
   QueryObjectLinksInput,
   QueryObjectLinksResult,