@dittolive/ditto 4.5.0 → 4.5.1-experimental.aarch64-linux.1.aarch64

package/react-native/src/sources/query-result-item.ts

@@ -1,116 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-import { CBOR } from './cbor'
-import { Bridge } from './bridge'
-import { Document } from './document'
-
-/**
- * Represents a single match of a DQL query, similar to a “row” in SQL terms.
- * It’s a reference type serving as a “cursor”, allowing for efficient access of
- * the underlying data in various formats.
- *
- * The {@link QueryResultItem.value | value } property is lazily
- * materialized and kept in memory until it goes out of scope. To reduce the
- * memory footprint, structure your code such that items can be processed as a
- * stream, i.e. one by one (or in batches) and
- * {@link QueryResultItem.dematerialize | dematerialize() } them
- * right after use.
- */
-export class QueryResultItem {
-  /**
-   * Returns the content as a materialized object.
-   *
-   * The item's value is
-   * {@link QueryResultItem.materialize | materialized() } on first access
-   * and subsequently on each access after performing
-   * {@link QueryResultItem.dematerialize | dematerialize() }. Once
-   * materialized, the value is kept in memory until explicitly
-   * {@link QueryResultItem.dematerialize | dematerialize() }-ed or the item
-   * goes out of scope.
-   *
-   * Note: This property is very similar to {@link Document.value}.
-   */
-  get value(): any {
-    this.materialize()
-    if (this.materializedValue === undefined) {
-      throw new Error('Internal Error: Materialized value is undefined')
-    }
-    return this.materializedValue
-  }
-
-  /**
-   * Returns `true` if value is currently held materialized in memory, otherwise
-   * returns `false`.
-   *
-   * See {@link QueryResultItem.materialize | materialize()} and
-   * {@link QueryResultItem.dematerialize | dematerialize()}.
-   */
-  get isMaterialized(): boolean {
-    return this.materializedValue !== undefined
-  }
-
-  /**
-   * Loads the CBOR representation of the item's content, decodes it as an
-   * object so it can be accessed via {@link QueryResultItem.value | value }.
-   * Keeps the object in memory until
-   * {@link QueryResultItem.dematerialize | dematerialize() } is called. No-op
-   * if {@link QueryResultItem.value | value } is already materialized.
-   */
-  materialize(): void {
-    if (!this.isMaterialized) {
-      const cborValue = this.cborData()
-      let materializedValue: any
-      try {
-        materializedValue = CBOR.decode(cborValue)
-      } catch (error: any) {
-        throw new Error(`Internal inconsistency: CBOR decoding error while materializing result item: ${error.message}`)
-      }
-
-      if (materializedValue === undefined) {
-        throw new Error('Internal inconsistency: Materialized value is undefined')
-      }
-
-      this.materializedValue = materializedValue
-    }
-  }
-
-  /**
-   * Releases the materialized value from memory. No-op if item is not
-   * materialized.
-   */
-  dematerialize(): void {
-    this.materializedValue = undefined
-  }
-
-  /**
-   * Returns the content of the item as CBOR data.
-   *
-   * Important: The returned CBOR data is not cached, make sure to call this
-   * method once and keep it for as long as needed.
-   */
-  cborData(): Uint8Array {
-    const resultHandle = Bridge.dqlResult.handleFor(this)
-    return FFI.dqlResultCBOR(resultHandle.deref())
-  }
-
-  /**
-   * Returns the content of the item as a JSON string.
-   *
-   * Important: The returned JSON string is not cached, make sure to call this
-   * method once and keep it for as long as needed.
-   */
-  jsonString(): string {
-    const resultHandle = Bridge.dqlResult.handleFor(this)
-    return FFI.dqlResultJSON(resultHandle.deref())
-  }
-
-  // ----------------------------------------------------------- Internal ------
-
-  private materializedValue: any
-
-  /** @internal */
-  constructor() {}
-}

package/react-native/src/sources/query-result.ts

