@sixb/core 0.0.1

package/src/objects/link/authorization.ts

@@ -0,0 +1,26 @@
+/**
+ * The authorization rule for writing a link, in one place because all three link leaves need it.
+ */
+import { type AuthorizationContext, assertAuthorized, assertCanEdit } from "../../authorization"
+
+/**
+ * Assert a principal may create or remove a link.
+ *
+ * `edit` on the **source** type, `view` on the **target**: a link is declared on the source type
+ * (`objectType.links`), and writing one changes the source's edges, not the target's properties.
+ * Requiring `edit` on the target too would mean a clerk needs write access to every customer before
+ * attaching an invoice to one.
+ *
+ * `view` on the target is still required, and for two reasons: it matches how links are *read* —
+ * `canViewLink` already demands `view` on both endpoints — and without it the endpoint-existence
+ * check that follows would answer whether a target the principal cannot see exists.
+ *
+ * Call this *before* any endpoint lookup, for that second reason.
+ */
+export function assertCanWriteLink(
+  ctx: { readonly authorization?: AuthorizationContext },
+  endpoints: { readonly sourceTypeId: string; readonly targetTypeId: string }
+): void {
+  assertCanEdit(ctx, endpoints.sourceTypeId)
+  assertAuthorized(ctx, { kind: "object.view", objectTypeId: endpoints.targetTypeId })
+}

package/src/objects/link/endpoints.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared endpoint existence reads for runtime link batches.
+ *
+ * The Materializer independently refuses a link whose endpoints are not effective. These reads exist
+ * only so batch callers keep receiving the public {@link ObjectNotFoundError} for a missing endpoint
+ * instead of a generic per-item validation error.
+ */
+
+import type { SixbRuntimeContext } from "../../runtime/types"
+import { ObjectNotFoundError } from "../../storage/errors"
+
+export interface LinkEndpointItem {
+  readonly objectType: { readonly id: string }
+  readonly sourceId: string
+  readonly targetTypeId: string
+  readonly targetId: string
+}
+
+export type EndpointExistence = ReadonlySet<string>
+
+export function collectEndpointLookups(
+  items: readonly LinkEndpointItem[]
+): { objectTypeId: string; primaryId: string }[] {
+  const lookups: { objectTypeId: string; primaryId: string }[] = []
+  const seen = new Set<string>()
+
+  for (const item of items) {
+    for (const endpoint of [
+      { objectTypeId: item.objectType.id, primaryId: item.sourceId },
+      { objectTypeId: item.targetTypeId, primaryId: item.targetId },
+    ]) {
+      const key = endpointKey(endpoint.objectTypeId, endpoint.primaryId)
+      if (seen.has(key)) continue
+      seen.add(key)
+      lookups.push(endpoint)
+    }
+  }
+
+  return lookups
+}
+
+export async function loadEndpointExistence(
+  ctx: Pick<SixbRuntimeContext, "projectId" | "storage">,
+  lookups: readonly { objectTypeId: string; primaryId: string }[]
+): Promise<EndpointExistence> {
+  if (lookups.length === 0) return new Set()
+  const rows = await ctx.storage.objects.getByPrimaryIdBatch({
+    projectId: ctx.projectId,
+    items: lookups,
+  })
+  return new Set(rows.keys())
+}
+
+/** Throws {@link ObjectNotFoundError} for the first endpoint the read did not find. */
+export function requireEndpoints(item: LinkEndpointItem, existing: EndpointExistence): void {
+  if (!existing.has(endpointKey(item.objectType.id, item.sourceId))) {
+    throw new ObjectNotFoundError(item.objectType.id, item.sourceId, "Source object not found")
+  }
+  if (!existing.has(endpointKey(item.targetTypeId, item.targetId))) {
+    throw new ObjectNotFoundError(item.targetTypeId, item.targetId, "Target object not found")
+  }
+}
+
+function endpointKey(objectTypeId: string, primaryId: string): string {
+  return `${objectTypeId}:${primaryId}`
+}

package/src/objects/link/index.ts

@@ -0,0 +1,3 @@
+export { removeLink } from "./remove"
+export { upsertLink } from "./upsert"
+export { upsertLinkBatch } from "./upsert-batch"

package/src/objects/link/remove.ts

