@dittolive/ditto 4.7.4 → 4.7.5-rc.2

package/react-native/src/sources/transport-config.ts

@@ -1,430 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-/**
- * Restore a `TransportConfig` from its serializable representation.
- *
- * @internal
- */
-export function transportConfigFromDeserializable(serialized: any): TransportConfig {
-  const peerToPeerJSON = serialized['peer_to_peer']
-  const bluetoothLEJSON = peerToPeerJSON['bluetooth_le']
-  const bluetoothLEEnabled = bluetoothLEJSON['enabled']
-  const awdlJSON = peerToPeerJSON['awdl']
-  const awdlEnabled = awdlJSON['enabled']
-  const lanJSON = peerToPeerJSON['lan']
-  const lanEnabled = lanJSON['enabled']
-  const lanMdnsEnabled = lanJSON['mdns_enabled']
-  const lanMulticastEnabled = lanJSON['multicast_enabled']
-
-  const connectJSON = serialized['connect']
-  const connectTcpServers = connectJSON['tcp_servers']
-  const connectWebsocketURLs = connectJSON['websocket_urls']
-  const connectRetryInterval = connectJSON['retry_interval']
-
-  const listenJSON = serialized['listen']
-  const tcpJSON = listenJSON['tcp']
-  const tcpEnabled = tcpJSON['enabled']
-  const tcpInterfaceIP = tcpJSON['interface_ip']
-  const tcpPort = tcpJSON['port']
-  const httpJSON = listenJSON['http']
-  const httpEnabled = httpJSON['enabled']
-  const httpInterfaceIP = httpJSON['interface_ip']
-  const httpPort = httpJSON['port']
-  const httpStaticContentPath = httpJSON['static_content_path']
-  const httpWebsocketSync = httpJSON['websocket_sync']
-  const httpTLSKeyPath = httpJSON['tls_key_path']
-  const httpTLSCertificatePath = httpJSON['tls_certificate_path']
-
-  const globalJSON = serialized['global']
-  const globalSyncGroup = globalJSON['sync_group']
-  const globalRoutingHint = globalJSON['routing_hint']
-
-  const config = new TransportConfig()
-
-  config.peerToPeer.bluetoothLE.isEnabled = bluetoothLEEnabled
-  config.peerToPeer.awdl.isEnabled = awdlEnabled
-  config.peerToPeer.lan.isEnabled = lanEnabled
-  config.peerToPeer.lan.isMdnsEnabled = lanMdnsEnabled
-  config.peerToPeer.lan.isMulticastEnabled = lanMulticastEnabled
-
-  config.connect.tcpServers = connectTcpServers
-  config.connect.websocketURLs = connectWebsocketURLs
-  config.connect.retryInterval = connectRetryInterval
-
-  config.listen.tcp.isEnabled = tcpEnabled
-  config.listen.tcp.interfaceIP = tcpInterfaceIP
-  config.listen.tcp.port = tcpPort
-  config.listen.http.isEnabled = httpEnabled
-  config.listen.http.interfaceIP = httpInterfaceIP
-  config.listen.http.port = httpPort
-  config.listen.http.staticContentPath = httpStaticContentPath
-  config.listen.http.websocketSync = httpWebsocketSync
-  config.listen.http.tlsKeyPath = httpTLSKeyPath
-  config.listen.http.tlsCertificatePath = httpTLSCertificatePath
-
-  config.global.syncGroup = globalSyncGroup
-  config.global.routingHint = globalRoutingHint
-
-  return config
-}
-
-/**
- * Convert a `TransportConfig` to a serializable representation.
- *
- * This mainly involves converting the `TransportConfig`'s properties to have the expected key names
- * and casing.
- *
- * @internal
- */
-export function transportConfigToSerializable(config: TransportConfig): any {
-  const peerToPeer = config.peerToPeer
-  const connect = config.connect
-  const listen = config.listen
-  const global = config.global
-
-  const serialized = {
-    peer_to_peer: {
-      bluetooth_le: {
-        enabled: peerToPeer.bluetoothLE.isEnabled,
-      },
-      awdl: {
-        enabled: peerToPeer.awdl.isEnabled,
-      },
-      lan: {
-        enabled: peerToPeer.lan.isEnabled,
-        mdns_enabled: peerToPeer.lan.isMdnsEnabled,
-        multicast_enabled: peerToPeer.lan.isMulticastEnabled,
-      },
-    },
-    connect: {
-      tcp_servers: connect.tcpServers,
-      websocket_urls: connect.websocketURLs,
-      retry_interval: connect.retryInterval,
-    },
-    listen: {
-      tcp: {
-        enabled: listen.tcp.isEnabled,
-        interface_ip: listen.tcp.interfaceIP,
-        port: listen.tcp.port,
-      },
-      http: {
-        enabled: listen.http.isEnabled,
-        interface_ip: listen.http.interfaceIP,
-        port: listen.http.port,
-        websocket_sync: listen.http.websocketSync,
-      },
-    },
-    global: {
-      sync_group: global.syncGroup,
-      routing_hint: global.routingHint,
-    },
-  }
-
-  // Only set the optional properties if they are not undefined
-  if (listen.http.staticContentPath) {
-    serialized.listen.http['static_content_path'] = listen.http.staticContentPath
-  }
-  if (listen.http.tlsKeyPath) {
-    serialized.listen.http['tls_key_path'] = listen.http.tlsKeyPath
-  }
-  if (listen.http.tlsCertificatePath) {
-    serialized.listen.http['tls_certificate_path'] = listen.http.tlsCertificatePath
-  }
-
-  return serialized
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for listening for TCP
- * connections.
- */
-export interface TransportConfigListenTCP {
-  isEnabled: boolean
-  interfaceIP: string
-  port: number
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for listening for HTTP,
- * including Websocket, connections.
- */
-export interface TransportConfigListenHTTP {
-  isEnabled: boolean
-  interfaceIP: string
-  port: number
-  staticContentPath?: string
-  websocketSync: boolean
-  tlsKeyPath?: string
-  tlsCertificatePath?: string
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for all P2P transports.
- */
-export interface TransportConfigPeerToPeer {
-  bluetoothLE: { isEnabled: boolean }
-  awdl: { isEnabled: boolean }
-  lan: TransportConfigLan
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for discovering and syncing with peers on LAN.
- */
-export interface TransportConfigLan {
-  isEnabled: boolean
-  isMdnsEnabled: boolean
-  /**
-   * @deprecated Multicast is deprecated. Please use mDNS instead.
-   */
-  isMulticastEnabled: boolean
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for connecting to TCP
- * and Websocket servers.
- */
-export interface TransportConfigConnect {
-  tcpServers: string[]
-  websocketURLs: string[]
-  /**
-   * The retry interval in milliseconds between failed connection attempts. For cross-compatibility, this must be less than 2^32 - 1.
-   */
-  retryInterval: number
-}
-
-/**
- * Part of {@link TransportConfig} type, configuration for listening for
- * incoming TCP and HTTP connections.
- */
-export interface TransportConfigListen {
-  tcp: TransportConfigListenTCP
-  http: TransportConfigListenHTTP
-}
-
-const NO_PREFERRED_ROUTE_HINT = 0
-
-/**
- * Part of {@link TransportConfig} type, settings not associated with any specific type of transport.
- */
-export interface TransportConfigGlobal {
-  /**
-   * The sync group for this device.
-   *
-   * When peer-to-peer transports are enabled, all devices with the same App ID will
-   * normally form an interconnected mesh network. In some situations it may be
-   * desirable to have distinct groups of devices within the same app, so that
-   * connections will only be formed within each group. The `syncGroup` parameter
-   * changes that group membership. A device can only ever be in one sync group, which
-   * by default is group 0. Up to 2^32 distinct group numbers can be used in an app.
-   *
-   * This is an optimization, not a security control. If a connection is created
-   * manually, such as by specifying a `connect` transport, then devices from
-   * different sync groups will still sync as normal. If two groups of devices are
-   * intended to have access to different data sets, this must be enforced using
-   * Ditto's permissions system.
-   */
-  syncGroup: number
-
-  /**
-   * The routing hint for this device.
-   *
-   * A routing hint is a performance tuning option which can improve the performance of
-   * applications that use large collections. Ditto will make a best effort to co-locate data for
-   * the same routing key. In most circumstances, this should substantially improve responsiveness
-   * of the Ditto Cloud.
-   *
-   * The value of the routing hint is application specific - you are free to chose any value.
-   * Devices which you expect to operate on much the same data should be configured to
-   * use the same value.
-   *
-   * A routing hint does not partition data. The value of the routing hint will not affect the data
-   * returned for a query. The routing hint only improves the efficiency of the Cloud's
-   * ability to satisfy the query.
-   */
-  routingHint: number
-}
-
-/**
- * A configuration object specifying which network transports Ditto should
- * use to sync data.
- *
- * A Ditto object comes with a default transport configuration where all
- * available peer-to-peer transports are enabled. You can customize this by
- * copying that or initializing a new `TransportConfig`, adjusting its
- * properties, and supplying it to `setTransportConfig()` on `Ditto`.
- *
- * When you initialize a new `TransportConfig` instance, all  transports are
- * disabled. You must enable each one explicitly.
- *
- * Peer-to-peer transports will automatically discover peers in the vicinity
- * and create connections without any configuration. These are configured via
- * the `peerToPeer` property. To turn each one on, set its `isEnabled` property
- * to `true`.
- *
- * To connect to a peer at a known location, such as a Ditto Big Peer, add its
- * address inside the connect configuration. These are either "host:port"
- * strings for raw TCP sync, or a "wss://…" URL for websockets.
- *
- * The listen configurations are for specific less common data sync scenarios.
- * Please read the documentation on the Ditto website for examples. Incorrect
- * use of listen can result in insecure configurations.
- *
- * **IMPORTANT**: when running in the browser, only the `connect.websocketURLs`
- * part is considered, the rest of the configuration is ignored.
- */
-export class TransportConfig {
-  /** Configuration for peer-to-peer connections. */
-  readonly peerToPeer: TransportConfigPeerToPeer
-
-  /** Configuration for connecting to servers. */
-  readonly connect: TransportConfigConnect
-
-  /** Configuration for listening for incomping connections. */
-  readonly listen: TransportConfigListen
-
-  /** Settings not associated with any specific type of transport. */
-  readonly global: TransportConfigGlobal
-
-  /**
-   * Create a new transport config initialized with the default settings.
-   */
-  constructor() {
-    this.peerToPeer = {
-      bluetoothLE: { isEnabled: false },
-      awdl: { isEnabled: false },
-      lan: { isEnabled: false, isMdnsEnabled: true, isMulticastEnabled: true },
-    }
-
-    this.connect = {
-      tcpServers: [],
-      websocketURLs: [],
-      retryInterval: 5000,
-    }
-
-    this.listen = {
-      tcp: {
-        isEnabled: false,
-        interfaceIP: '[::]',
-        port: 4040,
-      },
-
-      http: {
-        isEnabled: false,
-        interfaceIP: '[::]',
-        port: 80,
-        websocketSync: true,
-      },
-    }
-
-    this.global = {
-      syncGroup: 0,
-      routingHint: NO_PREFERRED_ROUTE_HINT,
-    }
-  }
-
-  /**
-   * Enables all peer-to-peer transports. Throws if receiver is frozen.
-   */
-  setAllPeerToPeerEnabled(enabled: boolean) {
-    this.peerToPeer.bluetoothLE.isEnabled = enabled
-    this.peerToPeer.lan.isEnabled = enabled
-    this.peerToPeer.awdl.isEnabled = enabled
-  }
-
-  /**
-   * Returns `true` if the transport configuration is frozen, otherwise
-   * returns `false`.
-   */
-  get isFrozen(): boolean {
-    return this._isFrozen
-  }
-
-  /**
-   * (Deep) freezes the receiver such that it can't be modified anymore.
-   */
-  freeze(): TransportConfig {
-    if (this.isFrozen) return this
-    this._isFrozen = true
-
-    Object.freeze(this.peerToPeer.bluetoothLE)
-    Object.freeze(this.peerToPeer.awdl)
-    Object.freeze(this.peerToPeer.lan)
-    Object.freeze(this.peerToPeer)
-
-    Object.freeze(this.connect.tcpServers)
-    Object.freeze(this.connect.websocketURLs)
-    Object.freeze(this.connect)
-
-    Object.freeze(this.listen.tcp)
-    Object.freeze(this.listen.http)
-    Object.freeze(this.listen)
-
-    Object.freeze(this.global)
-
-    return this
-  }
-
-  /**
-   * Returns a (deep) copy of the receiver.
-   */
-  copy(): TransportConfig {
-    const copy = new TransportConfig()
-
-    copy.peerToPeer.bluetoothLE.isEnabled = this.peerToPeer.bluetoothLE.isEnabled
-    copy.peerToPeer.awdl.isEnabled = this.peerToPeer.awdl.isEnabled
-    copy.peerToPeer.lan.isEnabled = this.peerToPeer.lan.isEnabled
-    copy.peerToPeer.lan.isMdnsEnabled = this.peerToPeer.lan.isMdnsEnabled
-    copy.peerToPeer.lan.isMulticastEnabled = this.peerToPeer.lan.isMulticastEnabled
-
-    copy.connect.tcpServers = this.connect.tcpServers.slice()
-    copy.connect.websocketURLs = this.connect.websocketURLs.slice()
-    copy.connect.retryInterval = this.connect.retryInterval
-
-    copy.listen.tcp = { ...this.listen.tcp }
-    copy.listen.http = { ...this.listen.http }
-
-    copy.global.syncGroup = this.global.syncGroup
-    copy.global.routingHint = this.global.routingHint
-
-    return copy
-  }
-
-  /**
-   * Returns `true` if passed in TCP configurations are equal, otherwise
-   * returns `false`.
-   */
-  static areListenTCPsEqual(left: TransportConfigListenTCP, right: TransportConfigListenTCP): boolean {
-    /* eslint-disable */
-    // prettier-ignore
-    return (
-      left.isEnabled === right.isEnabled &&
-      left.interfaceIP === right.interfaceIP &&
-      left.port === right.port
-    )
-    /* eslint-enable */
-  }
-
-  /**
-   * Returns `true` if passed in HTTP configurations are equal, otherwise
-   * returns `false`.
-   */
-  static areListenHTTPsEqual(left: TransportConfigListenHTTP, right: TransportConfigListenHTTP): boolean {
-    /* eslint-disable */
-    // prettier-ignore
-    return (
-      left.isEnabled === right.isEnabled &&
-      left.interfaceIP === right.interfaceIP &&
-      left.port === right.port &&
-
-      left.staticContentPath === right.staticContentPath &&
-      left.websocketSync === right.websocketSync &&
-      left.tlsKeyPath === right.tlsKeyPath &&
-      left.tlsCertificatePath === right.tlsCertificatePath
-    )
-    /* eslint-enable */
-  }
-
-  private _isFrozen: boolean = false
-}

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

@@ -1,66 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-import type { DocumentID } from './document-id'
-
-/**
- * The types of an {@link UpdateResult}.
- */
-export type UpdateResultType = 'set' | 'incremented' | 'removed'
-
-/*
- * Provides information about a successful update operation on a document.
- *
- * The update result can be one of the following types:
- *   - `set`
- *   - `removed`
- *   - `incremented`
- */
-export class UpdateResult {
-  /** The update result's type. */
-  readonly type: UpdateResultType
-
-  /** The ID of the document that was updated. */
-  readonly docID: DocumentID
-
-  /** The path to the key in the document that was updated. */
-  readonly path: string
-
-  /**
-   * The associated value for `set` operations. The value will be the new value
-   * at the key path.
-   *
-   * All other types of update results do not have this property set.
-   */
-  readonly value?: any
-
-  /** The associated amount, only set if {@link type} is `incremented`. */
-  readonly amount?: number
-
-  // ----------------------------------------------------------- Internal ------
-
-  /** @internal */
-  static set(docID: DocumentID, path: string, value?: any): UpdateResult {
-    return new UpdateResult('set', docID, path, value, undefined)
-  }
-
-  /** @internal */
-  static incremented(docID: DocumentID, path: string, amount: number): UpdateResult {
-    return new UpdateResult('incremented', docID, path, undefined, amount)
-  }
-
-  /** @internal */
-  static removed(docID: DocumentID, path: string): UpdateResult {
-    return new UpdateResult('removed', docID, path, undefined, undefined)
-  }
-
-  /** @internal */
-  private constructor(type: UpdateResultType, docID: DocumentID, path: string, value?: any, amount?: number) {
-    this.type = type
-    this.docID = docID
-    this.path = path
-    if (value !== undefined) this.value = value
-    if (amount !== undefined) this.amount = amount
-  }
-}

package/react-native/src/sources/update-results-map.ts

@@ -1,65 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-import { DocumentID } from './document-id'
-import { UpdateResult } from './update-result'
-
-import type { DocumentIDValue } from './document-id'
-
-/**
- * Maps a {@link DocumentID} to an array of
- * {@link UpdateResult | update results}. This is the data structure you get
- * when {@link PendingCursorOperation.update | updating} a set of documents
- * with detailed info about the performed updates.
- */
-export class UpdateResultsMap {
-  /**
-   * Returns an array of {@link UpdateResult | update results} associated with
-   * the `documentID` or undefined if not found.
-   */
-  get(documentIDOrValue: DocumentID | DocumentIDValue): UpdateResult[] | undefined {
-    const documentID: DocumentID = documentIDOrValue instanceof DocumentID ? documentIDOrValue : new DocumentID(documentIDOrValue)
-    const documentIDString = documentID.toString()
-    return this.updateResultsByDocumentIDString[documentIDString]
-  }
-
-  /**
-   * Returns all contained keys, i.e. {@link DocumentID | document IDs}
-   * contained in this map.
-   */
-  keys(): DocumentID[] {
-    return this.documentIDs.slice()
-  }
-
-  // ----------------------------------------------------------- Internal ------
-
-  /** @internal */
-  constructor(documentIDs: DocumentID[], updateResultsByDocumentIDString: object) {
-    // REFACTOR: this quick & dirty implementation assumes Document.toString()
-    // to be isomorphic, i.e. id1.equals(id2) <==> id1.toString() == id2.toString(),
-    // which isn't the case in certain edge cases. Fix by implementing a proper
-    // data structure ensuring correctness. One idea would be to use toString()
-    // as a hash value and add a check plus conflict resolution after lookup.
-    // Another idea would be to check for isomorphism for the particular subset
-    // that is passed in and fallback to O(n) linear array search if not.
-
-    const documentIDStrings = documentIDs
-      .map((documentID) => documentID.toString())
-      .sort()
-      .join(', ')
-    const updateResultsKeys = Object.keys(updateResultsByDocumentIDString).sort().join(', ')
-
-    if (documentIDStrings !== updateResultsKeys) {
-      throw new Error("Internal inconsistency, can't construct update results map, documentIDs must all be keys in update results (by document ID string)")
-    }
-
-    this.documentIDs = documentIDs.slice()
-    this.updateResultsByDocumentIDString = { ...updateResultsByDocumentIDString }
-  }
-
-  // ------------------------------------------------------------ Private ------
-
-  private documentIDs: DocumentID[]
-  private updateResultsByDocumentIDString: object
-}

package/react-native/src/sources/websocket-client.ts

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

package/react-native/src/sources/write-transaction-collection.ts

@@ -1,122 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { CBOR } from './cbor'
-import { desugarJSObject } from './augment'
-import { DocumentID } from './document-id'
-import { performAsyncToWorkaroundNonAsyncFFIAPI } from './internal'
-import { WriteTransactionPendingCursorOperation } from './write-transaction-pending-cursor-operation'
-import { WriteTransactionPendingIDSpecificOperation } from './write-transaction-pending-id-specific-operation'
-
-import type { Store } from './store'
-import type { QueryArguments } from './essentials'
-import type { DocumentValue } from './document'
-import type { CollectionInterface, UpsertOptions } from './collection-interface'
-import type { WriteTransaction } from './write-transaction'
-
-/**
- * Represents a collection of a Ditto store that is used in the context of a
- * write transaction.
- *
- * Supports most of a regular {@link Collection | collection}'s functionality
- * but cannot be subscribed or live queried and can not be used to create
- * attachments.
- *
- * Create a `WriteTransactionCollection` by starting a {@link WriteTransaction}
- * and using its `scoped` method.
- */
-export class WriteTransactionCollection implements CollectionInterface {
-  /** The name of the collection. */
-  readonly name: string
-
-  /**
-   * The store this collection belongs to.
-   * @internal
-   */
-  readonly store: Store
-
-  /**
-   * The write transaction within which this collection instance is used.
-   * @internal
-   */
-  readonly writeTransaction: WriteTransaction
-
-  /**
-   * Search for documents in this collection using the provided query string.
-   *
-   * The returned cursor operation can be used to chain operations on the
-   * resulting document set.
-   *
-   * @param query The query to run against the collection.
-   * @param queryArgs These arguments replace placeholders in the provided
-   * query.
-   */
-  find(query: string, queryArgs?: QueryArguments | undefined): WriteTransactionPendingCursorOperation {
-    return new WriteTransactionPendingCursorOperation(query, queryArgs ?? null, this)
-  }
-
-  /**
-   * Convenience method, equivalent to calling {@link find | find()} and passing
-   * the query `"true"`.
-   */
-  findAll(): WriteTransactionPendingCursorOperation {
-    return this.find('true')
-  }
-
-  /**
-   * Generates a {@link WriteTransactionPendingIDSpecificOperation} with the
-   * provided document ID.
-   *
-   * The returned object can be used to find and return the document. It can also be used to update, remove or evict the document.
-   *
-   * @param id The ID of the document to find.
-   */
-  findByID(id: any): WriteTransactionPendingIDSpecificOperation {
-    const documentID: DocumentID = id instanceof DocumentID ? id : new DocumentID(id)
-    return new WriteTransactionPendingIDSpecificOperation(documentID, this)
-  }
-
-  async upsert(value: DocumentValue, options: UpsertOptions = {}): Promise<DocumentID> {
-    const ditto = this.store.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    return ditto.deferCloseAsync(async () => {
-      const writeStrategy = options.writeStrategy ?? 'merge'
-
-      const documentValueJSON = desugarJSObject(value)
-      const documentValueCBOR = CBOR.encode(documentValueJSON)
-
-      const idCBOR = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
-        return await FFI.collectionInsertValue(dittoHandle.deref(), this.name, documentValueCBOR, writeStrategy, this.writeTransaction.writeTransactionPointer)
-      })
-
-      const insertedDocumentId = new DocumentID(idCBOR, true)
-      this.writeTransaction.addResult('inserted', insertedDocumentId, this.name)
-
-      return new DocumentID(idCBOR, true)
-    })
-  }
-
-  /**
-   * See comment in {@link CollectionInterface.findByIDCBOR()}
-   *
-   * @internal */
-  findByIDCBOR(idCBOR: Uint8Array): WriteTransactionPendingIDSpecificOperation {
-    const documentID = new DocumentID(idCBOR, true, true)
-    return new WriteTransactionPendingIDSpecificOperation(documentID, this)
-  }
-
-  /**
-   * This constructor is marked internal because write transaction collections
-   * should be created from a {@link WriteTransaction} instance.
-   *
-   * @internal */
-  constructor(name: string, store: Store, writeTransaction: WriteTransaction) {
-    this.name = name
-    this.store = store
-    this.writeTransaction = writeTransaction
-  }
-}