@@ -1,55 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { QueryResultItem } from './query-result-item'
-import { DocumentID } from './document-id'
-
-import type { Store } from './store'
-
-/**
- * Represents results returned when executing a DQL query containing a
- * {@link QueryResultItem} for each match.
- *
- * More info, such as metrics, will be provided in the near future.
- */
-export class QueryResult {
-  /**
-   * Individual items matching a DQL query.
-   */
-  readonly items: QueryResultItem[]
-
-  /**
-   * IDs of documents that were mutated _locally_ by a _mutating_ DQL query
-   * passed to {@link Store.execute | `execute()`}. Empty array if no documents
-   * have been mutated.
-   *
-   * **Note: Query results received from a {@link StoreObserver} never contain
-   * mutated document IDs because a store observer is always registered using a
-   * non-mutating `SELECT` query.
-   *
-   * **Important:** The returned document IDs are not cached, make sure to call
-   * this method once and keep the return value for as long as needed.
-   *
-   * @returns an array of document IDs
-   */
-  mutatedDocumentIDs(): DocumentID[] {
-    const responseHandle = Bridge.dqlResponse.handleFor(this)
-    const affectedCBORIDs = FFI.dqlMutatedDocumentIDs(responseHandle.deref())
-    return affectedCBORIDs.map((id) => new DocumentID(id, true))
-  }
-
-  // ----------------------------------------------------- Internal ------------
-
-  /** @internal */
-  constructor(responsePointer: FFI.Pointer<FFI.FFIDqlResponse>) {
-    if (responsePointer == null) {
-      throw new Error('Internal inconsistency, failed to initialize query result without a response pointer')
-    }
-
-    const results = FFI.dqlResponseResults(responsePointer)
-    this.items = results.map((r) => Bridge.dqlResult.bridge(r))
-  }
-}

package/react-native/src/sources/register.ts

@@ -1,92 +0,0 @@
-//
-// Copyright © 2022 DittoLive Incorporated. All rights reserved.
-//
-
-
-const privateToken = '@ditto.ff82dae89821c5ab822a8b539056bce4'
-
-/**
- * Represents a CRDT register that can be upserted as part of a document or
- * assigned to a property during an update of a document.
- */
-export class Register {
-  /** Returns the value of the register. */
-  get value(): any {
-    return this['@ditto.value']
-  }
-
-  /**
-   * Creates a new Register that can be used as part of a document's content.
-   */
-  constructor(value: any) {
-    this['@ditto.value'] = value
-  }
-
-  /** @internal */
-  static '@ditto.create'(mutableDocument, path, value) {
-    const register = mutableDocument ? new (MutableRegister as any)(value, privateToken) : new Register(value)
-    register['@ditto.mutableDocument'] = mutableDocument
-    register['@ditto.path'] = path
-    register['@ditto.value'] = value
-    return register
-  }
-
-  /** @internal */
-  protected '@ditto.mutableDocument': any
-
-  /** @internal */
-  protected '@ditto.path': any
-
-  /** @internal */
-  protected '@ditto.value': any
-}
-
-// -----------------------------------------------------------------------------
-
-/**
- * Represents a mutable CRDT register that can be set to a specific value when
- * updating a document.
- *
- * This class can't be instantiated directly, it's returned automatically for
- * any register property of a document within an update block via {@link MutableDocumentPath.register}.
- */
-export class MutableRegister extends Register {
-  /** Returns the value of the register. */
-  get value(): any {
-    return super.value
-  }
-
-  /**
-   * Convenience setter, equivalent to {@link set | set()}.
-   */
-  set value(value: any) {
-    this.set(value)
-  }
-
-  /**
-   * Sets the register to the provided value.
-   *
-   * Only valid within the `update` closure of
-   * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
-   * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
-   * otherwise an exception is thrown.
-   */
-  set(value: any) {
-    const mutableDocument = this['@ditto.mutableDocument']
-    const path = this['@ditto.path']
-
-    mutableDocument.at(path)['@ditto.set'](value)
-
-
-    this['@ditto.value'] = value
-  }
-
-  /** @internal */
-  constructor(value: any) {
-    if (arguments[1] === privateToken) {
-      super(value)
-    } else {
-      throw new Error(`MutableRegister constructor is for internal use only.`)
-    }
-  }
-}

package/react-native/src/sources/small-peer-info.ts