@@ -0,0 +1,42 @@
+/**
+ * Leaf operation: remove a single link through the ontology Materializer.
+ */
+import { assertLinkTargetType } from "../../ontology/validation"
+import type { ResolvedLinkContext } from "../context"
+import {
+  commitRuntimeOperations,
+  linkDeleteOperation,
+  runtimeOperationId,
+} from "../materializer-adapter"
+import { assertCanWriteLink } from "./authorization"
+
+export async function removeLink(
+  ctx: ResolvedLinkContext,
+  params: {
+    sourceId: string
+    linkId: string
+    targetTypeId: string
+    targetId: string
+  }
+): Promise<void> {
+  const { objectType, linkDefinition, ontology } = ctx
+  const { sourceId, linkId, targetTypeId, targetId } = params
+  assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId })
+
+  assertLinkTargetType(objectType.id, linkId, linkDefinition, targetTypeId, (expected, actual) =>
+    ontology.isValidLinkTarget(expected, actual)
+  )
+
+  // A missing link is a no-op: the delete records managed authority only when an effective edge
+  // exists, so the commit reports `unchanged` instead of failing.
+  await commitRuntimeOperations(ctx, [
+    linkDeleteOperation({
+      id: runtimeOperationId(0),
+      ref: {
+        source: { objectTypeId: objectType.id, primaryId: sourceId },
+        linkId,
+        target: { objectTypeId: targetTypeId, primaryId: targetId },
+      },
+    }),
+  ])
+}

package/src/objects/link/upsert-batch.ts

@@ -0,0 +1,80 @@
+/**
+ * Leaf operation: batch upsert links through the ontology Materializer.
+ *
+ * Takes SixbRuntimeContext (shared infra) + per-item pre-resolved data, because each item can target
+ * a different objectType + linkDefinition. Everything valid is submitted as one ordered
+ * continue-mode commit.
+ */
+
+import { stableJsonStringify } from "../../json"
+import { linkRefKey } from "../../materialization/refs"
+import type { BatchItemResult, SixbRuntimeContext } from "../../runtime/types"
+import type { ResolvedLinkBatchItem } from "../context"
+import {
+  linkUpsertOperation,
+  normalizeRuntimeLink,
+  runtimeOperationId,
+} from "../materializer-adapter"
+import { runRuntimeItemBatch } from "../runtime-batch"
+import { assertCanWriteLink } from "./authorization"
+import { collectEndpointLookups, loadEndpointExistence, requireEndpoints } from "./endpoints"
+
+export async function upsertLinkBatch(
+  ctx: SixbRuntimeContext,
+  items: readonly ResolvedLinkBatchItem[]
+): Promise<readonly BatchItemResult<void>[]> {
+  const { ontology } = ctx
+  if (items.length === 0) return []
+
+  // Every item, up front, and before the endpoint lookup below. Authorization is a precondition, not
+  // a per-item validation: a refused item must not become one failed `BatchItemResult` while the
+  // rest of the batch commits. Asserting inside `plan` would do exactly that, and would also let the
+  // existence lookup answer for targets the principal cannot see.
+  for (const item of items) {
+    assertCanWriteLink(ctx, {
+      sourceTypeId: item.objectType.id,
+      targetTypeId: item.targetTypeId,
+    })
+  }
+
+  const existing = await loadEndpointExistence(ctx, collectEndpointLookups(items))
+  const valueTypesById = ontology.getValueTypesById()
+
+  return runRuntimeItemBatch({
+    ctx,
+    items,
+    plan(item, index) {
+      requireEndpoints(item, existing)
+      const properties = normalizeRuntimeLink({
+        objectType: item.objectType,
+        linkDefinition: item.linkDefinition,
+        linkId: item.linkId,
+        targetTypeId: item.targetTypeId,
+        properties: item.properties,
+        valueTypesById,
+        isValidLinkTarget: (expected, actual) => ontology.isValidLinkTarget(expected, actual),
+      })
+      const ref = {
+        source: { objectTypeId: item.objectType.id, primaryId: item.sourceId },
+        linkId: item.linkId,
+        target: { objectTypeId: item.targetTypeId, primaryId: item.targetId },
+      }
+      const edge = linkRefKey(ref)
+      return {
+        key: edge,
+        // The key is a JSON array, which is unreadable in the error an operator sees on a failed
+        // link projection. Name the edge the way the object path names an object.
+        label: `link '${item.objectType.id}:${item.sourceId}.${item.linkId} -> ${item.targetTypeId}:${item.targetId}'`,
+        fingerprint: stableJsonStringify(properties ?? null),
+        operations: [
+          linkUpsertOperation({
+            id: runtimeOperationId(index),
+            ref,
+            ...(properties !== undefined ? { properties } : {}),
+          }),
+        ],
+      }
+    },
+    value: () => undefined,
+  })
+}

