@dittolive/ditto 4.7.4-rc.2 → 4.7.4

package/react-native/src/sources/write-transaction-pending-cursor-operation.ts

@@ -0,0 +1,101 @@
+//
+// Copyright © 2023 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Bridge } from './bridge'
+import { DocumentID } from './document-id'
+import { performAsyncToWorkaroundNonAsyncFFIAPI } from './internal'
+import { BasePendingCursorOperation } from './base-pending-cursor-operation'
+
+import type { QueryArguments, SortDirection } from './essentials'
+import type { Document, MutableDocument } from './document'
+import type { UpdateResultsMap } from './update-results-map'
+import type { Collection } from './collection'
+import type { WriteTransactionCollection } from './write-transaction-collection'
+
+/**
+ * These objects are returned when using `find`-like functionality on
+ * {@link Collection}.
+ *
+ * They allow chaining of further query-related functions to do things like add
+ * a limit to the number of documents you want returned or specify how you want
+ * the documents to be sorted and ordered.
+ *
+ * You can call {@link exec | exec()} on the cursor to get an array of
+ * {@link Document | documents} or you can use methods for updating, removing
+ * or evicting any matching documents.
+ *
+ * Live queries and subscriptions are only available outside of transactions.
+ */
+export class WriteTransactionPendingCursorOperation extends BasePendingCursorOperation {
+  sort(propertyPath: string, direction: SortDirection = 'ascending'): WriteTransactionPendingCursorOperation {
+    return super.sort(propertyPath, direction) as WriteTransactionPendingCursorOperation
+  }
+
+  offset(offset: number): WriteTransactionPendingCursorOperation {
+    return super.offset(offset) as WriteTransactionPendingCursorOperation
+  }
+
+  limit(limit: number): WriteTransactionPendingCursorOperation {
+    return super.limit(limit) as WriteTransactionPendingCursorOperation
+  }
+
+  async remove(): Promise<DocumentID[]> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const query = this.query
+      const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+
+      const documentsX = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => FFI.collectionRemoveQueryStr(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset))
+      const results: DocumentID[] = documentsX.map((idCBOR: Uint8Array) => {
+        return new DocumentID(idCBOR, true)
+      })
+
+      results.forEach((documentId) => {
+        transaction.addResult('removed', documentId, this.collection.name)
+      })
+
+      return results
+    })
+  }
+
+  async evict(): Promise<DocumentID[]> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const query = this.query
+      const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+
+      const documentsX = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => FFI.collectionEvictQueryStr(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset))
+
+      const results: DocumentID[] = documentsX.map((idCBOR: Uint8Array) => {
+        return new DocumentID(idCBOR, true)
+      })
+
+      results.forEach((documentId) => {
+        transaction.addResult('evicted', documentId, this.collection.name)
+      })
+
+      return results
+    })
+  }
+
+  async update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap> {
+    const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+    const results = await super.updateWithTransaction(closure, transaction.writeTransactionPointer)
+    results.keys().forEach((documentId) => {
+      transaction.addResult('updated', documentId, this.collection.name)
+    })
+    return results
+  }
+
+  // ----------------------------------------------------------- Internal ------
+
+  /** @internal */
+  constructor(query: string, queryArgs: QueryArguments | null, collection: WriteTransactionCollection) {
+    super(query, queryArgs, collection)
+  }
+}

package/react-native/src/sources/write-transaction-pending-id-specific-operation.ts

@@ -0,0 +1,74 @@
+//
+// Copyright © 2023 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Bridge } from './bridge'
+import { MutableDocument } from './document'
+import { performAsyncToWorkaroundNonAsyncFFIAPI } from './internal'
+import { BasePendingIDSpecificOperation } from './base-pending-id-specific-operation'
+
+import type { UpdateResult } from './update-result'
+import type { DocumentID } from './document-id'
+import type { WriteTransactionCollection } from './write-transaction-collection'
+
+export class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSpecificOperation {
+  async remove(): Promise<boolean> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+      const result = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => FFI.collectionRemove(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, this.documentIDCBOR))
+
+      transaction.addResult('removed', this.documentID, this.collection.name)
+      return result
+    })
+  }
+
+  async evict(): Promise<boolean> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+      const result = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => await FFI.collectionEvict(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, this.documentIDCBOR))
+
+      transaction.addResult('evicted', this.documentID, this.collection.name)
+      return result
+    })
+  }
+
+  async update(closure: (document: MutableDocument) => void): Promise<UpdateResult[]> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const transaction = (this.collection as WriteTransactionCollection).writeTransaction
+
+      const readTransactionX = await FFI.readTransaction(dittoHandle.deref())
+      const documentX = await FFI.collectionGet(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, readTransactionX)
+      FFI.readTransactionFree(readTransactionX)
+
+      if (!documentX) throw new Error(`Can't update, document with ID '${this.documentID.toString()}' not found in collection named '${this.collection.name}'`)
+
+      const mutableDocument = Bridge.mutableDocument.bridge(documentX, () => new MutableDocument())
+      closure(mutableDocument)
+
+      // Ownership is transferred back to the FFI layer via collectionUpdate(),
+      // we therefore need to explicitly unregister the instance.
+      Bridge.mutableDocument.unregister(mutableDocument)
+
+      await FFI.collectionUpdate(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, documentX)
+
+      transaction.addResult('updated', this.documentID, this.collection.name)
+
+      return mutableDocument['@ditto.updateResults'].slice()
+    })
+  }
+
+  // ----------------------------------------------------------- Internal ------
+
+  /** @internal */
+  constructor(documentID: DocumentID, collection: WriteTransactionCollection) {
+    super(documentID, collection)
+  }
+}

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

