fires2rest 0.0.0

package/dist/index.js

@@ -0,0 +1,820 @@
+import { SignJWT, importPKCS8 } from "jose";
+
+//#region src/auth.ts
+async function createJWT(config) {
+	const now = Math.floor(Date.now() / 1e3);
+	const payload = {
+		iss: config.clientEmail,
+		sub: config.clientEmail,
+		aud: "https://oauth2.googleapis.com/token",
+		iat: now,
+		exp: now + 3600,
+		scope: "https://www.googleapis.com/auth/datastore"
+	};
+	try {
+		const privateKey = await importPKCS8(config.privateKey, "RS256");
+		return await new SignJWT(payload).setProtectedHeader({
+			alg: "RS256",
+			typ: "JWT"
+		}).sign(privateKey);
+	} catch (error) {
+		console.error("Error creating JWT:", error);
+		throw error;
+	}
+}
+async function getFirestoreToken(config) {
+	const data = await (await fetch("https://oauth2.googleapis.com/token", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+			assertion: await createJWT(config)
+		})
+	})).json();
+	if (typeof data.access_token !== "string") throw new Error("Invalid access token");
+	return data.access_token;
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Generate a random document ID (20 characters, alphanumeric)
+*/
+function generateDocumentId() {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	for (let i = 0; i < 20; i++) result += chars.charAt(Math.floor(Math.random() * 62));
+	return result;
+}
+/**
+* Parse a document path into collection and document ID
+*/
+function parseDocumentPath(path) {
+	const parts = path.split("/");
+	if (parts.length < 2 || parts.length % 2 !== 0) throw new Error(`Invalid document path: ${path}`);
+	return {
+		collection: parts.slice(0, -1).join("/"),
+		docId: parts[parts.length - 1]
+	};
+}
+/**
+* Extract document ID from full resource name
+*/
+function extractDocumentId(name) {
+	const parts = name.split("/");
+	return parts[parts.length - 1];
+}
+/**
+* Get all field paths from an object.
+*/
+function getFieldPaths(obj, prefix = "", isFieldValue$1) {
+	const paths = [];
+	for (const key of Object.keys(obj)) if (key.includes(".")) paths.push(key);
+	else {
+		const fullPath = prefix ? `${prefix}.${key}` : key;
+		const value = obj[key];
+		if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !isFieldValue$1(value) && Object.keys(value).length > 0 && !("latitude" in value && "longitude" in value)) paths.push(...getFieldPaths(value, fullPath, isFieldValue$1));
+		else paths.push(fullPath);
+	}
+	return paths;
+}
+/**
+* Build Firestore fields from update data, handling dot-notation paths.
+*/
+function buildUpdateFields(data, toFirestoreValue$1, isFieldValue$1) {
+	const fields = {};
+	for (const [key, value] of Object.entries(data)) {
+		if (isFieldValue$1(value)) continue;
+		if (key.includes(".")) {
+			const parts = key.split(".");
+			let current = fields;
+			for (let i = 0; i < parts.length - 1; i++) {
+				const part = parts[i];
+				if (!current[part]) current[part] = { mapValue: { fields: {} } };
+				const mapVal = current[part];
+				if (!mapVal.mapValue.fields) mapVal.mapValue.fields = {};
+				current = mapVal.mapValue.fields;
+			}
+			current[parts[parts.length - 1]] = toFirestoreValue$1(value);
+		} else fields[key] = toFirestoreValue$1(value);
+	}
+	return fields;
+}
+
+//#endregion
+//#region src/field-value.ts
+/**
+* FieldValue Sentinels
+*
+* Sentinel values for special Firestore operations.
+*/
+/** Property name to identify FieldValue instances */
+const FIELD_VALUE_MARKER = "__isFieldValue__";
+/** Base class for FieldValue sentinels */
+var FieldValueBase = class {
+	constructor() {
+		this.__isFieldValue__ = true;
+	}
+};
+/** Server timestamp sentinel */
+var ServerTimestampValue = class extends FieldValueBase {
+	constructor(..._args) {
+		super(..._args);
+		this._type = "serverTimestamp";
+	}
+};
+/** Delete field sentinel */
+var DeleteFieldValue = class extends FieldValueBase {
+	constructor(..._args2) {
+		super(..._args2);
+		this._type = "delete";
+	}
+};
+/** Increment sentinel */
+var IncrementValue = class extends FieldValueBase {
+	constructor(amount) {
+		super();
+		this.amount = amount;
+		this._type = "increment";
+	}
+};
+/** Array union sentinel */
+var ArrayUnionValue = class extends FieldValueBase {
+	constructor(elements) {
+		super();
+		this.elements = elements;
+		this._type = "arrayUnion";
+	}
+};
+/** Array remove sentinel */
+var ArrayRemoveValue = class extends FieldValueBase {
+	constructor(elements) {
+		super();
+		this.elements = elements;
+		this._type = "arrayRemove";
+	}
+};
+/**
+* FieldValue factory for creating sentinel values
+*/
+const FieldValue = {
+	serverTimestamp() {
+		return new ServerTimestampValue();
+	},
+	delete() {
+		return new DeleteFieldValue();
+	},
+	increment(amount) {
+		return new IncrementValue(amount);
+	},
+	arrayUnion(...elements) {
+		return new ArrayUnionValue(elements);
+	},
+	arrayRemove(...elements) {
+		return new ArrayRemoveValue(elements);
+	}
+};
+/**
+* Check if a value is a FieldValue sentinel
+*/
+function isFieldValue(value) {
+	return typeof value === "object" && value !== null && FIELD_VALUE_MARKER in value && value[FIELD_VALUE_MARKER] === true;
+}
+/**
+* Check if a value is a ServerTimestamp sentinel
+*/
+function isServerTimestamp(value) {
+	return value instanceof ServerTimestampValue;
+}
+/**
+* Check if a value is a Delete sentinel
+*/
+function isDeleteField(value) {
+	return value instanceof DeleteFieldValue;
+}
+/**
+* Check if a value is an Increment sentinel
+*/
+function isIncrement(value) {
+	return value instanceof IncrementValue;
+}
+/**
+* Get increment amount if value is an increment sentinel
+*/
+function getIncrementAmount(value) {
+	if (value instanceof IncrementValue) return value.amount;
+}
+/**
+* Check if a value is an ArrayUnion sentinel
+*/
+function isArrayUnion(value) {
+	return value instanceof ArrayUnionValue;
+}
+/**
+* Get array union elements if value is an array union sentinel
+*/
+function getArrayUnionElements(value) {
+	if (value instanceof ArrayUnionValue) return value.elements;
+}
+/**
+* Check if a value is an ArrayRemove sentinel
+*/
+function isArrayRemove(value) {
+	return value instanceof ArrayRemoveValue;
+}
+/**
+* Get array remove elements if value is an array remove sentinel
+*/
+function getArrayRemoveElements(value) {
+	if (value instanceof ArrayRemoveValue) return value.elements;
+}
+
+//#endregion
+//#region src/value.ts
+/**
+* Value Conversion Utilities
+*
+* Bidirectional conversion between JavaScript values and Firestore REST format.
+*/
+/**
+* Represents a geographic point (latitude/longitude).
+*/
+var GeoPoint = class {
+	constructor(latitude, longitude) {
+		this.latitude = latitude;
+		this.longitude = longitude;
+		if (latitude < -90 || latitude > 90) throw new Error("Latitude must be between -90 and 90");
+		if (longitude < -180 || longitude > 180) throw new Error("Longitude must be between -180 and 180");
+	}
+	isEqual(other) {
+		return this.latitude === other.latitude && this.longitude === other.longitude;
+	}
+};
+/**
+* Represents a Firestore timestamp with nanosecond precision.
+*/
+var Timestamp = class Timestamp {
+	constructor(seconds, nanoseconds) {
+		this.seconds = seconds;
+		this.nanoseconds = nanoseconds;
+	}
+	static now() {
+		const now = Date.now();
+		return new Timestamp(Math.floor(now / 1e3), now % 1e3 * 1e6);
+	}
+	static fromDate(date) {
+		const ms = date.getTime();
+		return new Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
+	}
+	static fromMillis(milliseconds) {
+		return new Timestamp(Math.floor(milliseconds / 1e3), milliseconds % 1e3 * 1e6);
+	}
+	toDate() {
+		return /* @__PURE__ */ new Date(this.seconds * 1e3 + this.nanoseconds / 1e6);
+	}
+	toMillis() {
+		return this.seconds * 1e3 + this.nanoseconds / 1e6;
+	}
+	isEqual(other) {
+		return this.seconds === other.seconds && this.nanoseconds === other.nanoseconds;
+	}
+};
+/**
+* Convert a JavaScript value to Firestore REST format.
+*/
+function toFirestoreValue(value) {
+	if (value === null) return { nullValue: null };
+	if (value === void 0) return { nullValue: null };
+	if (typeof value === "boolean") return { booleanValue: value };
+	if (typeof value === "number") {
+		if (Number.isInteger(value)) return { integerValue: String(value) };
+		return { doubleValue: value };
+	}
+	if (typeof value === "string") return { stringValue: value };
+	if (value instanceof Date) return { timestampValue: value.toISOString() };
+	if (value instanceof Timestamp) return { timestampValue: value.toDate().toISOString() };
+	if (value instanceof GeoPoint) return { geoPointValue: {
+		latitude: value.latitude,
+		longitude: value.longitude
+	} };
+	if (value instanceof Uint8Array) {
+		const binary = Array.from(value, (byte) => String.fromCharCode(byte)).join("");
+		return { bytesValue: btoa(binary) };
+	}
+	if (Array.isArray(value)) return { arrayValue: { values: value.map(toFirestoreValue) } };
+	if (typeof value === "object") {
+		const fields = {};
+		for (const [key, val] of Object.entries(value)) if (!isFieldValue(val)) fields[key] = toFirestoreValue(val);
+		return { mapValue: { fields } };
+	}
+	throw new Error(`Unsupported value type: ${typeof value}`);
+}
+/**
+* Convert document data to Firestore fields format.
+*/
+function toFirestoreFields(data) {
+	const fields = {};
+	for (const [key, value] of Object.entries(data)) if (!isFieldValue(value)) fields[key] = toFirestoreValue(value);
+	return fields;
+}
+/**
+* Extract field transforms from document data.
+*/
+function extractFieldTransforms(data, pathPrefix = "") {
+	const transforms = [];
+	for (const [key, value] of Object.entries(data)) {
+		const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+		if (isFieldValue(value)) {
+			const transform = fieldValueToTransform(value, fieldPath);
+			if (transform) transforms.push(transform);
+		} else if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Timestamp) && !(value instanceof GeoPoint) && !(value instanceof Uint8Array)) transforms.push(...extractFieldTransforms(value, fieldPath));
+	}
+	return transforms;
+}
+/**
+* Convert a FieldValue sentinel to a FieldTransform.
+*/
+function fieldValueToTransform(fieldValue, fieldPath) {
+	if (isServerTimestamp(fieldValue)) return {
+		fieldPath,
+		setToServerValue: "REQUEST_TIME"
+	};
+	if (isDeleteField(fieldValue)) return null;
+	if (isIncrement(fieldValue)) return {
+		fieldPath,
+		increment: toFirestoreValue(getIncrementAmount(fieldValue))
+	};
+	if (isArrayUnion(fieldValue)) return {
+		fieldPath,
+		appendMissingElements: { values: (getArrayUnionElements(fieldValue) ?? []).map(toFirestoreValue) }
+	};
+	if (isArrayRemove(fieldValue)) return {
+		fieldPath,
+		removeAllFromArray: { values: (getArrayRemoveElements(fieldValue) ?? []).map(toFirestoreValue) }
+	};
+	return null;
+}
+/**
+* Extract delete field paths from document data.
+*/
+function extractDeleteFields(data, pathPrefix = "") {
+	const deletePaths = [];
+	for (const [key, value] of Object.entries(data)) {
+		const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+		if (isFieldValue(value) && isDeleteField(value)) deletePaths.push(fieldPath);
+		else if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Timestamp) && !(value instanceof GeoPoint) && !(value instanceof Uint8Array)) deletePaths.push(...extractDeleteFields(value, fieldPath));
+	}
+	return deletePaths;
+}
+/**
+* Extract transform field paths from document data.
+* These are fields with FieldValue sentinels that become transforms (not delete).
+*/
+function extractTransformFields(data, pathPrefix = "") {
+	const transformPaths = [];
+	for (const [key, value] of Object.entries(data)) {
+		const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+		if (isFieldValue(value) && !isDeleteField(value)) transformPaths.push(fieldPath);
+		else if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Timestamp) && !(value instanceof GeoPoint) && !(value instanceof Uint8Array)) transformPaths.push(...extractTransformFields(value, fieldPath));
+	}
+	return transformPaths;
+}
+/**
+* Convert a Firestore REST value to JavaScript.
+*/
+function fromFirestoreValue(value) {
+	if ("nullValue" in value) return null;
+	if ("booleanValue" in value) return value.booleanValue;
+	if ("integerValue" in value) return parseInt(value.integerValue, 10);
+	if ("doubleValue" in value) return value.doubleValue;
+	if ("timestampValue" in value) return new Date(value.timestampValue);
+	if ("stringValue" in value) return value.stringValue;
+	if ("bytesValue" in value) {
+		const binary = atob(value.bytesValue);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	}
+	if ("referenceValue" in value) return value.referenceValue;
+	if ("geoPointValue" in value) return new GeoPoint(value.geoPointValue.latitude, value.geoPointValue.longitude);
+	if ("arrayValue" in value) return (value.arrayValue.values ?? []).map(fromFirestoreValue);
+	if ("mapValue" in value) return fromFirestoreFields(value.mapValue.fields ?? {});
+	throw new Error("Unknown Firestore value type");
+}
+/**
+* Convert Firestore fields to JavaScript object.
+*/
+function fromFirestoreFields(fields) {
+	const result = {};
+	for (const [key, value] of Object.entries(fields)) result[key] = fromFirestoreValue(value);
+	return result;
+}
+
+//#endregion
+//#region src/references.ts
+/**
+* Document snapshot implementation.
+*/
+var DocumentSnapshotImpl = class {
+	constructor(doc, path) {
+		if (doc && doc.fields) {
+			this.exists = true;
+			this._data = fromFirestoreFields(doc.fields);
+			this.createTime = doc.createTime ? new Date(doc.createTime) : void 0;
+			this.updateTime = doc.updateTime ? new Date(doc.updateTime) : void 0;
+		} else {
+			this.exists = false;
+			this._data = void 0;
+		}
+		this.path = path;
+		this.id = extractDocumentId(path);
+	}
+	data() {
+		return this._data;
+	}
+	get(fieldPath) {
+		if (!this._data) return void 0;
+		const parts = fieldPath.split(".");
+		let current = this._data;
+		for (const part of parts) {
+			if (current === null || current === void 0) return void 0;
+			if (typeof current !== "object") return void 0;
+			current = current[part];
+		}
+		return current;
+	}
+};
+/**
+* A reference to a Firestore document.
+*/
+var DocumentReference = class {
+	constructor(_firestore, path) {
+		this._firestore = _firestore;
+		this.path = path;
+		this.id = extractDocumentId(path);
+	}
+	/**
+	* Get the parent collection reference.
+	*/
+	get parent() {
+		const { collection } = parseDocumentPath(this.path);
+		return new CollectionReference(this._firestore, collection);
+	}
+	/**
+	* Get a subcollection of this document.
+	*/
+	collection(collectionPath) {
+		return new CollectionReference(this._firestore, `${this.path}/${collectionPath}`);
+	}
+	/**
+	* Get the document.
+	*/
+	async get() {
+		return new DocumentSnapshotImpl(await this._firestore._getDocument(this.path), this.path);
+	}
+	/**
+	* Set the document data.
+	*/
+	async set(data, options) {
+		return this._firestore._setDocument(this.path, data, options);
+	}
+	/**
+	* Update the document data.
+	*/
+	async update(data) {
+		return this._firestore._updateDocument(this.path, data);
+	}
+	/**
+	* Delete the document.
+	*/
+	async delete() {
+		await this._firestore._deleteDocument(this.path);
+	}
+};
+/**
+* A reference to a Firestore collection.
+*/
+var CollectionReference = class {
+	constructor(_firestore, path) {
+		this._firestore = _firestore;
+		this.path = path;
+		const parts = path.split("/");
+		this.id = parts[parts.length - 1];
+	}
+	/**
+	* Get a document reference in this collection.
+	* If no ID is provided, a random one will be generated.
+	*/
+	doc(documentId) {
+		const docId = documentId ?? generateDocumentId();
+		return new DocumentReference(this._firestore, `${this.path}/${docId}`);
+	}
+	/**
+	* Add a new document with an auto-generated ID.
+	*/
+	async add(data) {
+		const ref = this.doc();
+		await ref.set(data);
+		return ref;
+	}
+};
+
+//#endregion
+//#region src/transaction.ts
+/**
+* Firestore Transaction
+*/
+/**
+* A Firestore transaction.
+* All reads must happen before any writes.
+*/
+var Transaction = class {
+	constructor(_firestore, _transactionId) {
+		this._firestore = _firestore;
+		this._transactionId = _transactionId;
+		this._writes = [];
+	}
+	/**
+	* Get a document within this transaction.
+	*/
+	async get(ref) {
+		return new DocumentSnapshotImpl(await this._firestore._getDocument(ref.path, this._transactionId), ref.path);
+	}
+	/**
+	* Queue a set operation.
+	*/
+	set(ref, data, options) {
+		const docName = this._firestore._getDocumentName(ref.path);
+		const fields = toFirestoreFields(data);
+		const transforms = extractFieldTransforms(data);
+		const write = { update: {
+			name: docName,
+			fields
+		} };
+		if (options?.merge) write.updateMask = { fieldPaths: getFieldPaths(data, "", isFieldValue) };
+		if (transforms.length > 0) write.updateTransforms = transforms;
+		this._writes.push(write);
+		return this;
+	}
+	/**
+	* Queue an update operation.
+	*/
+	update(ref, data) {
+		const docName = this._firestore._getDocumentName(ref.path);
+		const deleteFields = extractDeleteFields(data);
+		const transforms = extractFieldTransforms(data);
+		const fieldPaths = getFieldPaths(data, "", isFieldValue).filter((p) => !deleteFields.includes(p));
+		const write = {
+			update: {
+				name: docName,
+				fields: toFirestoreFields(data)
+			},
+			updateMask: { fieldPaths: [...fieldPaths, ...deleteFields] },
+			currentDocument: { exists: true }
+		};
+		if (transforms.length > 0) write.updateTransforms = transforms;
+		this._writes.push(write);
+		return this;
+	}
+	/**
+	* Queue a delete operation.
+	*/
+	delete(ref) {
+		const docName = this._firestore._getDocumentName(ref.path);
+		this._writes.push({ delete: docName });
+		return this;
+	}
+	/** @internal */
+	_getWrites() {
+		return this._writes;
+	}
+	/** @internal */
+	_getTransactionId() {
+		return this._transactionId;
+	}
+};
+
+//#endregion
+//#region src/client.ts
+/**
+* Firestore REST Client
+*
+* Main client implementation for Firestore REST API with transaction support.
+*/
+const API_BASE = "https://firestore.googleapis.com/v1";
+const DEFAULT_DATABASE = "(default)";
+/**
+* Firestore REST API client.
+*/
+var Firestore = class {
+	constructor(config, databaseId = DEFAULT_DATABASE) {
+		this._token = null;
+		this._tokenExpiry = 0;
+		this._config = config;
+		this._databaseId = databaseId;
+	}
+	/**
+	* Get a collection reference.
+	*/
+	collection(collectionPath) {
+		return new CollectionReference(this, collectionPath);
+	}
+	/**
+	* Get a document reference.
+	*/
+	doc(documentPath) {
+		return new DocumentReference(this, documentPath);
+	}
+	/**
+	* Run a transaction.
+	*/
+	async runTransaction(updateFn, options) {
+		const maxAttempts = options?.maxAttempts ?? 5;
+		let lastError = null;
+		let retryTransaction;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+			const transactionId = await this._beginTransaction(retryTransaction);
+			const transaction = new Transaction(this, transactionId);
+			const result = await updateFn(transaction);
+			await this._commitTransaction(transactionId, transaction._getWrites());
+			return result;
+		} catch (error) {
+			lastError = error;
+			if (error instanceof Error && error.message.includes("ABORTED")) {
+				retryTransaction = void 0;
+				continue;
+			}
+			throw error;
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("Transaction failed after max attempts");
+	}
+	/** @internal */
+	async _getToken() {
+		if (this._token && Date.now() < this._tokenExpiry - 6e4) return this._token;
+		this._token = await getFirestoreToken(this._config);
+		this._tokenExpiry = Date.now() + 3600 * 1e3;
+		return this._token;
+	}
+	/** @internal */
+	_getDatabasePath() {
+		return `projects/${this._config.projectId}/databases/${this._databaseId}`;
+	}
+	/** @internal */
+	_getDocumentName(path) {
+		return `${this._getDatabasePath()}/documents/${path}`;
+	}
+	/** @internal */
+	async _getDocument(path, transactionId) {
+		const token = await this._getToken();
+		let url = `${API_BASE}/${this._getDocumentName(path)}`;
+		if (transactionId) url += `?transaction=${encodeURIComponent(transactionId)}`;
+		const response = await fetch(url, {
+			method: "GET",
+			headers: { Authorization: `Bearer ${token}` }
+		});
+		if (response.status === 404) return null;
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to get document: ${JSON.stringify(error)}`);
+		}
+		return response.json();
+	}
+	/** @internal */
+	async _setDocument(path, data, options) {
+		const token = await this._getToken();
+		const database = this._getDatabasePath();
+		const docName = this._getDocumentName(path);
+		const fields = toFirestoreFields(data);
+		const transforms = extractFieldTransforms(data);
+		const writes = [{ update: {
+			name: docName,
+			fields
+		} }];
+		if (options?.merge) {
+			const fieldPaths = getFieldPaths(data, "", isFieldValue);
+			writes[0].updateMask = { fieldPaths };
+		}
+		if (transforms.length > 0) writes[0].updateTransforms = transforms;
+		const response = await fetch(`${API_BASE}/${database}/documents:commit`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ writes })
+		});
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to set document: ${JSON.stringify(error)}`);
+		}
+		return (await response.json()).writeResults?.[0] ?? {};
+	}
+	/** @internal */
+	async _updateDocument(path, data) {
+		const token = await this._getToken();
+		const database = this._getDatabasePath();
+		const docName = this._getDocumentName(path);
+		const deleteFields = extractDeleteFields(data);
+		const transforms = extractFieldTransforms(data);
+		const transformFields = extractTransformFields(data);
+		const fieldPaths = getFieldPaths(data, "", isFieldValue).filter((p) => !deleteFields.includes(p) && !transformFields.includes(p));
+		const fields = buildUpdateFields(data, toFirestoreValue, isFieldValue);
+		const updateMaskPaths = [...fieldPaths, ...deleteFields];
+		const writes = [];
+		if (updateMaskPaths.length > 0) {
+			const write = {
+				update: {
+					name: docName,
+					fields
+				},
+				updateMask: { fieldPaths: updateMaskPaths },
+				currentDocument: { exists: true }
+			};
+			writes.push(write);
+		}
+		if (transforms.length > 0) if (writes.length > 0) writes[0].updateTransforms = transforms;
+		else writes.push({
+			transform: {
+				document: docName,
+				fieldTransforms: transforms
+			},
+			currentDocument: { exists: true }
+		});
+		if (writes.length === 0) return {};
+		const response = await fetch(`${API_BASE}/${database}/documents:commit`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ writes })
+		});
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to update document: ${JSON.stringify(error)}`);
+		}
+		return (await response.json()).writeResults?.[0] ?? {};
+	}
+	/** @internal */
+	async _deleteDocument(path) {
+		const token = await this._getToken();
+		const database = this._getDatabasePath();
+		const docName = this._getDocumentName(path);
+		const response = await fetch(`${API_BASE}/${database}/documents:commit`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ writes: [{ delete: docName }] })
+		});
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to delete document: ${JSON.stringify(error)}`);
+		}
+	}
+	/** @internal */
+	async _beginTransaction(retryTransaction) {
+		const token = await this._getToken();
+		const database = this._getDatabasePath();
+		const options = { readWrite: retryTransaction ? { retryTransaction } : {} };
+		const response = await fetch(`${API_BASE}/${database}/documents:beginTransaction`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ options })
+		});
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to begin transaction: ${JSON.stringify(error)}`);
+		}
+		return (await response.json()).transaction;
+	}
+	/** @internal */
+	async _commitTransaction(transactionId, writes) {
+		const token = await this._getToken();
+		const database = this._getDatabasePath();
+		const response = await fetch(`${API_BASE}/${database}/documents:commit`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				writes,
+				transaction: transactionId
+			})
+		});
+		if (!response.ok) {
+			const error = await response.json();
+			throw new Error(`Failed to commit transaction: ${JSON.stringify(error)}`);
+		}
+		return response.json();
+	}
+};
+
+//#endregion
+export { CollectionReference, DocumentReference, FieldValue, Firestore, GeoPoint, Timestamp, Transaction, createJWT, fromFirestoreValue, getFirestoreToken, toFirestoreValue };
+//# sourceMappingURL=index.js.map