@rebasepro/server 0.25.0 → 0.26.0

package/dist/{offline-BrqCRgih-BtDB1ecy.js → offline-AvuEcg7u-DFHL98OT.js}

@@ -2,11 +2,12 @@ import { createRequire as __rebaseCreateRequire } from "module";
 import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
-import { c as RebaseClientError, l as isUnsupported, s as RebaseApiError, t as splitSearchTerms } from "./strings.es-BeZWAodn.js";
-import { D as Vector, E as GeoPoint, S as hasFieldOperation, T as EntityRelation, _ as normalizeOrderBy, c as collectAllPages, l as paginateFind, u as resolveFindWindow, w as EntityReference } from "./filter-dialect-O1HK6Nvr.js";
-import { $ as parseRelationAggregateSort, tt as toCanonicalOp } from "./src-D5Y3N-S4.js";
-import { a as byIdRead, f as rebaseReviver, h as unref, i as buildQueryString, n as MemoryOfflineStore, p as etagOf, r as SDKQueryBuilder, s as createMutationId, t as IndexedDBOfflineStore, u as invalidBulkBody } from "./offline-store-BhYXViha-BW5j1We_.js";
-//#region ../client/dist/offline-BrqCRgih.js
+import { a as RebaseClientError, i as RebaseApiError, o as isUnsupported } from "./data_driver-D0mg1Y_x.js";
+import { D as Vector, E as GeoPoint, S as hasFieldOperation, T as EntityRelation, _ as normalizeOrderBy, c as collectAllPages, l as paginateFind, u as resolveFindWindow, w as EntityReference } from "./filter-dialect-TrKFWLqT.js";
+import { et as parseRelationAggregateSort, nt as toCanonicalOp } from "./src-Bh9LRPb9.js";
+import { t as splitSearchTerms } from "./strings.es-B7QLnHh2.js";
+import { a as byIdRead, f as rebaseReviver, h as unref, i as buildQueryString, m as withETag, n as MemoryOfflineStore, p as etagOf, r as SDKQueryBuilder, s as createMutationId, t as IndexedDBOfflineStore, u as invalidBulkBody } from "./offline-store-BhYXViha-YTmjBpo2.js";
+//#region ../client/dist/offline-AvuEcg7u.js
 /**
 * Lossless round-tripping of rows through the offline store.
 *
@@ -901,6 +902,13 @@ function isPlainObject(value) {
 	const proto = Object.getPrototypeOf(value);
 	return proto === null || Object.getPrototypeOf(proto) === null;
 }
+/**
+* The key a folded run is sent under: its first and last member and its
+* length, which fixes its composition.
+*/
+function runKey(run) {
+	return `${run[0].mutationId}..${run[run.length - 1].mutationId}:${run.length}`;
+}
 /** Whether a queued write's payload mentions `id` anywhere — see {@link replaceMintedId}. */
 function mentionsMintedId(op, id) {
 	return [op.data, ...(op.updates ?? []).map((u) => u.data)].some((payload) => replaceMintedId(payload, id, "").changed);
@@ -1324,19 +1332,45 @@ var OfflineManager = class {
 	*/
 	ticket() {
 		if (this.scopeHold) return void 0;
-		return {
-			scope: this.scope,
-			epoch: this.scopeEpoch
-		};
+		return this.currentTicket();
 	}
 	/** The ticket of whoever the held scope turns out to be. */
 	async nextTicket() {
 		await this.scopeKnown();
-		return {
+		return this.currentTicket();
+	}
+	currentTicket() {
+		return this.unverified ? {
+			scope: this.scope,
+			epoch: this.scopeEpoch,
+			unverified: true
+		} : {
 			scope: this.scope,
 			epoch: this.scopeEpoch
 		};
 	}
+	/**
+	* Whether a write may go to the server now. Not while the scope is the last
+	* user's, unconfirmed: it would go out with no credentials, as nobody. It
+	* queues for its author instead, as it does offline.
+	*/
+	sendsWrites() {
+		return this.connectivity.shouldAttempt() && !this.unverified;
+	}
+	reachedUnconfirmedListeners = /* @__PURE__ */ new Set();
+	/**
+	* `listener` runs when a request made while the scope is unconfirmed
+	* reached the server: the connection is back, so the session can be asked
+	* about. The client wires it to the same confirmation the status listener
+	* runs — the status may never have said the connection was gone.
+	*/
+	onReachedUnconfirmed(listener) {
+		this.reachedUnconfirmedListeners.add(listener);
+		return () => this.reachedUnconfirmedListeners.delete(listener);
+	}
+	reachedUnconfirmed() {
+		for (const listener of this.reachedUnconfirmedListeners) callSafely(listener);
+	}
 	/** Whether an operation's user is still the signed-in one. */
 	isCurrent(ticket) {
 		return ticket.epoch === this.scopeEpoch;
@@ -1393,15 +1427,18 @@ var OfflineManager = class {
 				const res = await inner.find(params);
 				this.connectivity.markSuccess();
 				if (!this.isCurrent(ticket)) return res;
-				await this.ingest(slug, res.data ?? [], ticket, isProjection(params));
-				if (!this.isCurrent(ticket)) return res;
-				const snapshot = this.recordSnapshot(slug, params, res, ticket);
-				const answer = this.answer(slug, params, snapshot);
-				this.notifyCollection(slug, false);
-				return {
-					data: answer.data,
-					meta: answer.meta
-				};
+				if (ticket.unverified) this.reachedUnconfirmed();
+				else {
+					await this.ingest(slug, res.data ?? [], ticket, isProjection(params));
+					if (!this.isCurrent(ticket)) return res;
+					const snapshot = this.recordSnapshot(slug, params, res, ticket);
+					const answer = this.answer(slug, params, snapshot);
+					this.notifyCollection(slug, false);
+					return {
+						data: answer.data,
+						meta: answer.meta
+					};
+				}
 			} catch (error) {
 				if (!isNetworkError(error)) {
 					if (isRetryableError(error) && this.hasLocalAnswer(state, slug, params) && !(walk && !this.snapshotFor(slug, params))) {
@@ -1435,10 +1472,16 @@ var OfflineManager = class {
 					const row = await inner.findById(id, options);
 					this.connectivity.markSuccess();
 					if (!this.isCurrent(ticket)) return row;
+					if (ticket.unverified) {
+						this.reachedUnconfirmed();
+						return this.localRow(slug, id);
+					}
 					if (row !== void 0) await this.ingest(slug, [row], ticket);
 					else if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
 					this.notifyCollection(slug, false);
-					return this.localRow(slug, id);
+					const local = this.localRow(slug, id);
+					const etag = etagOf(row);
+					return etag && local !== void 0 && !this.hasPending(slug, id) ? withETag({ ...local }, etag) : local;
 				} catch (error) {
 					if (!isNetworkError(error)) throw error;
 					this.connectivity.markFailure();
@@ -1461,7 +1504,7 @@ var OfflineManager = class {
 				await this.ensureCollection(slug);
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
-				if (this.connectivity.shouldAttempt()) try {
+				if (this.sendsWrites()) try {
 					const row = await inner.create(data, id, {
 						...options,
 						idempotencyKey
@@ -1503,7 +1546,7 @@ var OfflineManager = class {
 				if (data.length === 0) return [];
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
-				if (this.connectivity.shouldAttempt()) try {
+				if (this.sendsWrites()) try {
 					const rows = await inner.createMany(data, {
 						...options,
 						idempotencyKey
@@ -1555,7 +1598,7 @@ var OfflineManager = class {
 			upsert: async (data, options) => {
 				const ticket = this.ticket() ?? await this.nextTicket();
 				await this.ensureCollection(slug);
-				if (this.connectivity.shouldAttempt()) try {
+				if (this.sendsWrites()) try {
 					const row = await inner.upsert(data, options);
 					this.connectivity.markSuccess();
 					await this.ingest(slug, [row], ticket);
@@ -1586,7 +1629,7 @@ var OfflineManager = class {
 				if (!Array.isArray(updates)) throw invalidBulkBody("updateMany expects an array of { id, data } entries.");
 				if (updates.length === 0) return [];
 				const anyPending = updates.some((u) => this.hasPending(slug, u.id));
-				if (this.connectivity.shouldAttempt() && !anyPending) try {
+				if (this.sendsWrites() && !anyPending) try {
 					const rows = await inner.updateMany(updates, options);
 					this.connectivity.markSuccess();
 					await this.ingest(slug, rows, ticket);
@@ -1625,7 +1668,7 @@ var OfflineManager = class {
 				if (!Array.isArray(ids)) throw invalidBulkBody("deleteMany expects an array of ids.");
 				if (ids.length === 0) return;
 				const anyPending = ids.some((id) => this.hasPending(slug, id));
-				if (this.connectivity.shouldAttempt() && !anyPending) try {
+				if (this.sendsWrites() && !anyPending) try {
 					await inner.deleteMany(ids, options);
 					this.connectivity.markSuccess();
 					for (const id of ids) this.removeLocalRow(slug, id, ticket, true);
@@ -1653,7 +1696,7 @@ var OfflineManager = class {
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
 				let sendFailure;
-				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
+				if (this.sendsWrites() && !this.hasPending(slug, id)) try {
 					const row = await inner.update(id, data, {
 						...options,
 						idempotencyKey
@@ -1678,7 +1721,7 @@ var OfflineManager = class {
 					throw new RebaseClientError(`Cannot apply a field operation to "${slug}" while offline: it is evaluated against the stored value, which this device does not have a current copy of. Send the value itself, or retry when the connection is back.`, { code: "OFFLINE_FIELD_OP_UNSUPPORTED" });
 				}
 				const base = this.rawLocalRow(slug, id);
-				const ifMatch = this.onConflict ? options?.ifMatch ?? (this.hasPending(slug, id) ? void 0 : this.etagFor(slug, id)) : void 0;
+				const ifMatch = options?.ifMatch ?? (this.onConflict && !this.hasPending(slug, id) ? this.etagFor(slug, id) : void 0);
 				await this.enqueue({
 					collection: slug,
 					type: "update",
@@ -1701,7 +1744,7 @@ var OfflineManager = class {
 				await this.ensureCollection(slug);
 				const idempotencyKey = options?.idempotencyKey ?? createMutationId();
 				let sent = false;
-				if (this.connectivity.shouldAttempt() && !this.hasPending(slug, id)) try {
+				if (this.sendsWrites() && !this.hasPending(slug, id)) try {
 					await inner.delete(id, {
 						...options,
 						idempotencyKey
@@ -1721,6 +1764,7 @@ var OfflineManager = class {
 					type: "delete",
 					id,
 					...sent ? { sent: { idempotencyKey } } : {},
+					...options?.ifMatch ? { ifMatch: options.ifMatch } : {},
 					rollback: { rows: { [String(id)]: this.rawLocalRow(slug, id) ?? null } }
 				}, ticket);
 				this.removeLocalRow(slug, id, ticket);
@@ -1733,6 +1777,12 @@ var OfflineManager = class {
 					const n = await inner.count(params);
 					this.connectivity.markSuccess();
 					if (!this.isCurrent(ticket)) return n;
+					if (ticket.unverified) {
+						this.reachedUnconfirmed();
+						const cached = await this.readCache(this.countKey(slug, params));
+						if (cached !== void 0) return Math.max(0, cached + this.pendingDelta(slug, params));
+						throw offlineError(`No count of "${slug}" for the last user is cached, and their session is not confirmed yet.`);
+					}
 					this.writeCache(this.countKey(slug, params), n);
 					return Math.max(0, n + this.pendingDelta(slug, params));
 				} catch (error) {
@@ -1771,6 +1821,15 @@ var OfflineManager = class {
 				onUpdate(response);
 				return;
 			}
+			if (ticket.unverified) {
+				const answer = this.localFind(slug, params);
+				onUpdate({
+					...response,
+					data: answer.data,
+					meta: answer.meta
+				});
+				return;
+			}
 			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
 				if (!this.isCurrent(ticket)) return;
 				const snapshot = this.recordSnapshot(slug, params, response, ticket);
@@ -1789,6 +1848,10 @@ var OfflineManager = class {
 				onUpdate(row);
 				return;
 			}
+			if (ticket.unverified) {
+				onUpdate(this.localRow(slug, id));
+				return;
+			}
 			if (!row) {
 				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
 				this.notifyCollection(slug, false);
@@ -1820,7 +1883,7 @@ var OfflineManager = class {
 	wrapTrash(slug, inner) {
 		const online = async (what, call) => {
 			const message = `Offline: ${what} on the trash of "${slug}" needs the server; the trash is never cached on this device.`;
-			if (!this.connectivity.shouldAttempt()) throw offlineError(message);
+			if (!this.sendsWrites()) throw offlineError(message);
 			try {
 				const result = await call();
 				this.connectivity.markSuccess();
@@ -1934,7 +1997,7 @@ var OfflineManager = class {
 		})();
 		if (options?.realtime !== false && !isUnsupported(inner.listen)) unlisten = inner.listen(params, (response) => {
 			const ticket = this.ticket();
-			if (!ticket) return;
+			if (!ticket || ticket.unverified) return;
 			this.ingest(slug, response.data ?? [], ticket, isProjection(params)).then(() => {
 				this.recordSnapshot(slug, params, response, ticket);
 				this.notifyCollection(slug, false);
@@ -1989,7 +2052,7 @@ var OfflineManager = class {
 		})();
 		if (options?.realtime !== false && !isUnsupported(inner.listenById)) unlisten = inner.listenById(id, (row) => {
 			const ticket = this.ticket();
-			if (!ticket) return;
+			if (!ticket || ticket.unverified) return;
 			if (!row) {
 				if (!this.hasPending(slug, id)) this.removeLocalRow(slug, id, ticket, true);
 				this.notifyCollection(slug, false);
@@ -2314,6 +2377,7 @@ var OfflineManager = class {
 	*/
 	removeLocalRow(slug, id, ticket, known = false) {
 		if (!this.isCurrent(ticket)) return;
+		if (known && ticket.unverified) return;
 		const state = this.collectionState(slug);
 		const key = String(id);
 		const existed = state.rows.delete(key);
@@ -2346,7 +2410,7 @@ var OfflineManager = class {
 	* dropdown elsewhere asked for titles.
 	*/
 	async ingest(slug, rows, ticket, projection = false) {
-		if (rows.length === 0 || !this.isCurrent(ticket)) return;
+		if (rows.length === 0 || !this.isCurrent(ticket) || ticket.unverified) return;
 		const state = await this.ensureCollection(slug);
 		if (!this.isCurrent(ticket)) return;
 		const cachedAt = Date.now();
@@ -2450,7 +2514,7 @@ var OfflineManager = class {
 			hasMore: meta.hasMore ?? false,
 			...isProjection(params) ? { rows: (result.data ?? []).map((row) => ({ ...row })) } : {}
 		};
-		if (!this.isCurrent(ticket)) return snapshot;
+		if (!this.isCurrent(ticket) || ticket.unverified) return snapshot;
 		const state = this.collectionState(slug);
 		const key = buildQueryString(params);
 		state.snapshots.set(key, snapshot);
@@ -2548,7 +2612,7 @@ var OfflineManager = class {
 			}
 			if (mutation.type === "update") {
 				const tail = this.queue[this.queue.length - 1];
-				if (tail && !this.inFlight.has(tail.mutationId) && tail.sent === void 0 && (tail.schemaVersion ?? 1) <= 1 && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
+				if (tail && !this.inFlight.has(tail.mutationId) && tail.sent === void 0 && (tail.schemaVersion ?? 1) <= 1 && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id && (mutation.ifMatch === void 0 || mutation.ifMatch === tail.ifMatch)) {
 					if (tail.type === "update") tail.parts = [...tail.parts ?? [{ ...tail.data }], { ...mutation.data }];
 					tail.data = {
 						...tail.data,
@@ -2729,7 +2793,7 @@ var OfflineManager = class {
 							this.connectivity.markFailure();
 							break;
 						}
-						if (op.type === "update" && op.ifMatch && isPreconditionFailed(error)) {
+						if ((op.type === "update" || op.type === "delete") && op.ifMatch && this.onConflict && isPreconditionFailed(error)) {
 							this.connectivity.markSuccess();
 							await this.resolveConflict(op, error, ticket);
 							continue;
@@ -2800,16 +2864,18 @@ var OfflineManager = class {
 	*/
 	foldableRun(unbatched) {
 		if (this.replayBatchSize < 2) return [];
-		const foldable = (op, collection) => op !== void 0 && op.type === "create" && op.generatedId === true && typeof op.id === "string" && op.sent === void 0 && !op.upsert && (op.schemaVersion ?? 1) <= 1 && !unbatched.has(op.mutationId) && (collection === void 0 || op.collection === collection);
 		const head = this.queue[0];
+		const resent = head?.sent?.run;
+		const foldable = (op, collection) => op !== void 0 && op.type === "create" && op.generatedId === true && typeof op.id === "string" && (resent === void 0 ? op.sent === void 0 : op.sent?.run === resent) && !op.upsert && (op.schemaVersion ?? 1) <= 1 && !unbatched.has(op.mutationId) && (collection === void 0 || op.collection === collection);
 		if (!foldable(head)) return [];
 		const run = [head];
-		for (let i = 1; i < this.queue.length && run.length < this.replayBatchSize; i++) {
+		for (let i = 1; i < this.queue.length && (resent !== void 0 || run.length < this.replayBatchSize); i++) {
 			const next = this.queue[i];
 			if (!foldable(next, head.collection)) break;
 			if (run.some((member) => mentionsMintedId(next, member.id))) break;
 			run.push(next);
 		}
+		if (resent !== void 0 && runKey(run) !== resent) return [];
 		return run;
 	}
 	/**
@@ -2830,9 +2896,10 @@ var OfflineManager = class {
 	*/
 	async replayRun(run, ticket) {
 		const inner = this.innerFor(run[0].collection);
-		const idempotencyKey = `${run[0].mutationId}..${run[run.length - 1].mutationId}:${run.length}`;
+		const idempotencyKey = runKey(run);
 		for (const member of run) this.inFlight.add(member.mutationId);
 		try {
+			for (const member of run) await this.markCreateSent(member, ticket, idempotencyKey);
 			let rows;
 			try {
 				rows = await inner.createMany(run.map((member) => member.data), { idempotencyKey });
@@ -2854,6 +2921,7 @@ var OfflineManager = class {
 	async replay(op, ticket) {
 		const inner = this.innerFor(op.collection);
 		if (op.type === "create") {
+			await this.markCreateSent(op, ticket);
 			let row;
 			try {
 				row = await this.sendQueuedWrite(op, (idempotencyKey) => inner.create(op.data, void 0, { idempotencyKey }), (sent) => inner.create(sent.data, sent.id, { idempotencyKey: sent.idempotencyKey }));
@@ -2906,11 +2974,30 @@ var OfflineManager = class {
 			}
 			for (const id of ids) this.removeLocalRow(op.collection, id, ticket, true);
 		} else if (op.type === "delete") {
-			await inner.delete(op.id, { idempotencyKey: op.sent?.idempotencyKey ?? op.mutationId });
+			await inner.delete(op.id, {
+				idempotencyKey: op.sent?.idempotencyKey ?? op.mutationId,
+				...op.ifMatch ? { ifMatch: op.ifMatch } : {}
+			});
 			this.removeLocalRow(op.collection, op.id, ticket, true);
 		}
 	}
 	/**
+	* Record a queued create as sent, with the request about to go out, and
+	* persist it — before the request, so a lost answer cannot leave it
+	* unmarked. One already marked (sent online before it was queued, or by
+	* an earlier replay) keeps what it holds: that is the request the server
+	* may have stored.
+	*/
+	async markCreateSent(op, ticket, run) {
+		if (op.sent) return;
+		op.sent = {
+			idempotencyKey: op.mutationId,
+			data: { ...op.data },
+			...run ? { run } : {}
+		};
+		await this.persistMutation(`${ticket.scope}|${op.mutationId}`, op).catch(() => void 0);
+	}
+	/**
 	* Send a queued write under its key.
 	*
 	* A write the queue sent once already, before it was queued, carries that
@@ -3302,4 +3389,4 @@ var OfflineManager = class {
 //#endregion
 export { OfflineManager };
 
-//# sourceMappingURL=offline-BrqCRgih-BtDB1ecy.js.map
+//# sourceMappingURL=offline-AvuEcg7u-DFHL98OT.js.map