Class HonuaOdataEntitySet

constructor

• new HonuaOdataEntitySet(
      options: HonuaOdataEntitySetOptions,
  ): HonuaOdataEntitySet

  Parameters

  • options: HonuaOdataEntitySetOptions

  Returns HonuaOdataEntitySet

ReadonlybasePath

Readonlyclient

ReadonlyentitySet

ReadonlyentitySetName

add

• add<T = Record<string, unknown>>(
      body: Record<string, unknown>,
      options?: HonuaOdataWriteRequestOptions,
  ): Promise<T>

  Insert a row via POST /<entitySet>.

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • body: Record<string, unknown>
  • options: HonuaOdataWriteRequestOptions = {}

  Returns Promise<T>

apply

• apply(
      transformations: string,
      params?: { filter?: string; signal?: AbortSignal },
  ): Promise<HonuaOdataAggregateResult>

  Run an $apply aggregation. The OData server applies the transformation pipeline (aggregate, groupby, filter, compute); the SDK returns the rows unchanged so callers can shape them onto the canonical Result.aggregateRows.

  Parameters

  • transformations: string
  • params: { filter?: string; signal?: AbortSignal } = {}

  Returns Promise<HonuaOdataAggregateResult>

batch

• batch(
      operations: readonly HonuaOdataBatchOperation[],
      options?: HonuaOdataBatchOptions,
  ): Promise<HonuaOdataBatchResult>

  Submit a $batch request using the OData JSON batch format. Multipart/mixed fallback is intentionally not implemented; Honua Server emits both formats but the JSON envelope is sufficient for the canonical surface and avoids the multipart parser.

  atomicity: "all" stamps the same atomicityGroup token on every request so the server runs them in one change-set with rollback on any failure (per OData v4 §11.7.7.3 and Honua Server's ODataBatchHandler, which groups by request.AtomicityGroup). atomicity: "none" (default) leaves the field unset so each request runs independently.

  Parameters

  • operations: readonly HonuaOdataBatchOperation[]
  • options: HonuaOdataBatchOptions = {}

  Returns Promise<HonuaOdataBatchResult>

delete

• delete(key: string, options?: { signal?: AbortSignal }): Promise<void>

  Delete a row via DELETE /<entitySet>(<key>).

  Parameters

  • key: string
  • options: { signal?: AbortSignal } = {}

  Returns Promise<void>

delta

• delta<T = Record<string, unknown>>(
      options?: { signal?: AbortSignal; since?: string },
  ): AsyncGenerator<HonuaOdataDeltaPage<T>, void, undefined>

  $deltatoken-driven change feed. Yields HonuaOdataDeltaPage per server response. The final page carries deltaLink; callers persist the encoded token for the next call to delta({ since }).

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • options: { signal?: AbortSignal; since?: string } = {}

  Returns AsyncGenerator<HonuaOdataDeltaPage<T>, void, undefined>

metadata

• metadata(options?: HonuaMetadataRequestOptions): Promise<HonuaOdataMetadata>

  Fetch (and cache) the $metadata document. The cache is per HonuaOdataEntitySet instance so callers can pin a metadata snapshot to a long-lived Source without re-parsing on every request.

  Parameters

  • options: HonuaMetadataRequestOptions = {}

  Returns Promise<HonuaOdataMetadata>

query

• query<T = Record<string, unknown>>(
      params?: HonuaOdataQueryParams,
  ): Promise<HonuaOdataPage<T>>

  Fetch one page of the entity set.

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • params: HonuaOdataQueryParams = {}

  Returns Promise<HonuaOdataPage<T>>

queryAll

• queryAll<T = Record<string, unknown>>(
      params?: HonuaOdataQueryParams,
  ): Promise<{ rows: readonly T[]; totalCount?: number }>

  Drain server-driven @odata.nextLink pages. When params.top is supplied it is treated as a hard cap on collected rows. Callers that want a lookahead row to detect truncation must add it themselves; the canonical Source.queryAll path does this with top = limit + 1, while ids-only projections enforce their own result cap. Returning top + 1 here would double-count for callers that already added the lookahead, so this helper respects top exactly.

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • params: HonuaOdataQueryParams = {}

  Returns Promise<{ rows: readonly T[]; totalCount?: number }>

queryStream

• queryStream<T = Record<string, unknown>>(
      params?: HonuaOdataQueryParams,
  ): AsyncGenerator<HonuaOdataPage<T>, void, undefined>

  Yield one page per server response. Used by Source.stream().

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • params: HonuaOdataQueryParams = {}

  Returns AsyncGenerator<HonuaOdataPage<T>, void, undefined>

raw

• raw(method: string, path: string, init?: RequestInit): Promise<Response>

  Last-resort raw passthrough — flows through HonuaClient.pipelineFetch so auth headers, retry, timeout, interceptors, telemetry, and normalized error mapping all apply. The returned Response is unconsumed; callers pick .json(), .text(), or .arrayBuffer().

  Parameters

  • method: string
  • path: string
  • init: RequestInit = {}

  Returns Promise<Response>

search

• search<T = Record<string, unknown>>(
      text: string,
      params?: HonuaOdataQueryParams,
  ): Promise<HonuaOdataPage<T>>

  Run a $search full-text query. Returns an HonuaOdataPage so the canonical Result<T> projection is symmetric with query().

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • text: string
  • params: HonuaOdataQueryParams = {}

  Returns Promise<HonuaOdataPage<T>>

update

• update<T = Record<string, unknown>>(
      key: string,
      body: Record<string, unknown>,
      options?: HonuaOdataWriteRequestOptions,
  ): Promise<T | undefined>

  Update a row via PATCH /<entitySet>(<key>). The OData server in Honua Server intentionally does not implement PUT; the SDK issues PATCH with the full canonical body to match a PUT replacement on the canonical surface (documented in docs/protocol-capability-matrix.md under the OData section).

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • key: string
  • body: Record<string, unknown>
  • options: HonuaOdataWriteRequestOptions = {}

  Returns Promise<T | undefined>