@powersync/common 1.51.0 → 1.53.0

package/src/client/sync/stream/JsonValue.ts

@@ -0,0 +1,8 @@
+type JSONValue = string | number | boolean | null | undefined | JSONObject | JSONArray;
+
+interface JSONObject {
+  [key: string]: JSONValue;
+}
+type JSONArray = JSONValue[];
+
+export type StreamingSyncRequestParameterType = JSONValue;

package/src/client/sync/stream/core-instruction.ts

@@ -1,4 +1,3 @@
-import { StreamingSyncRequest } from './streaming-sync-types.js';
 import * as sync_status from '../../../db/crud/SyncStatus.js';
 import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
 
@@ -6,12 +5,19 @@ import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
  * An internal instruction emitted by the sync client in the core extension in response to the JS
  * SDK passing sync data into the extension.
  */
-export type Instruction =
+export type Instruction = InterruptingInstruction | NonInterruptingInstruction;
+
+export type InterruptingInstruction =
+  | { EstablishSyncStream: EstablishSyncStream }
+  | { CloseSyncStream: { hide_disconnect: boolean } };
+
+/**
+ * An {@link Instruction} that doesn't start or stop a sync iteration.
+ */
+export type NonInterruptingInstruction =
   | { LogLine: LogLine }
   | { UpdateSyncStatus: UpdateSyncStatus }
-  | { EstablishSyncStream: EstablishSyncStream }
   | { FetchCredentials: FetchCredentials }
-  | { CloseSyncStream: { hide_disconnect: boolean } }
   | { FlushFileSystem: any }
   | { DidCompleteSync: any };
 
@@ -21,7 +27,7 @@ export interface LogLine {
 }
 
 export interface EstablishSyncStream {
-  request: StreamingSyncRequest;
+  request: unknown;
 }
 
 export interface UpdateSyncStatus {
@@ -97,3 +103,7 @@ export function coreStatusToJs(status: CoreSyncStatus): sync_status.SyncStatusOp
     priorityStatusEntries: status.priority_status.map(priorityToJs)
   };
 }
+
+export function isInterruptingInstruction(instruction: Instruction): instruction is InterruptingInstruction {
+  return 'EstablishSyncStream' in instruction || 'CloseSyncStream' in instruction;
+}

package/src/db/DBAdapter.ts

@@ -69,7 +69,17 @@ export interface SqlExecutor {
   executeBatch: (query: string, params?: any[][]) => Promise<QueryResult>;
 }
 
-export interface LockContext extends SqlExecutor, DBGetUtils {}
+export interface LockContext extends SqlExecutor, DBGetUtils {
+  /**
+   * How the connection has been opened.
+   *
+   * `writer` indicates that the lock context is capable of writing to the database.
+   * `queryOnly` indicates that the lock context has been opened in a readwrite mode, but a `PRAGMA query_only = TRUE`
+   * disabled writes.
+   * `readOnly` indicates that the lock context has been opened by passing `SQLITE_OPEN_READONLY` to `sqlite3_open_v2`.
+   */
+  connectionType?: 'writer' | 'queryOnly' | 'readOnly';
+}
 
 /**
  * Implements {@link DBGetUtils} on a {@link SqlRunner}.
@@ -263,8 +273,16 @@ class TransactionImplementation extends DBGetUtilsDefaultMixin(BaseTransaction)
   static async runWith<T>(ctx: LockContext, fn: (tx: Transaction) => Promise<T>): Promise<T> {
     let tx = new TransactionImplementation(ctx);
 
+    // For write transactions, use BEGIN IMMEDIATE to immediately obtain a write lock on the database (instead of doing
+    // that on the first statement). If we have a genuine read-only connection, we also use BEGIN IMMEDIATE there: In
+    // WAL mode, that ensures we pin the current state of the database (instead of the state at the first statement in
+    // the transaction). But if we have a "fake" read-only connection implemented through `pragma query_only = true`, we
+    // can't use this trick because it would attempt to lock the connection. So there, we use a regular `BEGIN`
+    // statement.
+    const useBeginImmediate = ctx.connectionType != 'queryOnly';
+
     try {
-      await ctx.execute('BEGIN IMMEDIATE');
+      await ctx.execute(useBeginImmediate ? 'BEGIN IMMEDIATE' : 'BEGIN');
 
       const result = await fn(tx);
       await tx.commit();

package/src/db/crud/SyncStatus.ts

@@ -39,6 +39,9 @@ export type SyncStatusOptions = {
   lastSyncedAt?: Date;
   hasSynced?: boolean;
   priorityStatusEntries?: SyncPriorityStatus[];
+  /**
+   * @deprecated This field is no longer set, since {@link SyncClientImplementation.RUST} is the only option.
+   */
   clientImplementation?: SyncClientImplementation;
 };
 
