@hyper-fetch/firebase-admin 7.5.3 → 8.0.0

package/dist/index.mjs

@@ -0,0 +1,670 @@
+import { CollectionReference, DocumentSnapshot, Firestore } from "firebase-admin/firestore";
+import { SocketAdapter } from "@hyper-fetch/sockets";
+import { Adapter } from "@hyper-fetch/core";
+//#region src/adapter/types/adapter.firestore.types.ts
+var FirestoreMethods = /* @__PURE__ */ function(FirestoreMethods) {
+	FirestoreMethods["addDoc"] = "addDoc";
+	FirestoreMethods["getDoc"] = "getDoc";
+	FirestoreMethods["getDocs"] = "getDocs";
+	FirestoreMethods["setDoc"] = "setDoc";
+	FirestoreMethods["updateDoc"] = "updateDoc";
+	FirestoreMethods["deleteDoc"] = "deleteDoc";
+	return FirestoreMethods;
+}({});
+//#endregion
+//#region src/adapter/types/adapter.realtime.types.ts
+var RealtimeDBMethods = /* @__PURE__ */ function(RealtimeDBMethods) {
+	RealtimeDBMethods["set"] = "set";
+	RealtimeDBMethods["push"] = "push";
+	RealtimeDBMethods["update"] = "update";
+	RealtimeDBMethods["get"] = "get";
+	RealtimeDBMethods["remove"] = "remove";
+	return RealtimeDBMethods;
+}({});
+//#endregion
+//#region src/firestore/utils/result.utils.ts
+var getOrderedResultFirestore = (snapshot) => {
+	const result = [];
+	snapshot.docs.forEach((d) => {
+		result.push({
+			...d.data(),
+			__key: d.id
+		});
+	});
+	return result;
+};
+var getGroupedResultFirestore = (snapshot) => {
+	const groupedResult = {
+		added: [],
+		modified: [],
+		removed: []
+	};
+	snapshot.docChanges().forEach((change) => {
+		groupedResult[change.type].push(change.doc.data());
+	});
+	return [
+		...groupedResult.added,
+		...groupedResult.modified,
+		...groupedResult.removed
+	].length > 0 ? groupedResult : null;
+};
+//#endregion
+//#region src/firestore/utils/ref.utils.ts
+var getRef = (db, fullUrl) => {
+	return fullUrl.replace(/^\/|\/$/g, "").split("/").map((element, index) => {
+		return index % 2 === 0 ? ["collection", element] : ["doc", element];
+	}).reduce((_db, value) => {
+		const [method, pathPart] = value;
+		if (method === "doc" && "doc" in _db) return _db.doc(pathPart);
+		if (method === "collection" && "collection" in _db) return _db.collection(pathPart);
+		return _db;
+	}, db);
+};
+//#endregion
+//#region src/constraints/firebase.constraints.ts
+var SharedQueryConstraints = /* @__PURE__ */ function(SharedQueryConstraints) {
+	SharedQueryConstraints["START_AT"] = "startAt";
+	SharedQueryConstraints["START_AFTER"] = "startAfter";
+	SharedQueryConstraints["END_AT"] = "endAt";
+	SharedQueryConstraints["END_BEFORE"] = "endBefore";
+	return SharedQueryConstraints;
+}({});
+var RealtimeQueryConstraints = /* @__PURE__ */ function(RealtimeQueryConstraints) {
+	RealtimeQueryConstraints["ORDER_BY_CHILD"] = "orderByChild";
+	RealtimeQueryConstraints["ORDER_BY_KEY"] = "orderByKey";
+	RealtimeQueryConstraints["ORDER_BY_VALUE"] = "orderByValue";
+	RealtimeQueryConstraints["LIMIT_TO_FIRST"] = "limitToFirst";
+	RealtimeQueryConstraints["LIMIT_TO_LAST"] = "limitToLast";
+	RealtimeQueryConstraints["EQUAL_TO"] = "equalTo";
+	return RealtimeQueryConstraints;
+}({});
+var FirestoreQueryConstraints = /* @__PURE__ */ function(FirestoreQueryConstraints) {
+	FirestoreQueryConstraints["WHERE"] = "where";
+	FirestoreQueryConstraints["ORDER_BY"] = "orderBy";
+	FirestoreQueryConstraints["LIMIT"] = "limit";
+	return FirestoreQueryConstraints;
+}({});
+var $where = (fieldPath, opStr, value) => {
+	return {
+		toString: () => `${FirestoreQueryConstraints.WHERE}_${fieldPath}${opStr}${value}`,
+		type: FirestoreQueryConstraints.WHERE,
+		values: [
+			fieldPath,
+			opStr,
+			value
+		]
+	};
+};
+var $orderBy = (fieldPath, directionStr) => {
+	return {
+		toString: () => `${FirestoreQueryConstraints.ORDER_BY}_${fieldPath}_${directionStr || ""}`,
+		type: FirestoreQueryConstraints.ORDER_BY,
+		values: [fieldPath, directionStr]
+	};
+};
+var $limit = (num) => {
+	return {
+		toString: () => `${FirestoreQueryConstraints.LIMIT}_${num}`,
+		type: FirestoreQueryConstraints.LIMIT,
+		values: [num]
+	};
+};
+var startEndConstraintsImpl = (constraintType) => {
+	return (...docOrFields) => {
+		if (docOrFields.length === 1 && docOrFields[0].query) return {
+			toString: () => `${constraintType}_${docOrFields[0].query?._query?.memoizedTarget?.memoizedCanonicalId}`,
+			type: constraintType,
+			values: [docOrFields]
+		};
+		return {
+			toString: () => `${constraintType}_${docOrFields}`,
+			type: constraintType,
+			values: [docOrFields]
+		};
+	};
+};
+var $startAt = startEndConstraintsImpl(SharedQueryConstraints.START_AT);
+var $startAfter = startEndConstraintsImpl(SharedQueryConstraints.START_AFTER);
+var $endAt = startEndConstraintsImpl(SharedQueryConstraints.END_AT);
+var $endBefore = startEndConstraintsImpl(SharedQueryConstraints.END_BEFORE);
+var $orderByChild = (path) => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.ORDER_BY_CHILD}_${path}`,
+		type: RealtimeQueryConstraints.ORDER_BY_CHILD,
+		values: [path]
+	};
+};
+var $orderByKey = () => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.ORDER_BY_KEY}`,
+		type: RealtimeQueryConstraints.ORDER_BY_KEY,
+		values: []
+	};
+};
+var $orderByValue = () => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.ORDER_BY_VALUE}`,
+		type: RealtimeQueryConstraints.ORDER_BY_VALUE,
+		values: []
+	};
+};
+var $limitToFirst = (num) => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.LIMIT_TO_FIRST}_${num}`,
+		type: RealtimeQueryConstraints.LIMIT_TO_FIRST,
+		values: [num]
+	};
+};
+var $limitToLast = (num) => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.LIMIT_TO_LAST}_${num}`,
+		type: RealtimeQueryConstraints.LIMIT_TO_LAST,
+		values: [num]
+	};
+};
+var $equalTo = (value) => {
+	return {
+		toString: () => `${RealtimeQueryConstraints.LIMIT_TO_LAST}_${value}`,
+		type: RealtimeQueryConstraints.EQUAL_TO,
+		values: [value]
+	};
+};
+//#endregion
+//#region src/firestore/utils/constraints.utils.ts
+var applyFireStoreAdminConstraint = (collectionRef, { type, values }) => {
+	switch (type) {
+		case FirestoreQueryConstraints.WHERE: {
+			const [fieldPath, strOp, value] = values;
+			return collectionRef.where(fieldPath, strOp, value);
+		}
+		case FirestoreQueryConstraints.ORDER_BY: {
+			const [field, ord] = values;
+			return collectionRef.orderBy(field, ord);
+		}
+		case FirestoreQueryConstraints.LIMIT: {
+			const [limitValue] = values;
+			return collectionRef.limit(limitValue);
+		}
+		case SharedQueryConstraints.START_AT: {
+			const [docOrFields] = values;
+			return collectionRef.startAt(docOrFields);
+		}
+		case SharedQueryConstraints.START_AFTER: {
+			const [docOrFields] = values;
+			return collectionRef.startAfter(docOrFields);
+		}
+		case SharedQueryConstraints.END_AT: {
+			const [docOrFields] = values;
+			return collectionRef.endAt(docOrFields);
+		}
+		case SharedQueryConstraints.END_BEFORE: {
+			const [docOrFields] = values;
+			return collectionRef.endBefore(docOrFields);
+		}
+		default: throw new Error(`Unknown method ${type}`);
+	}
+};
+var applyFireStoreAdminConstraints = (collectionRef, constraints) => {
+	return constraints.reduce((collection, constraint) => {
+		return applyFireStoreAdminConstraint(collection, constraint);
+	}, collectionRef);
+};
+//#endregion
+//#region src/utils/misc.ts
+var getStatus = (res) => {
+	return Array.isArray(res) && res.length === 0 || res == null ? "emptyResource" : "success";
+};
+var isDocOrQuery = (fullUrl) => {
+	return fullUrl.replace(/^\/|\/$/g, "").split("/").length % 2 === 0 ? "doc" : "query";
+};
+//#endregion
+//#region src/firestore/firestore.sockets.ts
+var firestoreAdminSockets = (database) => {
+	return new SocketAdapter({
+		name: "firebase-admin-firestore",
+		defaultConnected: true
+	}).setConnector(({ socket, onReconnect, onListen, onEvent, onError }) => {
+		const connect = () => {
+			throw new Error("Connect function is not implemented for Firestore Admin socket.");
+		};
+		const disconnect = () => {
+			throw new Error("Cannot disconnect from Firestore database socket. Use 'app.delete()' instead.");
+		};
+		const reconnect = () => {
+			onReconnect({
+				disconnect,
+				connect
+			});
+		};
+		const listen = (listener, callback) => {
+			const fullUrl = socket.url + listener.topic;
+			const { options } = listener;
+			let pathRef = getRef(database, fullUrl);
+			if (pathRef instanceof CollectionReference) pathRef = applyFireStoreAdminConstraints(pathRef, options?.constraints || []);
+			let unsubscribe = () => {};
+			let unmount = () => {};
+			let clearListeners = () => {};
+			unsubscribe = pathRef.onSnapshot((snapshot) => {
+				const getSnapshotData = (s) => s.data() ? {
+					...s.data(),
+					__key: s.id
+				} : null;
+				const response = snapshot instanceof DocumentSnapshot ? getSnapshotData(snapshot) : getOrderedResultFirestore(snapshot);
+				const status = getStatus(response);
+				const groupedResult = options?.groupByChangeType === true ? getGroupedResultFirestore(snapshot) : null;
+				const extra = {
+					ref: pathRef,
+					snapshot,
+					unsubscribe,
+					groupedResult,
+					status
+				};
+				callback({
+					data: response,
+					extra
+				});
+				onEvent({
+					topic: listener.topic,
+					data: response,
+					extra
+				});
+			}, (error) => {
+				onError({ error });
+			});
+			unmount = onListen({
+				listener,
+				callback,
+				onUnmount: unsubscribe
+			});
+			clearListeners = () => {
+				unsubscribe();
+				unmount();
+			};
+			return clearListeners;
+		};
+		const emit = async () => {
+			throw new Error("Cannot emit from Firestore database socket.");
+		};
+		return {
+			connect,
+			reconnect,
+			disconnect,
+			emit,
+			listen
+		};
+	});
+};
+//#endregion
+//#region src/firestore/firestore.methods.ts
+var getFirestoreAdminMethods = ({ database, url, onSuccess, onError, onResponseStart, onRequestStart, onRequestEnd, onResponseEnd }) => {
+	const [cleanUrl] = url.split("?");
+	const methods = {
+		getDoc: async () => {
+			const path = getRef(database, cleanUrl);
+			const snapshot = await path.get();
+			const result = snapshot.data() ? {
+				...snapshot.data(),
+				__key: snapshot.id
+			} : null;
+			return {
+				result,
+				status: result ? "success" : "emptyResource",
+				extra: {
+					ref: path,
+					snapshot
+				}
+			};
+		},
+		getDocs: async ({ constraints = [] }) => {
+			const path = getRef(database, cleanUrl);
+			const querySnapshot = await applyFireStoreAdminConstraints(path, constraints).get();
+			const result = getOrderedResultFirestore(querySnapshot);
+			return {
+				result,
+				status: getStatus(result),
+				extra: {
+					ref: path,
+					snapshot: querySnapshot
+				}
+			};
+		},
+		setDoc: async ({ data, options }) => {
+			const path = getRef(database, cleanUrl);
+			const merge = options?.merge === true;
+			return {
+				result: await path.set(data, { merge }),
+				status: "success",
+				extra: { ref: path }
+			};
+		},
+		addDoc: async ({ data }) => {
+			const docRef = await getRef(database, cleanUrl).add(data);
+			return {
+				result: {
+					...data,
+					__key: docRef.id
+				},
+				status: "success",
+				extra: { ref: docRef }
+			};
+		},
+		updateDoc: async ({ data }) => {
+			const path = getRef(database, cleanUrl);
+			await path.update(data);
+			return {
+				result: data,
+				status: "success",
+				extra: { ref: path }
+			};
+		},
+		deleteDoc: async () => {
+			const path = getRef(database, cleanUrl);
+			await path.delete();
+			return {
+				result: null,
+				status: "success",
+				extra: { ref: path }
+			};
+		}
+	};
+	return async (methodName, data) => {
+		try {
+			onRequestStart();
+			const { result, status, extra } = await methods[methodName](data);
+			onRequestEnd();
+			onResponseStart();
+			onSuccess({
+				data: result,
+				status,
+				extra
+			});
+			onResponseEnd();
+		} catch (error) {
+			onRequestEnd();
+			onResponseStart();
+			onError({
+				error,
+				status: "error",
+				extra: {}
+			});
+			onResponseEnd();
+		}
+	};
+};
+//#endregion
+//#region src/realtime/utils/result.utils.ts
+var getOrderedResultRealtime = (snapshot) => {
+	const res = [];
+	snapshot.forEach((child) => {
+		res.push({
+			...child.val(),
+			__key: child.key
+		});
+	});
+	return res.length > 0 ? res : null;
+};
+//#endregion
+//#region src/realtime/utils/constraints.utils.ts
+var applyRealtimeAdminConstraint = (ref, { type, values }) => {
+	switch (type) {
+		case RealtimeQueryConstraints.ORDER_BY_CHILD: {
+			const [value] = values;
+			return ref.orderByChild(value);
+		}
+		case RealtimeQueryConstraints.ORDER_BY_KEY: return ref.orderByKey();
+		case RealtimeQueryConstraints.ORDER_BY_VALUE: return ref.orderByValue();
+		case SharedQueryConstraints.START_AT: {
+			const [[value]] = values;
+			return ref.startAt(value);
+		}
+		case SharedQueryConstraints.START_AFTER: {
+			const [[value]] = values;
+			return ref.startAfter(value);
+		}
+		case SharedQueryConstraints.END_AT: {
+			const [[value]] = values;
+			return ref.endAt(value);
+		}
+		case SharedQueryConstraints.END_BEFORE: {
+			const [[value]] = values;
+			return ref.endBefore(value);
+		}
+		case RealtimeQueryConstraints.LIMIT_TO_FIRST: {
+			const [value] = values;
+			return ref.limitToFirst(value);
+		}
+		case RealtimeQueryConstraints.LIMIT_TO_LAST: {
+			const [value] = values;
+			return ref.limitToLast(value);
+		}
+		case RealtimeQueryConstraints.EQUAL_TO: {
+			const [value] = values;
+			return ref.equalTo(value);
+		}
+		default: throw new Error(`Unknown method ${type}`);
+	}
+};
+var applyRealtimeAdminConstraints = (ref, constraints) => {
+	return constraints.reduce((collection, constraint) => {
+		return applyRealtimeAdminConstraint(collection, constraint);
+	}, ref);
+};
+//#endregion
+//#region src/realtime/realtime.methods.ts
+var getRealtimeDbAdminMethods = ({ database, url, onSuccess, onError, onResponseStart, onRequestStart, onRequestEnd, onResponseEnd }) => {
+	const [fullUrl] = url.split("?");
+	const path = database.ref(fullUrl);
+	const methods = {
+		get: async ({ constraints = [] }) => {
+			const docOrQuery = isDocOrQuery(fullUrl);
+			const snapshot = await applyRealtimeAdminConstraints(path, constraints).get();
+			const res = docOrQuery === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
+			return {
+				result: res,
+				status: getStatus(res),
+				extra: {
+					ref: path,
+					snapshot
+				}
+			};
+		},
+		set: async ({ data }) => {
+			await path.set(data);
+			return {
+				result: data,
+				status: "success",
+				extra: { ref: path }
+			};
+		},
+		push: async ({ data }) => {
+			const resRef = await path.push(data);
+			return {
+				result: {
+					...data,
+					__key: resRef.key
+				},
+				status: "success",
+				extra: {
+					ref: resRef,
+					key: resRef.key
+				}
+			};
+		},
+		update: async ({ data }) => {
+			await path.update(data);
+			return {
+				result: data,
+				status: "success",
+				extra: { ref: path }
+			};
+		},
+		remove: async () => {
+			await path.remove();
+			return {
+				result: null,
+				status: "success",
+				extra: { ref: path }
+			};
+		}
+	};
+	return async (methodName, data) => {
+		try {
+			onRequestStart();
+			const { result, status, extra } = await methods[methodName](data);
+			onRequestEnd();
+			onResponseStart();
+			onSuccess({
+				data: result,
+				status,
+				extra
+			});
+			onResponseEnd();
+		} catch (error) {
+			onRequestEnd();
+			onResponseStart();
+			onError({
+				error,
+				status: "error",
+				extra: {}
+			});
+			onResponseEnd();
+		}
+	};
+};
+//#endregion
+//#region src/realtime/realtime.sockets.ts
+var realtimeSocketsAdmin = (database) => {
+	return new SocketAdapter({
+		name: "firebase-admin-realtime",
+		defaultConnected: true
+	}).setConnector(({ socket, onReconnect, onConnect, onConnected, onDisconnect, onDisconnected, onListen, onEvent, onError }) => {
+		const connect = async () => {
+			if (onConnect()) {
+				database.goOnline();
+				onConnected();
+			}
+		};
+		const disconnect = async () => {
+			database.goOffline();
+			onDisconnect();
+			onDisconnected();
+		};
+		const reconnect = () => {
+			onReconnect({
+				disconnect,
+				connect
+			});
+		};
+		const listen = (listener, callback) => {
+			const fullUrl = socket.url + listener.topic;
+			const path = database.ref(fullUrl);
+			const { options } = listener;
+			const onlyOnce = options?.onlyOnce || false;
+			const q = applyRealtimeAdminConstraints(path, options?.constraints || []);
+			q[onlyOnce === true ? "once" : "on"]("value", (snapshot) => {
+				const getSnapshotData = (s) => s.val() ? {
+					...s.val(),
+					__key: s.key
+				} : null;
+				const response = isDocOrQuery(fullUrl) === "doc" ? getSnapshotData(snapshot) : getOrderedResultRealtime(snapshot);
+				const extra = {
+					ref: path,
+					snapshot,
+					status: getStatus(response)
+				};
+				callback({
+					data: response,
+					extra
+				});
+				onEvent({
+					topic: listener.topic,
+					data: response,
+					extra
+				});
+			}, (error) => {
+				onError({ error });
+			});
+			const unsubscribe = () => q.off("value");
+			const unmount = onListen({
+				listener,
+				callback,
+				onUnmount: unsubscribe
+			});
+			const clearListeners = () => {
+				unsubscribe();
+				unmount();
+			};
+			return clearListeners;
+		};
+		const emit = async () => {
+			throw new Error("Cannot emit from Realtime database socket.");
+		};
+		return {
+			connect,
+			reconnect,
+			disconnect,
+			listen,
+			emit
+		};
+	});
+};
+//#endregion
+//#region src/adapter/adapter.sockets.ts
+var FirebaseSocketsAdminAdapter = (database) => {
+	if (database instanceof Firestore) return firestoreAdminSockets(database);
+	return realtimeSocketsAdmin(database);
+};
+//#endregion
+//#region src/adapter/adapter.ts
+var FirebaseAdminAdapter = (database) => {
+	return new Adapter({
+		name: "firebase-admin",
+		defaultMethod: "getDoc",
+		defaultExtra: {},
+		systemErrorStatus: "error",
+		systemErrorExtra: {}
+	}).setFetcher(async ({ request, onSuccess, onError, onResponseStart, onResponseEnd, onRequestStart, onRequestEnd }) => {
+		const fullUrl = `${request.client.url}${request.endpoint}`;
+		if (database instanceof Firestore) {
+			const { method = FirestoreMethods.getDocs, queryParams, payload, options } = request;
+			const availableMethods = getFirestoreAdminMethods({
+				database,
+				url: fullUrl,
+				onSuccess,
+				onError,
+				onRequestStart,
+				onResponseEnd,
+				onResponseStart,
+				onRequestEnd
+			});
+			if (!Object.values(FirestoreMethods).includes(method)) throw new Error(`Cannot find method ${method} in Firestore available methods.`);
+			availableMethods(method, {
+				constraints: queryParams?.constraints ? queryParams.constraints : [],
+				payload,
+				options
+			});
+		} else {
+			const { method = RealtimeDBMethods.get, queryParams, payload, options } = request;
+			const availableMethods = getRealtimeDbAdminMethods({
+				database,
+				url: fullUrl,
+				onSuccess,
+				onError,
+				onRequestStart,
+				onResponseEnd,
+				onResponseStart,
+				onRequestEnd
+			});
+			if (!Object.values(RealtimeDBMethods).includes(method)) throw new Error(`Cannot find method ${method} in Realtime database available methods.`);
+			availableMethods(method, {
+				constraints: queryParams?.constraints ? queryParams.constraints : [],
+				options,
+				payload
+			});
+		}
+	});
+};
+//#endregion
+export { $endAt, $endBefore, $equalTo, $limit, $limitToFirst, $limitToLast, $orderBy, $orderByChild, $orderByKey, $orderByValue, $startAfter, $startAt, $where, FirebaseAdminAdapter, FirebaseSocketsAdminAdapter, FirestoreMethods, FirestoreQueryConstraints, RealtimeDBMethods, RealtimeQueryConstraints, SharedQueryConstraints, applyFireStoreAdminConstraint, applyFireStoreAdminConstraints, applyRealtimeAdminConstraint, applyRealtimeAdminConstraints, firestoreAdminSockets, getFirestoreAdminMethods, getGroupedResultFirestore, getOrderedResultFirestore, getOrderedResultRealtime, getRealtimeDbAdminMethods, getRef, realtimeSocketsAdmin };
+
+//# sourceMappingURL=index.mjs.map