package/src/objects/link/upsert.ts

@@ -0,0 +1,56 @@
+/**
+ * Leaf operation: upsert a single link through the ontology Materializer.
+ */
+import type { ResolvedLinkContext } from "../context"
+import {
+  commitRuntimeOperations,
+  linkUpsertOperation,
+  normalizeRuntimeLink,
+  runtimeOperationId,
+} from "../materializer-adapter"
+import { assertCanWriteLink } from "./authorization"
+import { collectEndpointLookups, loadEndpointExistence, requireEndpoints } from "./endpoints"
+
+export async function upsertLink(
+  ctx: ResolvedLinkContext,
+  params: {
+    sourceId: string
+    linkId: string
+    targetTypeId: string
+    targetId: string
+    properties?: Record<string, unknown>
+  }
+): Promise<void> {
+  const { objectType, linkDefinition, ontology } = ctx
+  const { sourceId, linkId, targetTypeId, targetId, properties } = params
+  assertCanWriteLink(ctx, { sourceTypeId: objectType.id, targetTypeId })
+  const endpoints = { objectType, sourceId, targetTypeId, targetId }
+
+  // Endpoint reads keep the public `ObjectNotFoundError` contract; the Materializer independently
+  // refuses a link whose endpoints are not effective when it commits. This runs before property
+  // normalization so the same input reports the same error class here and through the batch APIs,
+  // which check endpoints first inside `plan`.
+  requireEndpoints(endpoints, await loadEndpointExistence(ctx, collectEndpointLookups([endpoints])))
+
+  const normalizedProperties = normalizeRuntimeLink({
+    objectType,
+    linkDefinition,
+    linkId,
+    targetTypeId,
+    properties,
+    valueTypesById: ontology.getValueTypesById(),
+    isValidLinkTarget: (expected, actual) => ontology.isValidLinkTarget(expected, actual),
+  })
+
+  await commitRuntimeOperations(ctx, [
+    linkUpsertOperation({
+      id: runtimeOperationId(0),
+      ref: {
+        source: { objectTypeId: objectType.id, primaryId: sourceId },
+        linkId,
+        target: { objectTypeId: targetTypeId, primaryId: targetId },
+      },
+      ...(normalizedProperties !== undefined ? { properties: normalizedProperties } : {}),
+    }),
+  ])
+}

package/src/objects/materializer-adapter.ts

