@hyper-fetch/firebase-admin 6.0.1 → 7.0.1

package/src/firestore/firestore.sockets.ts

@@ -1,24 +1,24 @@
-import { CollectionReference, DocumentReference, DocumentSnapshot, Firestore, Query } from "firebase-admin/firestore";
-import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
+import {
+  CollectionReference,
+  DocumentReference,
+  DocumentSnapshot,
+  Firestore,
+  Query,
+  QuerySnapshot,
+} from "firebase-admin/firestore";
+import { SocketAdapter } from "@hyper-fetch/sockets";
 
 import { getGroupedResultFirestore, getOrderedResultFirestore, getRef, applyFireStoreAdminConstraints } from "./utils";
-import { getStatus } from "utils";
 import { FirestoreAdminSocketAdapterType } from "adapter";
+import { getStatus } from "utils";
 
-export const firestoreAdminSockets = (database: Firestore): FirestoreAdminSocketAdapterType => {
-  return (socket) => {
-    const {
-      open,
-      connecting,
-      reconnectionAttempts,
-      listeners,
-      removeListener,
-      onReconnect,
-      onListen,
-      onEvent,
-      onError,
-    } = getSocketAdapterBindings(socket, { open: true });
-
+export const firestoreAdminSockets = (database: Firestore) => {
+  return (
+    new SocketAdapter({
+      name: "firebase-admin-firestore",
+      defaultConnected: true,
+    }) as unknown as FirestoreAdminSocketAdapterType
+  ).setConnector(({ socket, onReconnect, onListen, onEvent, onError }) => {
     const connect = () => {
       throw new Error("Connect function is not implemented for Firestore Admin socket.");
     };
@@ -28,11 +28,11 @@ export const firestoreAdminSockets = (database: Firestore): FirestoreAdminSocket
     };
 
     const reconnect = () => {
-      onReconnect(disconnect, connect);
+      onReconnect({ disconnect, connect });
     };
 
-    const listen: ReturnType<FirestoreAdminSocketAdapterType>["listen"] = (listener, callback) => {
-      const fullUrl = socket.url + listener.endpoint;
+    const listen: FirestoreAdminSocketAdapterType["listen"] = (listener, callback) => {
+      const fullUrl = socket.url + listener.topic;
       const { options } = listener;
       let pathRef: DocumentReference | Query = getRef(database, fullUrl);
       if (pathRef instanceof CollectionReference) {
@@ -44,20 +44,23 @@ export const firestoreAdminSockets = (database: Firestore): FirestoreAdminSocket
 
       unsubscribe = pathRef.onSnapshot(
         (snapshot) => {
-          const getSnapshotData = (s) => (s.data() ? { ...s.data(), __key: s.id } : null);
+          const getSnapshotData = (s: DocumentSnapshot) => (s.data() ? { ...s.data(), __key: s.id } : null);
           const response =
-            snapshot instanceof DocumentSnapshot ? getSnapshotData(snapshot) : getOrderedResultFirestore(snapshot);
+            snapshot instanceof DocumentSnapshot
+              ? getSnapshotData(snapshot)
+              : getOrderedResultFirestore(snapshot as QuerySnapshot);
           const status = getStatus(response);
-          const groupedResult = options?.groupByChangeType === true ? getGroupedResultFirestore(snapshot) : null;
+          const groupedResult =
+            options?.groupByChangeType === true ? getGroupedResultFirestore(snapshot as QuerySnapshot) : null;
           const extra = { ref: pathRef, snapshot, unsubscribe, groupedResult, status };
           callback({ data: response, extra });
-          onEvent(listener.endpoint, response, extra);
+          onEvent({ topic: listener.topic, data: response, extra });
         },
         (error) => {
-          onError(error);
+          onError({ error });
         },
       );
-      unmount = onListen(listener, callback, unsubscribe);
+      unmount = onListen({ listener, callback, onUnmount: unsubscribe });
       clearListeners = () => {
         unsubscribe();
         unmount();
@@ -71,16 +74,11 @@ export const firestoreAdminSockets = (database: Firestore): FirestoreAdminSocket
     };
 
     return {
-      open,
-      reconnectionAttempts,
-      listeners,
-      connecting,
-      listen,
-      removeListener,
-      emit,
       connect,
       reconnect,
       disconnect,
+      emit,
+      listen,
     };
-  };
+  });
 };

package/src/firestore/utils/constraints.utils.ts

@@ -1,12 +1,9 @@
-import { CollectionReference } from "firebase-admin/lib/firestore";
+import { Query } from "firebase-admin/firestore";
 import { OrderByDirection } from "firebase/firestore";
 
 import { FirestorePermittedMethods, FirestoreQueryConstraints, SharedQueryConstraints } from "../../constraints";
 
-export const applyFireStoreAdminConstraint = (
-  collectionRef: CollectionReference,
-  { type, values }: FirestorePermittedMethods,
-) => {
+export const applyFireStoreAdminConstraint = (collectionRef: Query, { type, values }: FirestorePermittedMethods) => {
   switch (type) {
     case FirestoreQueryConstraints.WHERE: {
       const [fieldPath, strOp, value] = values;
@@ -14,7 +11,7 @@ export const applyFireStoreAdminConstraint = (
     }
     case FirestoreQueryConstraints.ORDER_BY: {
       const [field, ord] = values;
-      return collectionRef.orderBy(field, ord as OrderByDirection);
+      return collectionRef.orderBy(field!, ord as OrderByDirection);
     }
     case FirestoreQueryConstraints.LIMIT: {
       const [limitValue] = values;
@@ -41,10 +38,7 @@ export const applyFireStoreAdminConstraint = (
   }
 };
 
-export const applyFireStoreAdminConstraints = (
-  collectionRef: CollectionReference,
-  constraints: FirestorePermittedMethods[],
-) => {
+export const applyFireStoreAdminConstraints = (collectionRef: Query, constraints: FirestorePermittedMethods[]) => {
   return constraints.reduce((collection, constraint) => {
     return applyFireStoreAdminConstraint(collection, constraint);
   }, collectionRef);

package/src/firestore/utils/ref.utils.ts

@@ -1,4 +1,4 @@
-import { CollectionReference, DocumentReference, Firestore } from "firebase-admin/lib/firestore";
+import { CollectionReference, DocumentReference, Firestore } from "firebase-admin/firestore";
 
 export const getRef = (db: Firestore, fullUrl: string) => {
   const withoutSurroundingSlashes = fullUrl.replace(/^\/|\/$/g, "");
@@ -6,14 +6,17 @@ export const getRef = (db: Firestore, fullUrl: string) => {
     return index % 2 === 0 ? ["collection", element] : ["doc", element];
   });
 
-  return urlParts.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 as unknown as Firestore | CollectionReference | DocumentReference) as CollectionReference | DocumentReference;
+  return urlParts.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 as unknown as Firestore | CollectionReference | DocumentReference,
+  ) as CollectionReference | DocumentReference;
 };

package/src/firestore/utils/result.utils.ts

@@ -1,13 +1,19 @@
-export const getOrderedResultFirestore = (snapshot: any) => {
-  const result = [];
+import { QuerySnapshot, DocumentData } from "firebase-admin/firestore";
+
+export const getOrderedResultFirestore = (snapshot: QuerySnapshot) => {
+  const result: (DocumentData & { __key: string })[] = [];
   snapshot.docs.forEach((d) => {
     result.push({ ...d.data(), __key: d.id });
   });
-  return result.length > 0 ? result : null;
+  return result;
 };
 
-export const getGroupedResultFirestore = (snapshot: any) => {
-  const groupedResult = { added: [], modified: [], removed: [] };
+export const getGroupedResultFirestore = (snapshot: QuerySnapshot) => {
+  const groupedResult: { added: DocumentData[]; modified: DocumentData[]; removed: DocumentData[] } = {
+    added: [],
+    modified: [],
+    removed: [],
+  };
   snapshot.docChanges().forEach((change) => {
     groupedResult[change.type].push(change.doc.data());
   });

package/src/realtime/realtime.methods.ts

@@ -1,5 +1,6 @@
+/* eslint-disable max-params */
 import { Database } from "firebase-admin/database";
-import { RequestInstance } from "@hyper-fetch/core";
+import { getAdapterBindings } from "@hyper-fetch/core";
 
 import { RealtimeDBMethodsUnion } from "adapter/types";
 import { getStatus, isDocOrQuery } from "utils";
@@ -11,26 +12,36 @@ import {
   SharedQueryConstraints,
 } from "constraints";
 
-export const getRealtimeDbAdminMethods = <R extends RequestInstance>(
-  request: R,
-  database: Database,
-  url: string,
+export const getRealtimeDbAdminMethods = ({
+  database,
+  url,
   onSuccess,
   onError,
-  resolve,
-  events: { onRequestStart; onResponseEnd; onResponseStart; onRequestEnd },
-): ((
+  onResponseStart,
+  onRequestStart,
+  onRequestEnd,
+  onResponseEnd,
+}: {
+  database: Database;
+  url: string;
+  onSuccess: Awaited<ReturnType<typeof getAdapterBindings>>["onSuccess"];
+  onError: Awaited<ReturnType<typeof getAdapterBindings>>["onError"];
+  onResponseStart: Awaited<ReturnType<typeof getAdapterBindings>>["onResponseStart"];
+  onRequestStart: Awaited<ReturnType<typeof getAdapterBindings>>["onRequestStart"];
+  onRequestEnd: Awaited<ReturnType<typeof getAdapterBindings>>["onRequestEnd"];
+  onResponseEnd: Awaited<ReturnType<typeof getAdapterBindings>>["onResponseEnd"];
+}): ((
   methodName: RealtimeDBMethodsUnion,
   data: {
     constraints: PermittedConstraints<RealtimePermittedMethods, RealtimeConstraintsUnion | SharedQueryConstraints>[];
-    data: any;
+    payload: any;
     options: Record<string, any>;
   },
 ) => Promise<void>) => {
   const [fullUrl] = url.split("?");
   const path = database.ref(fullUrl);
   const methods = {
-    get: async ({ constraints }) => {
+    get: async ({ constraints = [] }) => {
       const docOrQuery = isDocOrQuery(fullUrl);
       const q = applyRealtimeAdminConstraints(path, constraints);
       const snapshot = await q.get();
@@ -38,15 +49,15 @@ export const getRealtimeDbAdminMethods = <R extends RequestInstance>(
       const status = getStatus(res);
       return { result: res, status, extra: { ref: path, snapshot } };
     },
-    set: async ({ data }) => {
+    set: async ({ data }: { data?: any }) => {
       await path.set(data);
       return { result: data, status: "success", extra: { ref: path } };
     },
-    push: async ({ data }) => {
+    push: async ({ data }: { data?: any }) => {
       const resRef = await path.push(data);
       return { result: { ...data, __key: resRef.key }, status: "success", extra: { ref: resRef, key: resRef.key } };
     },
-    update: async ({ data }) => {
+    update: async ({ data }: { data?: any }) => {
       await path.update(data);
       return { result: data, status: "success", extra: { ref: path } };
     },
@@ -58,17 +69,17 @@ export const getRealtimeDbAdminMethods = <R extends RequestInstance>(
 
   return async (methodName: RealtimeDBMethodsUnion, data) => {
     try {
-      events.onRequestStart();
-      const { result, status, extra } = await methods[methodName](data);
-      events.onRequestEnd();
-      events.onResponseStart();
-      onSuccess(result, status, extra, resolve);
-      events.onResponseEnd();
-    } catch (e) {
-      events.onRequestEnd();
-      events.onResponseStart();
-      onError(e, "error", {}, resolve);
-      events.onResponseEnd();
+      onRequestStart();
+      const { result, status, extra } = await methods[methodName](data as any);
+      onRequestEnd();
+      onResponseStart();
+      onSuccess({ data: result, status, extra });
+      onResponseEnd();
+    } catch (error) {
+      onRequestEnd();
+      onResponseStart();
+      onError({ error, status: "error", extra: {} });
+      onResponseEnd();
     }
   };
 };

package/src/realtime/realtime.sockets.ts

@@ -1,95 +1,81 @@
-import { Database } from "firebase-admin/lib/database";
-import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
+import { Database, DataSnapshot } from "firebase-admin/database";
+import { SocketAdapter } from "@hyper-fetch/sockets";
 
 import { applyRealtimeAdminConstraints, getOrderedResultRealtime } from "./utils";
 import { getStatus, isDocOrQuery } from "utils";
 import { RealtimeAdminOnValueMethodExtra, RealtimeAdminSocketAdapterType } from "adapter";
 
-export const realtimeSocketsAdmin = (database: Database): RealtimeAdminSocketAdapterType => {
-  return (socket) => {
-    const {
-      open,
-      connecting,
-      reconnectionAttempts,
-      listeners,
-      removeListener,
-      onConnect,
-      onReconnect,
-      onDisconnect,
-      onListen,
-      onOpen,
-      onClose,
-      onEvent,
-      onError,
-    } = getSocketAdapterBindings(socket, { open: true });
+export const realtimeSocketsAdmin = (database: Database) => {
+  return (
+    new SocketAdapter({
+      name: "firebase-admin-realtime",
+      defaultConnected: true,
+    }) as unknown as RealtimeAdminSocketAdapterType
+  ).setConnector(
+    ({ socket, onReconnect, onConnect, onConnected, onDisconnect, onDisconnected, onListen, onEvent, onError }) => {
+      const connect = async () => {
+        const enabled = onConnect();
 
-    const connect = () => {
-      const enabled = onConnect();
+        if (enabled) {
+          database.goOnline();
+          onConnected();
+        }
+      };
 
-      if (enabled) {
-        database.goOnline();
-        onOpen();
-      }
-    };
+      const disconnect = async () => {
+        database.goOffline();
+        onDisconnect();
+        onDisconnected();
+      };
 
-    const disconnect = () => {
-      database.goOffline();
-      onDisconnect();
-      onClose();
-    };
+      const reconnect = () => {
+        onReconnect({ disconnect, connect });
+      };
 
-    const reconnect = () => {
-      onReconnect(disconnect, connect);
-    };
+      const listen: RealtimeAdminSocketAdapterType["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 || []);
+        const method = onlyOnce === true ? "once" : "on";
+        q[method](
+          "value",
+          (snapshot) => {
+            const getSnapshotData = (s: DataSnapshot) => (s.val() ? { ...s.val(), __key: s.key } : null);
+            const response =
+              isDocOrQuery(fullUrl) === "doc" ? getSnapshotData(snapshot) : getOrderedResultRealtime(snapshot);
+            const status = getStatus(response);
+            const extra: RealtimeAdminOnValueMethodExtra = { ref: path, snapshot, status };
+            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 listen: ReturnType<RealtimeAdminSocketAdapterType>["listen"] = (listener, callback) => {
-      const fullUrl = socket.url + listener.endpoint;
-      const path = database.ref(fullUrl);
-      const { options } = listener;
-      const onlyOnce = options?.onlyOnce || false;
-      const q = applyRealtimeAdminConstraints(path, options?.constraints || []);
-      const method = onlyOnce === true ? "once" : "on";
-      q[method](
-        "value",
-        (snapshot) => {
-          const getSnapshotData = (s) => (s.val() ? { ...s.val(), __key: s.key } : null);
-          const response =
-            isDocOrQuery(fullUrl) === "doc" ? getSnapshotData(snapshot) : getOrderedResultRealtime(snapshot);
-          const status = getStatus(response);
-          const extra: RealtimeAdminOnValueMethodExtra = { ref: path, snapshot, status };
-          callback({ data: response, extra });
-          onEvent(listener.endpoint, response, extra);
-        },
-        (error) => {
-          onError(error);
-        },
-      );
-      const unsubscribe = () => q.off("value");
-      const unmount = onListen(listener, callback, unsubscribe);
+        const clearListeners = () => {
+          unsubscribe();
+          unmount();
+        };
 
-      const clearListeners = () => {
-        unsubscribe();
-        unmount();
+        return clearListeners;
       };
 
-      return clearListeners;
-    };
-
-    const emit = async () => {
-      throw new Error("Cannot emit from Realtime database socket.");
-    };
+      const emit = async () => {
+        throw new Error("Cannot emit from Realtime database socket.");
+      };
 
-    return {
-      open,
-      reconnectionAttempts,
-      listeners,
-      connecting,
-      listen,
-      removeListener,
-      emit,
-      connect,
-      reconnect,
-      disconnect,
-    };
-  };
+      return {
+        connect,
+        reconnect,
+        disconnect,
+        listen,
+        emit,
+      };
+    },
+  );
 };

package/src/realtime/utils/constraints.utils.ts

@@ -1,8 +1,8 @@
-import { Reference } from "firebase-admin/lib/database";
+import { Query } from "firebase-admin/database";
 
 import { RealtimePermittedMethods, RealtimeQueryConstraints, SharedQueryConstraints } from "constraints";
 
-export const applyRealtimeAdminConstraint = (ref: Reference, { type, values }: RealtimePermittedMethods) => {
+export const applyRealtimeAdminConstraint = (ref: Query, { type, values }: RealtimePermittedMethods) => {
   switch (type) {
     case RealtimeQueryConstraints.ORDER_BY_CHILD: {
       const [value] = values;
@@ -47,7 +47,7 @@ export const applyRealtimeAdminConstraint = (ref: Reference, { type, values }: R
   }
 };
 
-export const applyRealtimeAdminConstraints = (ref: Reference, constraints: RealtimePermittedMethods[]) => {
+export const applyRealtimeAdminConstraints = (ref: Query, constraints: RealtimePermittedMethods[]) => {
   return constraints.reduce((collection, constraint) => {
     return applyRealtimeAdminConstraint(collection, constraint);
   }, ref);

package/src/realtime/utils/result.utils.ts

@@ -1,5 +1,7 @@
-export const getOrderedResultRealtime = (snapshot: any) => {
-  const res = [];
+import { DataSnapshot } from "firebase-admin/database";
+
+export const getOrderedResultRealtime = (snapshot: DataSnapshot) => {
+  const res: any = [];
   snapshot.forEach((child) => {
     res.push({ ...child.val(), __key: child.key });
   });

package/src/utils/cache.utils.ts

@@ -1,9 +1,15 @@
-import { RequestInstance } from "@hyper-fetch/core";
+import { ClientInstance, RequestInstance } from "@hyper-fetch/core";
 
-export const setCacheManually = <R extends RequestInstance>(
-  request: R,
+import { FirestoreAdapterType } from "adapter";
+
+export const setCacheManually = (
+  request: RequestInstance<{
+    client: ClientInstance<{
+      adapter: FirestoreAdapterType;
+    }>;
+  }>,
   response: { value: any; status: "success" | "error" | "emptyResource" },
-  extra,
+  extra: any,
 ) => {
   if (["success", "emptyResource"].includes(response.status)) {
     request.client.cache.set(request, {
@@ -15,19 +21,25 @@ export const setCacheManually = <R extends RequestInstance>(
       isCanceled: false,
       isOffline: false,
       retries: 0,
-      timestamp: +new Date(),
+      requestTimestamp: +new Date(),
+      responseTimestamp: +new Date(),
+      addedTimestamp: +new Date(),
+      triggerTimestamp: +new Date(),
     });
   } else {
     request.client.cache.set(request, {
       data: null,
-      status: "error",
+      status: "error" as const,
       error: response.value,
       success: false,
       extra,
       isCanceled: false,
       isOffline: false,
       retries: 0,
-      timestamp: +new Date(),
+      requestTimestamp: +new Date(),
+      responseTimestamp: +new Date(),
+      addedTimestamp: +new Date(),
+      triggerTimestamp: +new Date(),
     });
   }
 };

package/tsconfig.json

@@ -4,5 +4,5 @@
     "rootDir": ".",
     "baseUrl": "./src"
   },
-  "exclude": ["dist", "jest.config.ts"]
+  "exclude": ["node_modules", "dist", "jest.config.ts", "__tests__"]
 }