@@ -1,176 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { Ditto } from './ditto'
-
-/**
- * Specifies which peers to replicate the small peer info to when enabled.
- *
- * Possible values are:
- *
- * - `LocalPeerOnly`: no replication (default)
- * - `BigPeerOnly`: replicate to the Big Peer
- */
-export type SmallPeerInfoSyncScope = 'LocalPeerOnly' | 'BigPeerOnly'
-
-/**
- * The entrypoint for small peer user info collection. Small peer info consists
- * of information gathered into a system collection on a regular interval and
- * optionally synced to the Big Peer for device dashboard and debugging
- * purposes.
- *
- * An instance of this class is available on each `Ditto` instance via its
- * {@link Ditto.smallPeerInfo | `smallPeerInfo`} property. Instantiating this
- * class directly is not supported.
- */
-export class SmallPeerInfo {
-  /**
-   * Indicates whether small peer info collection is currently enabled, defaults
-   * to `false`.
-   *
-   * **Note**: whether the background ingestion process is enabled or not is a
-   * separate decision to whether this information is allowed to sync to other
-   * peers (including the big peer). This is controlled by
-   * {@link getSyncScope | getSyncScope()} and
-   * {@link setSyncScope | setSyncScope()}.
-   */
-  get isEnabled(): boolean {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferClose(() => {
-      return FFI.dittoSmallPeerInfoGetIsEnabled(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set whether small peer info collection is enabled.
-   *
-   * @throws when set to a non-boolean value.
-   */
-  set isEnabled(newValue: boolean) {
-    if (typeof newValue !== 'boolean') {
-      throw new TypeError(`Expected boolean, got ${typeof newValue}`)
-    }
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      FFI.dittoSmallPeerInfoSetEnabled(dittoHandle.deref(), newValue)
-    })
-  }
-
-  /**
-   * The metadata associated with the small peer info.
-   *
-   * Small peer info metadata is a free-form, user-provided JSON object that
-   * is inserted into the small peer info system document at each collection
-   * interval.
-   */
-  get metadata(): Record<string, any> {
-    return JSON.parse(this.metadataJSONString)
-  }
-
-  /**
-   * Set the metadata associated with the small peer info.
-   *
-   * The metadata must be a JSON-serializable object that conforms to the
-   * following constraints:
-   *
-   * - Must be a JSON object (not an array, string, number, etc.)
-   * - The size when encoded as JSON must be less than 128 KB
-   * - May only be nested up to 2 levels deep
-   *
-   * @example <caption>Valid metadata</caption>
-   * ditto.smallPeerInfo.metadata = {
-   *  "foo": "bar",
-   *  "nested": {
-   *    "inner": "value"
-   *   }
-   * }
-   *
-   * @example <caption>Invalid metadata</caption>
-   * // This is invalid and results in an error.
-   * ditto.smallPeerInfo.metadata = {
-   *   "foo": "bar",
-   *   "nested": {
-   *     "illegal": {
-   *       "inner": "value"
-   *     }
-   *   }
-   * }
-   *
-   * @throws when set to a value that violates any of the constraints listed
-   * above.
-   */
-  set metadata(metadata: Record<string, any>) {
-    this.metadataJSONString = JSON.stringify(metadata)
-  }
-
-  /**
-   * The metadata associated with the small peer info, as a JSON string.
-   */
-  get metadataJSONString(): string {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferClose(() => {
-      return FFI.dittoSmallPeerInfoGetMetadata(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set the metadata associated with the small peer info, as a JSON string.
-   *
-   * @see {@link SmallPeerInfo.metadata | `metadata`} for more information on
-   * valid values.
-   * @throws when set to a value that violates any of the constraints listed in
-   * {@link SmallPeerInfo.metadata | `metadata`}.
-   */
-  set metadataJSONString(metadata: string) {
-    if (typeof metadata !== 'string') {
-      throw new TypeError(`Expected string, got ${typeof metadata}`)
-    }
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      FFI.dittoSmallPeerInfoSetMetadata(dittoHandle.deref(), metadata)
-    })
-  }
-
-  /**
-   * Determines which "kind" of peers the small peer info will be
-   * replicated to.
-   *
-   * Defaults to `LocalPeerOnly`, which means no replication. Set this to
-   * `BigPeerOnly` to replicate collected info to the Big Peer.
-   */
-  async getSyncScope(): Promise<SmallPeerInfoSyncScope> {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferCloseAsync(async () => {
-      return FFI.dittoSmallPeerInfoGetSyncScope(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set the sync scope.
-   *
-   * See {@link getSyncScope} for more information.
-   *
-   * @param syncScope the new sync scope.
-   * @throws when set to a value other than `BigPeerOnly` or `LocalPeerOnly`.
-   */
-  async setSyncScope(syncScope: SmallPeerInfoSyncScope): Promise<void> {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferCloseAsync(async () => {
-      return FFI.dittoSmallPeerInfoSetSyncScope(dittoHandle.deref(), syncScope as any)
-    })
-  }
-
-  // ----------------------------------------------------------- Internal ------
-
-  private ditto: Ditto
-
-  /** @internal */
-  constructor(ditto: Ditto) {
-    this.ditto = ditto
-  }
-}

package/react-native/src/sources/static-tcp-client.ts

@@ -1,6 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-/** @internal */
-export class StaticTCPClient {}

package/react-native/src/sources/store-observer.ts

@@ -1,176 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { CBOR, documentIDReplacer } from './cbor'
-import { DittoError, mapFFIErrors } from './error'
-import { Logger } from './logger'
-import { QueryResult } from './query-result'
-
-import type { Ditto } from './ditto'
-import type { DQLQueryArguments } from './essentials'
-import type { Store } from './store'
-
-/**
- * A store observation handler is called whenever an active store observer
- * receives new results.
- */
-export type StoreObservationHandler = (queryResult: QueryResult) => void
-
-/**
- * A store observation handler is called whenever an active store observer
- * receives new results.
- *
- * Call `signalNext()` to signal that the handler is ready to receive the next
- * callback from the store observer.
- */
-export type StoreObservationHandlerWithSignalNext = (queryResult: QueryResult, signalNext: () => void) => void
-
-/**
- * A store observer invokes a given handler whenever results for its query
- * change.
- *
- * The store observer will remain active until it is {@link cancel | cancelled},
- * or the Ditto instance managing the observer has been
- * {@link Ditto.close | closed}.
- *
- * Create a store observer by calling
- * {@link Store.registerObserver | `ditto.store.registerObserver()`}.
- */
-export class StoreObserver {
-  /**
-   * The Ditto instance this store observer is registered with.
-   */
-  readonly ditto: Ditto
-
-  /**
-   * The query string of the store observer (as passed when registering it).
-   */
-  readonly queryString: string
-
-  /**
-   * The query arguments of the store observer (as passed when registering it).
-   */
-  readonly queryArguments?: Readonly<DQLQueryArguments>
-
-  /**
-   * Convenience property, returns `true` once the store observer has been
-   * cancelled.
-   */
-  get isCancelled(): boolean {
-    return this._isCancelled
-  }
-
-  /**
-   * Cancels the store observer and unregisters it. No-op if the
-   * store observer has already been cancelled.
-   */
-  cancel() {
-    if (this._isCancelled) return
-    this._isCancelled = true
-    this.ditto.store.unregisterObserver(this)
-  }
-
-  // --------------------------- Internal -------------------------------------
-
-  /**
-   * The ID of this observer's live query.
-   *
-   * @internal
-   */
-  readonly liveQueryID: number
-
-  /** @internal */
-  constructor(ditto: Ditto, query: string, queryArguments: DQLQueryArguments | null, observationHandler: StoreObservationHandlerWithSignalNext) {
-    this.queryString = query
-    this.queryArguments = queryArguments ? Object.freeze({ ...queryArguments }) : undefined
-    this.ditto = ditto
-
-    let queryArgumentsCBOR: Uint8Array | null = null
-    if (queryArguments != null) {
-      try {
-        queryArgumentsCBOR = CBOR.encode(queryArguments, documentIDReplacer)
-      } catch (error: any) {
-        throw new DittoError('query/arguments-invalid')
-      }
-    }
-    let storeObserverID: number | undefined
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    this.ditto.deferClose(() => {
-      const weakThis = new WeakRef(this)
-
-      function wrappedObservationHandler(cCBParams: CCallbackParams): void {
-        const strongThis = weakThis.deref()
-        if (strongThis == null) {
-          Logger.debug(`Ignoring change event received by store observer ${storeObserverID} after it was cancelled`)
-          return
-        }
-
-        const response = Bridge.dqlResponse.bridge(cCBParams.query_result, () => new QueryResult(cCBParams.query_result))
-
-        Logger.debug(`Invoking user event handler with new event for store observer ${storeObserverID}`)
-        observationHandler(response, () => {
-          strongThis.signalNext()
-        })
-      }
-
-      const errorContext = {
-        query,
-        queryArguments,
-      }
-
-      mapFFIErrors(
-        () => {
-          storeObserverID = FFI.tryExperimentalRegisterChangeObserver(dittoHandle.deref(), query, queryArgumentsCBOR, wrappedObservationHandler)
-        },
-        undefined,
-        errorContext,
-      )
-    })
-
-    if (storeObserverID == null) {
-      throw new DittoError('internal', 'Internal inconsistency, store observer ID is undefined after registering')
-    }
-
-    this.liveQueryID = storeObserverID
-  }
-
-  // --------------------------- Private --------------------------------------
-
-  /**
-   * `true` when the store observer has been cancelled.
-   *
-   * We mark the store observer as cancelled here as an optimization to avoid a
-   * scan of all store observers in the store whenever the `isCancelled`
-   * property is checked.
-   */
-  private _isCancelled = false
-
-  /**
-   * Signals to Ditto Core that the observer is ready for the next event.
-   */
-  private signalNext() {
-    const ditto = this.ditto
-    if (!ditto || ditto.isClosed) return
-
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    const dittoPointer = dittoHandle.derefOrNull()
-    if (!dittoPointer) return
-
-    if (this.liveQueryID == null) {
-      throw new Error('live query ID is null while signaling ready for next event')
-    }
-
-    return ditto.deferCloseAsync(async () => {
-      Logger.debug(`Signaling availability for live query ${this.liveQueryID}`)
-      await FFI.liveQuerySignalAvailableNext(dittoPointer, this.liveQueryID)
-    })
-  }
-}
-
-type CCallbackParams = {
-  query_result: FFI.Pointer<FFI.FFIDqlResponse>
-}