@@ -122,8 +125,6 @@ export class SyncStatus {
    *
    * This returns null when the database is currently being opened and we don't have reliable information about all
    * included streams yet.
-   *
-   * @experimental Sync streams are currently in alpha.
    */
   get syncStreams(): SyncStreamStatus[] | undefined {
     return this.options.dataFlow?.internalStreamSubscriptions?.map((core) => new SyncStreamStatusView(this, core));
@@ -131,8 +132,6 @@ export class SyncStatus {
 
   /**
    * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
-   *
-   * @experimental Sync streams are currently in alpha.
    */
   forStream(stream: SyncStreamDescription): SyncStreamStatus | undefined {
     const asJson = JSON.stringify(stream.parameters);
@@ -262,7 +261,7 @@ export class SyncStatus {
   }
 
   /**
-   * Not all errors are serializable over a MessagePort. E.g. some `DomExceptions` fail to be passed across workers. 
+   * Not all errors are serializable over a MessagePort. E.g. some `DomExceptions` fail to be passed across workers.
    * This explicitly serializes errors in the SyncStatus.
    */
   protected serializeError(error?: Error) {

package/src/db/schema/RawTable.ts

@@ -9,11 +9,6 @@ import { TableOrRawTableOptions } from './Table.js';
  * To collect local writes to raw tables with PowerSync, custom triggers are required. See
  * {@link https://docs.powersync.com/usage/use-case-examples/raw-tables the documentation} for details and an example on
  * using raw tables.
- *
- * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
- *
- * @experimental Please note that this feature is experimental at the moment, and not covered by PowerSync semver or
- * stability guarantees.
  */
 export type RawTableType = RawTableTypeWithStatements | InferredRawTableType;
 

package/src/db/schema/Schema.ts

@@ -51,10 +51,8 @@ export class Schema<S extends SchemaType = SchemaType> {
    * developer instead of automatically by PowerSync.
    * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
    * using client-side table and column constraints.
-   * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
    *
    * @param tables An object of (table name, raw table definition) entries.
-   * @experimental Note that the raw tables API is still experimental and may change in the future.
    */
   withRawTables(tables: Record<string, RawTableType>) {
     for (const [name, rawTableDefinition] of Object.entries(tables)) {

package/src/index.ts

@@ -20,14 +20,10 @@ export * from './client/sync/bucket/BucketStorageAdapter.js';
 export * from './client/sync/bucket/CrudBatch.js';
 export { CrudEntry, OpId, UpdateType } from './client/sync/bucket/CrudEntry.js';
 export * from './client/sync/bucket/CrudTransaction.js';
-export * from './client/sync/bucket/OplogEntry.js';
-export * from './client/sync/bucket/OpType.js';
 export * from './client/sync/bucket/SqliteBucketStorage.js';
-export * from './client/sync/bucket/SyncDataBatch.js';
-export * from './client/sync/bucket/SyncDataBucket.js';
 export * from './client/sync/stream/AbstractRemote.js';
 export * from './client/sync/stream/AbstractStreamingSyncImplementation.js';
-export * from './client/sync/stream/streaming-sync-types.js';
+export * from './client/sync/stream/JsonValue.js';
 export * from './client/sync/sync-streams.js';
 
 export * from './client/ConnectionManager.js';
@@ -59,9 +55,9 @@ export * from './client/watched/WatchedQuery.js';
 export * from './utils/AbortOperation.js';
 export * from './utils/BaseObserver.js';
 export * from './utils/ControlledExecutor.js';
-export * from './utils/DataStream.js';
 export * from './utils/Logger.js';
 export * from './utils/mutex.js';
 export * from './utils/parseQuery.js';
+export type { SimpleAsyncIterator } from './utils/stream_transform.js';
 
 export * from './types/types.js';

package/src/utils/async.ts

@@ -1,14 +1,3 @@
-/**
- * A ponyfill for `Symbol.asyncIterator` that is compatible with the
- * [recommended polyfill](https://github.com/Azure/azure-sdk-for-js/blob/%40azure/core-asynciterator-polyfill_1.0.2/sdk/core/core-asynciterator-polyfill/src/index.ts#L4-L6)
- * we recommend for React Native.
- *
- * As long as we use this symbol (instead of `for await` and `async *`) in this package, we can be compatible with async
- * iterators without requiring them.
- */
-export const symbolAsyncIterator: typeof Symbol.asyncIterator =
-  Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
-
 /**
  * Throttle a function to be called at most once every "wait" milliseconds,
  * on the trailing edge.

package/src/utils/stream_transform.ts

@@ -0,0 +1,252 @@
+/**
+ * An async iterator that can't be cancelled.
+ *
+ * To keep data flow simple, we always pass an explicit cancellation token when subscribing to async streams. Once the
+ * {@link AbortSignal} aborts, iterators are supposed to clean up and then emit a final `{done: true}` event. This means
+ * that there's no way to distinguish between streams that have completed normally and streams that have been cancelled,
+ * but that is acceptable for our uses of this.
+ */
+export type SimpleAsyncIterator<T> = Pick<AsyncIterator<T>, 'next'>;
+
+export const doneResult: IteratorReturnResult<any> = { done: true, value: undefined };
+
+export function valueResult<T>(value: T) {
+  return { done: false, value };
+}
+
+/**
+ * A variant of {@link Array.map} for async iterators.
+ */
+export function map<T1, T2>(source: SimpleAsyncIterator<T1>, map: (source: T1) => T2): SimpleAsyncIterator<T2> {
+  return {
+    next: async () => {
+      const value = await source.next();
+      if (value.done) {
+        return value;
+      } else {
+        return { value: map(value.value) };
+      }
+    }
+  };
+}
+
+export interface InjectableIterator<T> extends SimpleAsyncIterator<T> {
+  inject(event: T): void;
+}
+
+/**
+ * Expands a source async iterator by allowing to inject events asynchronously.
+ *
+ * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
+ * events are dropped once the main iterator completes, but are otherwise forwarded.
+ *
+ * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
+ * in response to a `next()` call from downstream if no pending injected events can be dispatched.
+ */
+export function injectable<T>(source: SimpleAsyncIterator<T>): InjectableIterator<T> {
+  type Waiter = { resolve: (t: IteratorResult<T>) => void; reject: (e: unknown) => void };
+
+  let sourceIsDone = false;
+  let waiter: Waiter | undefined = undefined; // An active, waiting next() call.
+  // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
+  let pendingSourceEvent: ((w: Waiter) => void) | null = null;
+
+  let pendingInjectedEvents: T[] = [];
+
+  const consumeWaiter = () => {
+    const pending = waiter;
+    waiter = undefined;
+    return pending;
+  };
+
+  const fetchFromSource = () => {
+    const resolveWaiter = (propagate: (w: Waiter) => void) => {
+      const active = consumeWaiter();
+      if (active) {
+        propagate(active);
+      } else {
+        pendingSourceEvent = propagate;
+      }
+    };
+
+    const nextFromSource = source.next();
+    nextFromSource.then(
+      (value) => {
+        sourceIsDone = value.done == true;
+        resolveWaiter((w) => w.resolve(value));
+      },
+      (error) => {
+        resolveWaiter((w) => w.reject(error));
+      }
+    );
+  };
+
+  return {
+    next: () => {
+      return new Promise((resolve, reject) => {
+        // First priority: Dispatch ready upstream events.
+        if (sourceIsDone) {
+          return resolve(doneResult);
+        }
+        if (pendingSourceEvent) {
+          pendingSourceEvent({ resolve, reject });
+          pendingSourceEvent = null;
+          return;
+        }
+
+        // Second priority: Dispatch injected events
+        if (pendingInjectedEvents.length) {
+          return resolve(valueResult(pendingInjectedEvents.shift()!));
+        }
+
+        // Nothing pending? Fetch from source
+        waiter = { resolve, reject };
+        return fetchFromSource();
+      });
+    },
+    inject: (event) => {
+      const pending = consumeWaiter();
+      if (pending != null) {
+        pending.resolve(valueResult(event));
+      } else {
+        pendingInjectedEvents.push(event);
+      }
+    }
+  };
+}
+
+/**
+ * Splits a byte stream at line endings, emitting each line as a string.
+ */
+export function extractJsonLines(
+  source: SimpleAsyncIterator<Uint8Array>,
+  decoder: TextDecoder
+): SimpleAsyncIterator<string> {
+  let buffer = '';
+  const pendingLines: string[] = [];
+  let isFinalEvent = false;
+
+  return {
+    next: async () => {
+      while (true) {
+        if (isFinalEvent) {
+          return doneResult;
+        }
+
+        {
+          const first = pendingLines.shift();
+          if (first) {
+            return { done: false, value: first };
+          }
+        }
+
+        const { done, value } = await source.next();
+        if (done) {
+          const remaining = buffer.trim();
+          if (remaining.length != 0) {
+            isFinalEvent = true;
+            return { done: false, value: remaining };
+          }
+
+          return doneResult;
+        }
+
+        const data = decoder.decode(value, { stream: true });
+        buffer += data;
+
+        const lines = buffer.split('\n');
+        for (let i = 0; i < lines.length - 1; i++) {
+          const l = lines[i].trim();
+          if (l.length > 0) {
+            pendingLines.push(l);
+          }
+        }
+
+        buffer = lines[lines.length - 1];
+      }
+    }
+  };
+}
+
+/**
+ * Splits a concatenated stream of BSON objects by emitting individual objects.
+ */
+export function extractBsonObjects(source: SimpleAsyncIterator<Uint8Array>): SimpleAsyncIterator<Uint8Array> {
+  // Fully read but not emitted yet.
+  const completedObjects: Uint8Array[] = [];
+
+  // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
+  let isDone = false;
+
+  const lengthBuffer = new DataView(new ArrayBuffer(4));
+  let objectBody: Uint8Array | null = null;
+  // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
+  // If we're consuming a document, the bytes remaining.
+  let remainingLength = 4;
+
+  return {
+    async next(): Promise<IteratorResult<Uint8Array>> {
+      while (true) {
+        // Before fetching new data from upstream, return completed objects.
+        if (completedObjects.length) {
+          return valueResult(completedObjects.shift()!);
+        }
+        if (isDone) {
+          return doneResult;
+        }
+
+        const upstreamEvent = await source.next();
+        if (upstreamEvent.done) {
+          isDone = true;
+          if (objectBody || remainingLength != 4) {
+            throw new Error('illegal end of stream in BSON object');
+          }
+          return doneResult;
+        }
+
+        const chunk = upstreamEvent.value;
+        for (let i = 0; i < chunk.length; ) {
+          const availableInData = chunk.length - i;
+
+          if (objectBody) {
+            // We're in the middle of reading a BSON document.
+            const bytesToRead = Math.min(availableInData, remainingLength);
+            const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
+            objectBody.set(copySource, objectBody.length - remainingLength);
+            i += bytesToRead;
+            remainingLength -= bytesToRead;
+
+            if (remainingLength == 0) {
+              completedObjects.push(objectBody);
+
+              // Prepare to read another document, starting with its length
+              objectBody = null;
+              remainingLength = 4;
+            }
+          } else {
+            // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
+            const bytesToRead = Math.min(availableInData, remainingLength);
+            for (let j = 0; j < bytesToRead; j++) {
+              lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
+            }
+            i += bytesToRead;
+            remainingLength -= bytesToRead;
+
+            if (remainingLength == 0) {
+              // Transition from reading length header to reading document. Subtracting 4 because the length of the
+              // header is included in length.
+              const length = lengthBuffer.getInt32(0, true /* little endian */);
+              remainingLength = length - 4;
+              if (remainingLength < 1) {
+                throw new Error(`invalid length for bson: ${length}`);
+              }
+
+              objectBody = new Uint8Array(length);
+              new DataView(objectBody.buffer).setInt32(0, length, true);
+            }
+          }
+        }
+      }
+    }
+  };
+}

package/lib/client/sync/bucket/OpType.d.ts

@@ -1,16 +0,0 @@
-export declare enum OpTypeEnum {
-    CLEAR = 1,
-    MOVE = 2,
-    PUT = 3,
-    REMOVE = 4
-}
-export type OpTypeJSON = string;
-/**
- * Used internally for sync buckets.
- */
-export declare class OpType {
-    value: OpTypeEnum;
-    static fromJSON(jsonValue: OpTypeJSON): OpType;
-    constructor(value: OpTypeEnum);
-    toJSON(): string;
-}

package/lib/client/sync/bucket/OpType.js

@@ -1,23 +0,0 @@
-export var OpTypeEnum;
-(function (OpTypeEnum) {
-    OpTypeEnum[OpTypeEnum["CLEAR"] = 1] = "CLEAR";
-    OpTypeEnum[OpTypeEnum["MOVE"] = 2] = "MOVE";
-    OpTypeEnum[OpTypeEnum["PUT"] = 3] = "PUT";
-    OpTypeEnum[OpTypeEnum["REMOVE"] = 4] = "REMOVE";
-})(OpTypeEnum || (OpTypeEnum = {}));
-/**
- * Used internally for sync buckets.
- */
-export class OpType {
-    value;
-    static fromJSON(jsonValue) {
-        return new OpType(OpTypeEnum[jsonValue]);
-    }
-    constructor(value) {
-        this.value = value;
-    }
-    toJSON() {
-        return Object.entries(OpTypeEnum).find(([, value]) => value === this.value)[0];
-    }
-}
-//# sourceMappingURL=OpType.js.map

package/lib/client/sync/bucket/OpType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpType.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/OpType.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,UAKX;AALD,WAAY,UAAU;IACpB,6CAAS,CAAA;IACT,2CAAQ,CAAA;IACR,yCAAO,CAAA;IACP,+CAAU,CAAA;AACZ,CAAC,EALW,UAAU,KAAV,UAAU,QAKrB;AAID;;GAEG;AACH,MAAM,OAAO,MAAM;IAKE;IAJnB,MAAM,CAAC,QAAQ,CAAC,SAAqB;QACnC,OAAO,IAAI,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,YAAmB,KAAiB;QAAjB,UAAK,GAAL,KAAK,CAAY;IAAG,CAAC;IAExC,MAAM;QACJ,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAE,CAAC,CAAC,CAAC,CAAC;IAClF,CAAC;CACF"}

package/lib/client/sync/bucket/OplogEntry.d.ts

@@ -1,23 +0,0 @@
-import { OpId } from './CrudEntry.js';
-import { OpType, OpTypeJSON } from './OpType.js';
-export interface OplogEntryJSON {
-    checksum: number;
-    data?: string;
-    object_id?: string;
-    object_type?: string;
-    op_id: string;
-    op: OpTypeJSON;
-    subkey?: string;
-}
-export declare class OplogEntry {
-    op_id: OpId;
-    op: OpType;
-    checksum: number;
-    subkey?: string | undefined;
-    object_type?: string | undefined;
-    object_id?: string | undefined;
-    data?: string | undefined;
-    static fromRow(row: OplogEntryJSON): OplogEntry;
-    constructor(op_id: OpId, op: OpType, checksum: number, subkey?: string | undefined, object_type?: string | undefined, object_id?: string | undefined, data?: string | undefined);
-    toJSON(fixedKeyEncoding?: boolean): OplogEntryJSON;
-}

package/lib/client/sync/bucket/OplogEntry.js

@@ -1,36 +0,0 @@
-import { OpType } from './OpType.js';
-export class OplogEntry {
-    op_id;
-    op;
-    checksum;
-    subkey;
-    object_type;
-    object_id;
-    data;
-    static fromRow(row) {
-        return new OplogEntry(row.op_id, OpType.fromJSON(row.op), row.checksum, row.subkey, row.object_type, row.object_id, row.data);
-    }
-    constructor(op_id, op, checksum, subkey, object_type, object_id, data) {
-        this.op_id = op_id;
-        this.op = op;
-        this.checksum = checksum;
-        this.subkey = subkey;
-        this.object_type = object_type;
-        this.object_id = object_id;
-        this.data = data;
-    }
-    toJSON(fixedKeyEncoding = false) {
-        return {
-            op_id: this.op_id,
-            op: this.op.toJSON(),
-            object_type: this.object_type,
-            object_id: this.object_id,
-            checksum: this.checksum,
-            data: this.data,
-            // Older versions of the JS SDK used to always JSON.stringify here. That has always been wrong,
-            // but we need to migrate gradually to not break existing databases.
-            subkey: fixedKeyEncoding ? this.subkey : JSON.stringify(this.subkey)
-        };
-    }
-}
-//# sourceMappingURL=OplogEntry.js.map

package/lib/client/sync/bucket/OplogEntry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OplogEntry.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/OplogEntry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAc,MAAM,aAAa,CAAC;AAYjD,MAAM,OAAO,UAAU;IAcZ;IACA;IACA;IACA;IACA;IACA;IACA;IAnBT,MAAM,CAAC,OAAO,CAAC,GAAmB;QAChC,OAAO,IAAI,UAAU,CACnB,GAAG,CAAC,KAAK,EACT,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EACvB,GAAG,CAAC,QAAQ,EACZ,GAAG,CAAC,MAAM,EACV,GAAG,CAAC,WAAW,EACf,GAAG,CAAC,SAAS,EACb,GAAG,CAAC,IAAI,CACT,CAAC;IACJ,CAAC;IAED,YACS,KAAW,EACX,EAAU,EACV,QAAgB,EAChB,MAAe,EACf,WAAoB,EACpB,SAAkB,EAClB,IAAa;QANb,UAAK,GAAL,KAAK,CAAM;QACX,OAAE,GAAF,EAAE,CAAQ;QACV,aAAQ,GAAR,QAAQ,CAAQ;QAChB,WAAM,GAAN,MAAM,CAAS;QACf,gBAAW,GAAX,WAAW,CAAS;QACpB,cAAS,GAAT,SAAS,CAAS;QAClB,SAAI,GAAJ,IAAI,CAAS;IACnB,CAAC;IAEJ,MAAM,CAAC,gBAAgB,GAAG,KAAK;QAC7B,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE;YACpB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,+FAA+F;YAC/F,oEAAoE;YACpE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;SACrE,CAAC;IACJ,CAAC;CACF"}

package/lib/client/sync/bucket/SyncDataBatch.d.ts

@@ -1,6 +0,0 @@
-import { SyncDataBucket } from './SyncDataBucket.js';
-export declare class SyncDataBatch {
-    buckets: SyncDataBucket[];
-    static fromJSON(json: any): SyncDataBatch;
-    constructor(buckets: SyncDataBucket[]);
-}

package/lib/client/sync/bucket/SyncDataBatch.js

@@ -1,12 +0,0 @@
-import { SyncDataBucket } from './SyncDataBucket.js';
-// TODO JSON
-export class SyncDataBatch {
-    buckets;
-    static fromJSON(json) {
-        return new SyncDataBatch(json.buckets.map((bucket) => SyncDataBucket.fromRow(bucket)));
-    }
-    constructor(buckets) {
-        this.buckets = buckets;
-    }
-}
-//# sourceMappingURL=SyncDataBatch.js.map

package/lib/client/sync/bucket/SyncDataBatch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyncDataBatch.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/SyncDataBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,YAAY;AAEZ,MAAM,OAAO,aAAa;IAKL;IAJnB,MAAM,CAAC,QAAQ,CAAC,IAAS;QACvB,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED,YAAmB,OAAyB;QAAzB,YAAO,GAAP,OAAO,CAAkB;IAAG,CAAC;CACjD"}

package/lib/client/sync/bucket/SyncDataBucket.d.ts

@@ -1,40 +0,0 @@
-import { OpId } from './CrudEntry.js';
-import { OplogEntry, OplogEntryJSON } from './OplogEntry.js';
-export type SyncDataBucketJSON = {
-    bucket: string;
-    has_more?: boolean;
-    after?: string;
-    next_after?: string;
-    data: OplogEntryJSON[];
-};
-export declare class SyncDataBucket {
-    bucket: string;
-    data: OplogEntry[];
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean;
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined;
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined;
-    static fromRow(row: SyncDataBucketJSON): SyncDataBucket;
-    constructor(bucket: string, data: OplogEntry[], 
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more: boolean, 
-    /**
-     * The `after` specified in the request.
-     */
-    after?: OpId | undefined, 
-    /**
-     * Use this for the next request.
-     */
-    next_after?: OpId | undefined);
-    toJSON(fixedKeyEncoding?: boolean): SyncDataBucketJSON;
-}

package/lib/client/sync/bucket/SyncDataBucket.js

@@ -1,40 +0,0 @@
-import { OplogEntry } from './OplogEntry.js';
-export class SyncDataBucket {
-    bucket;
-    data;
-    has_more;
-    after;
-    next_after;
-    static fromRow(row) {
-        return new SyncDataBucket(row.bucket, row.data.map((entry) => OplogEntry.fromRow(entry)), row.has_more ?? false, row.after, row.next_after);
-    }
-    constructor(bucket, data, 
-    /**
-     * True if the response does not contain all the data for this bucket, and another request must be made.
-     */
-    has_more, 
-    /**
-     * The `after` specified in the request.
-     */
-    after, 
-    /**
-     * Use this for the next request.
-     */
-    next_after) {
-        this.bucket = bucket;
-        this.data = data;
-        this.has_more = has_more;
-        this.after = after;
-        this.next_after = next_after;
-    }
-    toJSON(fixedKeyEncoding = false) {
-        return {
-            bucket: this.bucket,
-            has_more: this.has_more,
-            after: this.after,
-            next_after: this.next_after,
-            data: this.data.map((entry) => entry.toJSON(fixedKeyEncoding))
-        };
-    }
-}
-//# sourceMappingURL=SyncDataBucket.js.map

package/lib/client/sync/bucket/SyncDataBucket.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SyncDataBucket.js","sourceRoot":"","sources":["../../../../src/client/sync/bucket/SyncDataBucket.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAkB,MAAM,iBAAiB,CAAC;AAU7D,MAAM,OAAO,cAAc;IAYhB;IACA;IAIA;IAIA;IAIA;IAxBT,MAAM,CAAC,OAAO,CAAC,GAAuB;QACpC,OAAO,IAAI,cAAc,CACvB,GAAG,CAAC,MAAM,EACV,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAClD,GAAG,CAAC,QAAQ,IAAI,KAAK,EACrB,GAAG,CAAC,KAAK,EACT,GAAG,CAAC,UAAU,CACf,CAAC;IACJ,CAAC;IAED,YACS,MAAc,EACd,IAAkB;IACzB;;OAEG;IACI,QAAiB;IACxB;;OAEG;IACI,KAAY;IACnB;;OAEG;IACI,UAAiB;QAbjB,WAAM,GAAN,MAAM,CAAQ;QACd,SAAI,GAAJ,IAAI,CAAc;QAIlB,aAAQ,GAAR,QAAQ,CAAS;QAIjB,UAAK,GAAL,KAAK,CAAO;QAIZ,eAAU,GAAV,UAAU,CAAO;IACvB,CAAC;IAEJ,MAAM,CAAC,gBAAgB,GAAG,KAAK;QAC7B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;SAC/D,CAAC;IACJ,CAAC;CACF"}