@@ -0,0 +1,121 @@
+//
+// Copyright © 2023 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Bridge } from './bridge'
+import { WriteTransactionCollection } from './write-transaction-collection'
+
+import type { Ditto } from './ditto'
+import type { DocumentID } from './document-id'
+import type { Store } from './store'
+
+/**
+ * Provides information about the result of an operation on a document that was
+ * part of a write transaction.
+ *
+ * The write transaction result can be one of the following types:
+ *
+ * - `inserted`
+ * - `removed`
+ * - `evicted`
+ * - `updated`
+ *
+ * Please note that an `upsert` operation always results in the result type
+ * `inserted`, regardless of whether it resulted in an update or insert.
+ */
+export interface WriteTransactionResult {
+  type: 'inserted' | 'removed' | 'evicted' | 'updated'
+  docID: DocumentID
+  collectionName: string
+}
+
+/**
+ * Perform writes in a transaction.
+ *
+ * Create a write transaction using {@link Store.write | ditto.store.write}.
+ */
+export class WriteTransaction {
+  // Pointer to internal C transaction through FFI.
+  /** @internal */
+  readonly writeTransactionPointer: FFI.Pointer<FFI.FFIWriteTransaction>
+
+  /** @internal */
+  readonly ditto: Ditto
+
+  // All documents affected by writes in this transaction are collected here.
+  readonly results: WriteTransactionResult[]
+
+  /**
+   * Initialise a write transaction given a Ditto instance.
+   *
+   * This is not implemented as a constructor in order to be able to use FFI
+   * async functions. Users start transactions through {@link Store.write}.
+   *
+   * @param ditto an instance of Ditto
+   * @internal
+   */
+  static async init(ditto: Ditto) {
+    return ditto.deferCloseAsync(async () => {
+      const dittoHandle = Bridge.ditto.handleFor(ditto)
+      const writeTransactionPointer = await FFI.writeTransaction(dittoHandle.deref())
+      return new WriteTransaction(ditto, writeTransactionPointer)
+    })
+  }
+
+  /**
+   * Creates a transaction-specific
+   * {@link WriteTransactionCollection | collection} object that will ensure
+   * that operations called on it are all in the context of the collection name
+   * provided to this function. You can create many
+   * {@link WriteTransactionCollection | collection} objects per
+   * {@link WriteTransaction} object.
+   * */
+  scoped(toCollectionNamed: string): WriteTransactionCollection {
+    if (typeof toCollectionNamed !== 'string') {
+      throw new Error('Collection name must be a string')
+    }
+    return new WriteTransactionCollection(toCollectionNamed, this.ditto.store, this)
+  }
+
+  // ----------------------------------------------------------- Internal ------
+
+  /** @internal */
+  async commit(): Promise<void> {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      return FFI.writeTransactionCommit(dittoHandle.deref(), this.writeTransactionPointer)
+    })
+  }
+
+  /** @internal */
+  async rollback(): Promise<void> {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      return FFI.writeTransactionRollback(dittoHandle.deref(), this.writeTransactionPointer)
+    })
+  }
+
+  /**
+   * Adds an entry to the list of results that is returned at the end of a
+   * transaction.
+   *
+   * @internal */
+  addResult(type: WriteTransactionResult['type'], docID: DocumentID, collectionName: string) {
+    this.results.push({
+      type,
+      docID,
+      collectionName,
+    })
+  }
+
+  /** @internal */
+  constructor(ditto: Ditto, cTransaction: FFI.Pointer<FFI.FFIWriteTransaction>) {
+    this.writeTransactionPointer = cTransaction
+    this.ditto = ditto
+    this.results = []
+  }
+}

package/react-native.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './react-native/android',
+      },
+    },
+  },
+};