@@ -0,0 +1,307 @@
+/**
+ * Runtime translation onto the ontology Materializer.
+ *
+ * Every typed and dynamic object/link mutation lowers to canonical Materializer operations here and
+ * every Materializer result is mapped back to the public runtime shapes. The adapter owns no
+ * ontology semantics: authority classification, effective resolution, validation, and event
+ * construction all happen inside the Materializer's single commit.
+ */
+
+import { randomUUID } from "node:crypto"
+import type { EventActor } from "../events/envelope"
+import type { JsonValue } from "../json"
+import type {
+  EditCommitResult,
+  EffectiveObjectSnapshot,
+  MaterializationItemError,
+  OntologyEditOperation,
+  OntologyLinkRef,
+  OntologyObjectRef,
+  OntologyOperationOutcome,
+} from "../materialization/model"
+import { normalizeJsonProperties } from "../materializer"
+import type { ObjectLink, ValueType } from "../ontology"
+import { OntologyValidationError } from "../ontology/errors"
+import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
+import {
+  assertKnownProperties,
+  assertLinkTargetType,
+  normalizeLinkProperties,
+  normalizeObjectProperties,
+  validateLinkProperties,
+  validateObjectProperties,
+} from "../ontology/validation"
+import { getOntologyMutationRuntime } from "../runtime/ontology-mutations"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type { ObjectRow } from "../storage"
+import { ObjectError } from "./errors"
+
+/** The runtime pieces one commit needs. */
+// `authorization` is here only so a commit can name its actor; it stays optional, so every existing
+// privileged caller still satisfies the type.
+export type RuntimeMaterializerContext = Pick<
+  SixbRuntimeContext,
+  "projectId" | "storage" | "authorization"
+>
+
+/** One caller-supplied batch item, lowered to the operations it contributes. */
+export interface RuntimeBatchGroup {
+  /** Position in the caller's input array; item errors are reported against it. */
+  readonly index: number
+  readonly operations: readonly OntologyEditOperation[]
+}
+
+export interface RuntimeBatchCommit {
+  readonly commit: EditCommitResult | null
+  /** Outcomes per input position, in the order the item's operations were submitted. */
+  readonly outcomes: ReadonlyMap<number, readonly OntologyOperationOutcome[]>
+}
+
+/**
+ * The principal behind a runtime write, when there is one.
+ *
+ * `origin: { kind: "runtime" }` already says a write bypassed an Action; this says who made it.
+ * Absent on a privileged caller (workers, syncs, tests), which is what makes the field's absence
+ * meaningful rather than merely unset: an event with no actor was written by the system itself.
+ *
+ * A `Principal` is an `EventActor` — same literals, no translation.
+ */
+function runtimeActor(ctx: RuntimeMaterializerContext): { readonly actor?: EventActor } {
+  const principal = ctx.authorization?.principal
+  return principal === undefined ? {} : { actor: principal }
+}
+
+/**
+ * Commits ordered operations as one atomic runtime commit.
+ *
+ * A fresh request id per call keeps each runtime mutation its own commit; the Materializer's
+ * idempotency replay then only collapses a retry of the very same request.
+ */
+export async function commitRuntimeOperations(
+  ctx: RuntimeMaterializerContext,
+  operations: readonly OntologyEditOperation[]
+): Promise<EditCommitResult> {
+  const mutations = getOntologyMutationRuntime(ctx)
+  const commit = await mutations.commitEdits({
+    mode: "atomic",
+    source: { kind: "runtime", requestId: randomUUID() },
+    ...runtimeActor(ctx),
+    operations,
+    expectedObjects: [],
+    expectedLinks: [],
+    expectedLinkScopes: [],
+  })
+  return commit
+}
+
+/**
+ * Commits grouped batch operations as one ordered continue-mode transaction.
+ *
+ * Successful items apply against one evolving authority state while semantic failures are recorded
+ * per item. Provider, serialization, and CAS failures still roll the whole transaction back.
+ *
+ * An item that lowers to several operations is declared as one operation group so the Materializer
+ * rolls the whole item back rather than committing the operations that ran before the failure.
+ */
+export async function commitRuntimeBatch(
+  ctx: RuntimeMaterializerContext,
+  groups: readonly RuntimeBatchGroup[]
+): Promise<RuntimeBatchCommit> {
+  const operations = groups.flatMap((group) => group.operations)
+  if (operations.length === 0) {
+    return { commit: null, outcomes: new Map() }
+  }
+
+  const operationGroups = groups
+    .filter((group) => group.operations.length > 1)
+    .map((group) => group.operations.map((operation) => operation.id))
+
+  const mutations = getOntologyMutationRuntime(ctx)
+  const commit = await mutations.commitEdits({
+    mode: "continue",
+    source: { kind: "runtime", requestId: randomUUID() },
+    ...runtimeActor(ctx),
+    operations,
+    ...(operationGroups.length > 0 ? { operationGroups } : {}),
+  })
+
+  const byId = new Map(commit.outcomes.map((outcome) => [outcome.id, outcome]))
+  const outcomes = new Map<number, readonly OntologyOperationOutcome[]>()
+  for (const group of groups) {
+    outcomes.set(
+      group.index,
+      group.operations.map((operation) => requireOutcome(byId, operation.id))
+    )
+  }
+  return { commit, outcomes }
+}
+
+/**
+ * Assigns the canonical operation id for one batch item.
+ *
+ * Ids derive from the caller's original ordinal so outcomes map back to input positions even when
+ * earlier items failed local validation and never reached the Materializer.
+ */
+export function runtimeOperationId(index: number, subOrdinal = 0): string {
+  return subOrdinal === 0 ? `op:${index}` : `op:${index}.${subOrdinal}`
+}
+
+export interface NormalizedRuntimeObject {
+  readonly primaryId: string
+  /** Managed authority values; identity lives in the object ref, never in the properties. */
+  readonly properties: Readonly<Record<string, JsonValue>>
+}
+
+/**
+ * Validates and normalizes one runtime object input at the SDK/service boundary.
+ *
+ * Shape and value-type errors surface here so a batch can report them against the caller's original
+ * position. Authority classification, required-property enforcement, and cardinality stay in the
+ * Materializer, which validates the resolved effective object instead of the request.
+ */
+export function normalizeRuntimeObject(input: {
+  readonly objectType: ObjectTypeWithPropertyTokens
+  readonly primaryPropertyId: string
+  readonly properties: Record<string, unknown>
+  readonly valueTypesById: ReadonlyMap<string, ValueType>
+}): NormalizedRuntimeObject {
+  const { objectType, primaryPropertyId, properties, valueTypesById } = input
+  assertKnownProperties(objectType, properties)
+  validateObjectProperties(objectType, properties, valueTypesById)
+
+  const primaryValue = properties[primaryPropertyId]
+  if (primaryValue === undefined || primaryValue === null) {
+    throw new OntologyValidationError(
+      `[Sixb] Missing primary property '${primaryPropertyId}' in upsert for '${objectType.id}'`
+    )
+  }
+
+  const normalized = normalizeObjectProperties(
+    objectType.properties,
+    properties,
+    valueTypesById,
+    objectType.id
+  )
+  const { [primaryPropertyId]: _identity, ...managed } = normalized
+  return {
+    primaryId: String(primaryValue),
+    properties: normalizeJsonProperties(managed, `${objectType.id} properties`),
+  }
+}
+
+/**
+ * Validates and normalizes one runtime link input.
+ *
+ * Managed link authority carries the complete property set, so required link properties must be
+ * present in the request rather than inherited from the stored edge.
+ */
+export function normalizeRuntimeLink(input: {
+  readonly objectType: ObjectTypeWithPropertyTokens
+  readonly linkDefinition: ObjectLink
+  readonly linkId: string
+  readonly targetTypeId: string
+  readonly properties?: Record<string, unknown>
+  readonly valueTypesById: ReadonlyMap<string, ValueType>
+  readonly isValidLinkTarget: (expected: string | string[], actual: string) => boolean
+}): Readonly<Record<string, JsonValue>> | undefined {
+  const { objectType, linkDefinition, linkId, targetTypeId, properties, valueTypesById } = input
+  assertLinkTargetType(objectType.id, linkId, linkDefinition, targetTypeId, input.isValidLinkTarget)
+  validateLinkProperties(objectType, linkDefinition, properties, undefined, valueTypesById)
+  const normalized = normalizeLinkProperties(objectType, linkDefinition, properties, valueTypesById)
+  if (normalized === undefined) return undefined
+  return normalizeJsonProperties(normalized, `${objectType.id}.${linkId} properties`)
+}
+
+export function objectUpsertOperation(input: {
+  readonly id: string
+  readonly ref: OntologyObjectRef
+  readonly properties: Readonly<Record<string, JsonValue>>
+}): OntologyEditOperation {
+  return { id: input.id, kind: "object.upsert", ref: input.ref, properties: input.properties }
+}
+
+export function objectDeleteOperation(input: {
+  readonly id: string
+  readonly ref: OntologyObjectRef
+}): OntologyEditOperation {
+  return { id: input.id, kind: "object.delete", ref: input.ref }
+}
+
+export function objectRestoreOperation(input: {
+  readonly id: string
+  readonly ref: OntologyObjectRef
+}): OntologyEditOperation {
+  return { id: input.id, kind: "object.restore", ref: input.ref }
+}
+
+export function linkUpsertOperation(input: {
+  readonly id: string
+  readonly ref: OntologyLinkRef
+  readonly properties?: Readonly<Record<string, JsonValue>>
+}): OntologyEditOperation {
+  return {
+    id: input.id,
+    kind: "link.upsert",
+    ref: input.ref,
+    ...(input.properties !== undefined ? { properties: input.properties } : {}),
+  }
+}
+
+export function linkDeleteOperation(input: {
+  readonly id: string
+  readonly ref: OntologyLinkRef
+}): OntologyEditOperation {
+  return { id: input.id, kind: "link.delete", ref: input.ref }
+}
+
+/** Reads the outcomes one batch item produced; the commit returns one per submitted operation. */
+export function requireItemOutcomes(
+  commit: RuntimeBatchCommit,
+  index: number
+): readonly OntologyOperationOutcome[] {
+  const outcomes = commit.outcomes.get(index)
+  if (!outcomes || outcomes.length === 0) {
+    throw new ObjectError(`[Sixb] Materializer returned no outcome for batch item ${index}.`)
+  }
+  return outcomes
+}
+
+/** Reads the effective object an ok outcome produced; runtime object writes always resolve one. */
+export function requireEffectiveObject(outcome: OntologyOperationOutcome): EffectiveObjectSnapshot {
+  if (!outcome.ok || !outcome.object) {
+    throw new ObjectError(`[Sixb] Materializer returned no effective object for '${outcome.id}'.`)
+  }
+  return outcome.object
+}
+
+export function toObjectRow(projectId: string, snapshot: EffectiveObjectSnapshot): ObjectRow {
+  return {
+    projectId,
+    objectTypeId: snapshot.ref.objectTypeId,
+    primaryId: snapshot.ref.primaryId,
+    properties: structuredClone(snapshot.properties) as Record<string, unknown>,
+    createdAt: new Date(snapshot.createdAt),
+    updatedAt: new Date(snapshot.updatedAt),
+    version: snapshot.version,
+    lastCommitId: snapshot.lastCommitId,
+  }
+}
+
+/** Rehydrates a persisted item error into the public runtime error type. */
+export function toItemError(error: MaterializationItemError): Error {
+  switch (error.code) {
+    case "validation":
+      return new OntologyValidationError(error.message)
+  }
+}
+
+function requireOutcome(
+  outcomes: ReadonlyMap<string, OntologyOperationOutcome>,
+  id: string
+): OntologyOperationOutcome {
+  const outcome = outcomes.get(id)
+  if (!outcome) {
+    throw new ObjectError(`[Sixb] Materializer returned no outcome for '${id}'.`)
+  }
+  return outcome
+}

