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

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

@@ -1,101 +0,0 @@
-//
-// 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

@@ -1,72 +0,0 @@
-//
-// 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)
-
-      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

@@ -1,119 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { Ditto } from './ditto'
-import { WriteTransactionCollection } from './write-transaction-collection'
-
-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 {
-  /** @internal */
-  readonly writeTransactionPointer: FFI.Pointer<FFI.FFIWriteTransaction>
-
-  /** @internal */
-  readonly ditto: Ditto
-
-  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

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