@rebasepro/client 0.10.1-canary.gdaf6ba4 → 0.11.0

package/dist/index.es.js

@@ -1194,12 +1194,13 @@ function createCollectionClient(transport, slug, ws) {
 				throw err;
 			}
 		},
-		async create(data, id) {
+		async create(data, id, options) {
 			const body = { ...data };
 			if (id !== void 0) body.id = id;
 			return await transport.request(basePath, {
 				method: "POST",
-				body: JSON.stringify(body)
+				body: JSON.stringify(body),
+				...options?.idempotencyKey ? { headers: { "Idempotency-Key": options.idempotencyKey } } : {}
 			});
 		},
 		async createMany(data, options) {
@@ -3196,6 +3197,21 @@ function isRetryableError(error) {
 	if (error instanceof RebaseApiError) return error.status !== void 0 && RETRYABLE_STATUSES.has(error.status);
 	return false;
 }
+/**
+* Did this write fail because the row is already there?
+*
+* Matched on the SQLSTATE the server passes through (`23505`, unique_violation)
+* and on 409, never on the message — a duplicate-key message names the
+* constraint and the values, so it is neither stable nor safe to parse.
+*
+* The queue uses this to recognise its own earlier attempt. A create whose
+* response was lost is replayed, and for a row carrying an id the SDK generated
+* the server can only be rejecting it because the first attempt actually landed.
+*/
+function isDuplicateKeyError(error) {
+	if (!(error instanceof RebaseApiError)) return false;
+	return error.code === "23505" || error.status === 409;
+}
 var ConnectivityMonitor = class {
 	state = "online";
 	backoffMs;
@@ -3812,6 +3828,25 @@ var OfflineManager = class {
 	collections = /* @__PURE__ */ new Map();
 	/** In-memory mirror of the current scope's queue, in replay order. */
 	queue = [];
+	/**
+	* The mutation currently on the wire, if any.
+	*
+	* `flush` awaits `replay(op)` with `op` still at the head of `queue`, so for
+	* the whole duration of that request the in-flight op is also the queue's
+	* *tail* whenever it is the only entry. Both shortcuts in `enqueue` reach
+	* for the tail, and neither may touch an op the server is already reading:
+	*
+	* - Coalescing an update into it mutates a payload that has already been
+	*   serialized and sent, and `drop` then removes the whole entry on ACK —
+	*   so the second edit is neither sent nor kept. A silently lost write.
+	* - Cancelling it out against a delete assumes the server never saw the
+	*   create. It is seeing it right now, so the row would be created and the
+	*   delete never queued — an orphan row nothing will ever remove.
+	*
+	* Guarding on the id rather than on a boolean keeps this correct if the
+	* flush loop ever sends more than one op at a time.
+	*/
+	inFlightId = null;
 	queueLoad;
 	/** Serializes enqueues so concurrent writes keep the order the app made them. */
 	enqueueChain = Promise.resolve();
@@ -4059,7 +4094,7 @@ var OfflineManager = class {
 			},
 			update: async (id, data) => {
 				await this.ensureCollection(slug);
-				if (this.connectivity.shouldAttempt()) try {
+				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
 					const row = await inner.update(id, data);
 					this.connectivity.markSuccess();
 					await this.ingest(slug, [row]);
@@ -4088,7 +4123,7 @@ var OfflineManager = class {
 			},
 			delete: async (id) => {
 				await this.ensureCollection(slug);
-				if (this.connectivity.shouldAttempt()) try {
+				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
 					await inner.delete(id);
 					this.connectivity.markSuccess();
 					this.removeLocalRow(slug, id, true);
@@ -4630,7 +4665,7 @@ var OfflineManager = class {
 			await this.ensureQueueLoaded();
 			if (mutation.type === "update") {
 				const tail = this.queue[this.queue.length - 1];
-				if (tail && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
+				if (tail && tail.mutationId !== this.inFlightId && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
 					tail.data = {
 						...tail.data,
 						...mutation.data,
@@ -4641,8 +4676,8 @@ var OfflineManager = class {
 				}
 			}
 			if (mutation.type === "delete") {
-				if (this.queue.some((m) => m.collection === mutation.collection && m.type === "create" && m.id === mutation.id && m.generatedId === true)) {
-					const doomed = this.queue.filter((m) => m.collection === mutation.collection && m.id === mutation.id && (m.type === "create" || m.type === "update"));
+				if (this.queue.some((m) => m.collection === mutation.collection && m.type === "create" && m.id === mutation.id && m.generatedId === true && m.mutationId !== this.inFlightId)) {
+					const doomed = this.queue.filter((m) => m.collection === mutation.collection && m.id === mutation.id && (m.type === "create" || m.type === "update") && m.mutationId !== this.inFlightId);
 					for (const op of doomed) await this.store.dequeue(this.queueKey(op));
 					this.queue = this.queue.filter((m) => !doomed.includes(m));
 					this.afterQueueChange();
@@ -4717,27 +4752,32 @@ var OfflineManager = class {
 			while (this.queue.length > 0 && !this.disposed) {
 				const op = this.queue[0];
 				touched.add(op.collection);
+				this.inFlightId = op.mutationId;
 				try {
-					await this.replay(op);
-				} catch (error) {
-					if (isNetworkError(error)) {
-						this.connectivity.markFailure();
-						break;
-					}
-					op.attempts = (op.attempts ?? 0) + 1;
-					op.lastError = error?.message ?? String(error);
-					if (isRetryableError(error) && op.attempts < this.maxRetries) {
-						await this.store.enqueue(this.queueKey(op), op).catch(() => void 0);
-						this.connectivity.deferRetry();
-						this.patchStatus({ lastError: op.lastError });
-						break;
+					try {
+						await this.replay(op);
+					} catch (error) {
+						if (isNetworkError(error)) {
+							this.connectivity.markFailure();
+							break;
+						}
+						op.attempts = (op.attempts ?? 0) + 1;
+						op.lastError = error?.message ?? String(error);
+						if (isRetryableError(error) && op.attempts < this.maxRetries) {
+							await this.store.enqueue(this.queueKey(op), op).catch(() => void 0);
+							this.connectivity.deferRetry();
+							this.patchStatus({ lastError: op.lastError });
+							break;
+						}
+						await this.rejectMutation(op, error);
+						continue;
 					}
-					await this.rejectMutation(op, error);
-					continue;
+					this.connectivity.markSuccess();
+					await this.drop(op);
+					flushed++;
+				} finally {
+					this.inFlightId = null;
 				}
-				this.connectivity.markSuccess();
-				await this.drop(op);
-				flushed++;
 			}
 		} finally {
 			this.patchStatus({ syncing: false });
@@ -4758,7 +4798,14 @@ var OfflineManager = class {
 	async replay(op) {
 		const inner = this.innerFor(op.collection);
 		if (op.type === "create") {
-			const row = await inner.create(op.data);
+			let row;
+			try {
+				row = await inner.create(op.data, void 0, { idempotencyKey: op.mutationId });
+			} catch (error) {
+				if (!(op.generatedId === true && isDuplicateKeyError(error))) throw error;
+				row = await inner.findById(op.id).catch(() => void 0);
+				if (!row) return;
+			}
 			await this.adoptServerRow(op, op.id, row);
 		} else if (op.type === "createMany") {
 			const queued = op.data ?? [];