package/src/objects/object/delete.ts

@@ -0,0 +1,47 @@
+/**
+ * Leaf operations: delete and restore a single object through the ontology Materializer.
+ *
+ * Both are thin wrappers over one materializer operation, exactly like `removeLink` — the cascade
+ * over links and the effective-state bookkeeping happen inside the commit.
+ */
+import { assertCanEdit } from "../../authorization"
+import type { ResolvedObjectContext } from "../context"
+import {
+  commitRuntimeOperations,
+  objectDeleteOperation,
+  objectRestoreOperation,
+  runtimeOperationId,
+} from "../materializer-adapter"
+
+/**
+ * Delete the object with this primary id.
+ *
+ * A missing object is a no-op: the delete records managed authority only where effective state
+ * exists, so the commit reports `unchanged` rather than failing. An object a projection also writes
+ * stays hidden even while the projection keeps asserting it — `restore()` is what reveals it again.
+ */
+export async function deleteObject(ctx: ResolvedObjectContext, primaryId: string): Promise<void> {
+  assertCanEdit(ctx, ctx.objectType.id)
+  await commitRuntimeOperations(ctx, [
+    objectDeleteOperation({
+      id: runtimeOperationId(0),
+      ref: { objectTypeId: ctx.objectType.id, primaryId },
+    }),
+  ])
+}
+
+/**
+ * Withdraw a previous delete.
+ *
+ * For an object written only from code this is a no-op — there is nothing left to reveal, so write it
+ * again instead. For an object a projection also writes, it makes the projected state visible again.
+ */
+export async function restoreObject(ctx: ResolvedObjectContext, primaryId: string): Promise<void> {
+  assertCanEdit(ctx, ctx.objectType.id)
+  await commitRuntimeOperations(ctx, [
+    objectRestoreOperation({
+      id: runtimeOperationId(0),
+      ref: { objectTypeId: ctx.objectType.id, primaryId },
+    }),
+  ])
+}

package/src/objects/object/index.ts

@@ -0,0 +1,3 @@
+export { deleteObject, restoreObject } from "./delete"
+export { upsertObject } from "./upsert"
+export { upsertObjectBatch } from "./upsert-batch"