@edgedev/firebase 1.1.6 → 1.2.2

package/README.md

@@ -16,23 +16,80 @@ pnpm install @edgedev/firebase
 ```bash
 pnpm install @edgedev/firebase
 ```
-If installing into a Nuxt 3 project, you can make this globally avaiable by adding a file (whatever.ts) to your "composables" folder with the code below. 
+### Installing with Nuxt 3 global composables
+
+Add a file (whatever.ts) to your "composables" folder with this code:
 
 ```typescript
-import * as edgeFirebase from "@edgedev/firebase";
+import { EdgeFirebase } from "@edgedev/firebase";
+const config = {
+    apiKey: "your-apiKey",
+    authDomain: "your-authDomain",
+    projectId: "your-projectId",
+    storageBucket: "your-storageBucket",
+    messagingSenderId: "your-messagingSenderId",
+    appId: "your-appId"
+  };
+const edgeFirebase = new EdgeFirebase(config);
 export { edgeFirebase };
 ```
 
-Also if on Nuxt 3 - SSR must be disabled, update the nuxt.config.ts file:
+##### *Nuxt must be configured with SSR disabled, update the nuxt.config.ts file (if other parts of your project SSR, see Nuxt 3 plugin instuctions):
+```javascript
+export default defineNuxtConfig({ ssr: false });
+```
+
+### Installing as a plugin
+
+#### Vue 3 plugin, main.js example:
+```javascript
+import { createApp } from "vue";
+import App from "./App.vue";
+
+//edgeFirebase Plugin 
+import eFb from "@edgedev/firebase";
+app.use(eFb, {
+    apiKey: "your-apiKey",
+    authDomain: "your-authDomain",
+    projectId: "your-projectId",
+    storageBucket: "your-storageBucket",
+    messagingSenderId: "your-messagingSenderId",
+    appId: "your-appId"
+  })
+//end edgeFirebase
+
+app.mount("#app");
+```
+
+#### Nuxt 3 example using the plugins folder:
+Add a file (whatever**.client**.ts) to your "plugins" folder with the following code:
+
+***-Note the ".client" in the file name. If the file doesn't have that in the name you must disabled SSR in the nuxt config.***
+```javascript
+import eFb from "@edgedev/firebase";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.use(eFb, {
+    apiKey: "your-apiKey",
+    authDomain: "your-authDomain",
+    projectId: "your-projectId",
+    storageBucket: "your-storageBucket",
+    messagingSenderId: "your-messagingSenderId",
+    appId: "your-appId"
+  });
+});
+```
+***-Alternatively you can disable SSR for your entire Nuxt project instead of naming the plugin with ".client", update the nuxt.config.ts file:***
+
 ```javascript
 export default defineNuxtConfig({ ssr: false });
 ```
 
-If not in Nuxt 3 or there is no need for it to be global, put this in your components <script setup> 
 
+#### After installing as a plugin you will need to include this in <script setup> in any component you want to use EdgeFirebase in:
 ```javascript
 <script setup>
-import * as edgeFirebase from "@edgedev/firebase";
+import { inject } from "vue";
+const edgeFirebase = inject("edgeFirebase");
 </script>
 ```
 # Firebase Authentication

package/edgeFirebase.ts

@@ -0,0 +1,485 @@
+import { initializeApp } from "firebase/app";
+import { reactive } from "vue";
+
+import {
+  getFirestore,
+  collection,
+  addDoc,
+  doc,
+  query,
+  onSnapshot,
+  WhereFilterOp,
+  QueryConstraint,
+  Unsubscribe,
+  where,
+  deleteDoc,
+  getDocs,
+  getDoc,
+  orderBy,
+  limit,
+  Query,
+  startAfter,
+  DocumentData,
+  setDoc
+} from "firebase/firestore";
+
+import {
+  getAuth,
+  setPersistence,
+  browserSessionPersistence,
+  browserLocalPersistence,
+  Persistence,
+  signInWithEmailAndPassword,
+  onAuthStateChanged,
+  signOut
+} from "firebase/auth";
+
+interface FirestoreQuery {
+  field: string;
+  operator: WhereFilterOp; // '==' | '<' | '<=' | '>' | '>=' | 'array-contains' | 'in' | 'array-contains-any';
+  value: unknown;
+}
+
+interface FirestoreOrderBy {
+  field: string;
+  direction: "asc" | "desc";
+}
+
+interface FirestoreLimit {
+  limit: number;
+}
+
+interface CollectionUnsubscribeObject {
+  [key: string]: Unsubscribe;
+}
+
+interface CollectionDataObject {
+  [key: string]: object;
+}
+
+interface UserDataObject {
+  uid: string | null;
+  email: string;
+  loggedIn: boolean;
+  logInError: boolean;
+  logInErrorMessage: string;
+}
+
+interface Credentials {
+  email: string;
+  password: string;
+}
+
+interface StaticDataResult {
+  data: object;
+  next: DocumentData | null;
+}
+
+interface firebaseConfig {
+  apiKey: string;
+  authDomain: string;
+  projectId: string;
+  storageBucket: string;
+  messagingSenderId: string;
+  appId: string;
+}
+
+export const EdgeFirebase = class {
+  constructor(
+    firebaseConfig: firebaseConfig = {
+      apiKey: "",
+      authDomain: "",
+      projectId: "",
+      storageBucket: "",
+      messagingSenderId: "",
+      appId: ""
+    }
+  ) {
+    this.firebaseConfig = firebaseConfig;
+    this.app = initializeApp(this.firebaseConfig);
+    this.auth = getAuth(this.app);
+    this.db = getFirestore(this.app);
+    this.setOnAuthStateChanged();
+  }
+
+  private firebaseConfig = null;
+
+  // Initialize Firebase
+  public app = null;
+  public auth = null;
+  public db = null;
+
+  // Composable to logout
+  public logOut = (): void => {
+    signOut(this.auth)
+      .then(() => {
+        Object.keys(this.unsubscibe).forEach((key) => {
+          if (this.unsubscibe[key] instanceof Function) {
+            this.unsubscibe[key]();
+            this.unsubscibe[key] = null;
+          }
+        });
+      })
+      .catch(() => {
+        // Do nothing
+      });
+  };
+
+  private setOnAuthStateChanged = (): void => {
+    onAuthStateChanged(this.auth, (userAuth) => {
+      if (userAuth) {
+        this.user.email = userAuth.email;
+        this.user.uid = userAuth.uid;
+        this.user.loggedIn = true;
+        this.user.logInError = false;
+        this.user.logInErrorMessage = "";
+      } else {
+        this.user.email = "";
+        this.user.uid = null;
+        this.user.loggedIn = false;
+        this.user.logInError = false;
+        this.user.logInErrorMessage = "";
+      }
+    });
+  };
+
+  // Composable to login and set persistence
+  public logIn = (credentials: Credentials, isPersistant = false): void => {
+    this.logOut();
+    let persistence: Persistence = browserSessionPersistence;
+    if (isPersistant) {
+      persistence = browserLocalPersistence;
+    }
+    setPersistence(this.auth, persistence)
+      .then(() => {
+        signInWithEmailAndPassword(
+          this.auth,
+          credentials.email,
+          credentials.password
+        )
+          .then(() => {
+            // do nothing
+          })
+          .catch((error) => {
+            this.user.email = "";
+            this.user.uid = null;
+
+            this.user.loggedIn = false;
+            this.user.logInError = true;
+            this.user.logInErrorMessage = error.code + ": " + error.message;
+          });
+      })
+      .catch((error) => {
+        this.user.email = "";
+        this.user.uid = null;
+
+        this.user.loggedIn = false;
+        this.user.logInError = true;
+        this.user.logInErrorMessage = error.code + ": " + error.message;
+      });
+  };
+
+  // Keeping this for reference on how to Type a Ref.
+  // const user = ref<UserDataObject>({
+  //   uid: null,
+  //   email: "",
+  //   loggedIn: false,
+  //   logInError: false,
+  //   logInErrorMessage: ""
+  // });
+
+  // Simple Store Items (add matching key per firebase collection)
+  public data: CollectionDataObject = reactive({});
+  public unsubscibe: CollectionUnsubscribeObject = reactive({});
+  public user: UserDataObject = reactive({
+    uid: null,
+    email: "",
+    loggedIn: false,
+    logInError: false,
+    logInErrorMessage: ""
+  });
+
+  public getDocData = async (
+    collectionPath: string,
+    docId: string
+  ): Promise<{ [key: string]: unknown }> => {
+    const docRef = doc(this.db, collectionPath, docId);
+    const docSnap = await getDoc(docRef);
+    const docData = docSnap.data();
+    docData.docId = docSnap.id;
+    return docData;
+  };
+
+  private getStaticData = async (
+    collectionPath: string,
+    queryList: FirestoreQuery[] = [],
+    orderList: FirestoreOrderBy[] = [],
+    max = 0,
+    last: DocumentData | null = null
+  ): Promise<StaticDataResult> => {
+    const data: object = {};
+
+    const q = this.getQuery(collectionPath, queryList, orderList, max, last);
+
+    const docs = await getDocs(q);
+    const nextLast: DocumentData = docs.docs[docs.docs.length - 1];
+
+    docs.forEach((doc) => {
+      const item = doc.data();
+      item.docId = doc.id;
+      data[doc.id] = item;
+    });
+    return { data, next: nextLast };
+  };
+
+  // Class for wrapping a getSaticData to handle pagination
+  get SearchStaticData() {
+    const getStaticData = this.getStaticData;
+    return class {
+      private collectionPath = "";
+      private queryList: FirestoreQuery[] = [];
+      private orderList: FirestoreOrderBy[] = [];
+      private max = 0;
+
+      public results = reactive({
+        data: {},
+        pagination: [],
+        staticIsLastPage: true,
+        staticIsFirstPage: true,
+        staticCurrentPage: ""
+      });
+
+      public prev = async (): Promise<void> => {
+        const findIndex = this.results.pagination.findIndex(
+          (x) => x.key === this.results.staticCurrentPage
+        );
+        let last = null;
+        if (findIndex === 1) {
+          this.results.staticCurrentPage = "";
+          this.results.staticIsLastPage = false;
+          this.results.staticIsFirstPage = true;
+        } else {
+          last = this.results.pagination[findIndex - 2].next;
+          this.results.staticCurrentPage =
+            this.results.pagination[findIndex - 2].key;
+        }
+        await this.afterNextPrev(last);
+      };
+
+      public next = async (): Promise<void> => {
+        const findIndex = this.results.pagination.findIndex(
+          (x) => x.key === this.results.staticCurrentPage
+        );
+        const last = this.results.pagination[findIndex].next;
+        if (this.results.pagination.length === 1) {
+          this.results.staticIsFirstPage = true;
+        } else {
+          this.results.staticIsFirstPage = false;
+        }
+        await this.afterNextPrev(last);
+      };
+
+      private afterNextPrev = async (last): Promise<void> => {
+        let results = await getStaticData(
+          "users",
+          this.queryList,
+          this.orderList,
+          this.max,
+          last
+        );
+
+        if (last && Object.keys(results.data).length === 0) {
+          this.results.staticIsLastPage = true;
+          if (this.results.pagination.length === 1) {
+            last = null;
+            this.results.staticCurrentPage = "";
+            this.results.staticIsFirstPage = true;
+          } else {
+            last =
+              this.results.pagination[this.results.pagination.length - 2].next;
+            this.results.staticCurrentPage =
+              this.results.pagination[this.results.pagination.length - 2].key;
+          }
+          results = await getStaticData(
+            "users",
+            this.queryList,
+            this.orderList,
+            this.max,
+            last
+          );
+        } else {
+          this.results.staticIsLastPage = false;
+          if (this.results.pagination.length === 1) {
+            this.results.staticIsFirstPage = false;
+          }
+        }
+        this.results.data = results.data;
+        this.results.staticCurrentPage = results.next.id;
+        if (!this.results.staticIsLastPage) {
+          if (results.next) {
+            const findItem = this.results.pagination.find(
+              (x) => x.key === results.next.id
+            );
+            if (!findItem) {
+              this.results.pagination.push({
+                key: results.next.id,
+                next: results.next
+              });
+            }
+          }
+        }
+      };
+
+      public getData = async (
+        collectionPath: string,
+        queryList: FirestoreQuery[] = [],
+        orderList: FirestoreOrderBy[] = [],
+        max = 0
+      ): Promise<void> => {
+        this.collectionPath = collectionPath;
+        this.queryList = queryList;
+        this.orderList = orderList;
+        this.max = max;
+        this.results.staticIsLastPage = true;
+        this.results.staticIsFirstPage = true;
+        this.results.staticCurrentPage = "";
+        this.results.pagination = [];
+        this.results.pagination = [];
+        this.results.data = {};
+        const results = await getStaticData(
+          collectionPath,
+          queryList,
+          orderList,
+          max
+        );
+        if (Object.keys(results.data).length > 0) {
+          this.results.staticIsLastPage = false;
+          this.results.data = results.data;
+          this.results.staticCurrentPage = results.next.id;
+          this.results.pagination.push({
+            key: results.next.id,
+            next: results.next
+          });
+        } else {
+          this.results.staticIsLastPage = true;
+          this.results.staticIsFirstPage = true;
+        }
+      };
+    };
+  }
+
+  // Class for wrapping a getSaticData to handle pagination
+  public SearchStaticDatas = new (class {})();
+
+  // Composable to start snapshot listener and set unsubscribe function
+  public startSnapshot = (
+    collectionPath: string,
+    queryList: FirestoreQuery[] = [],
+    orderList: FirestoreOrderBy[] = [],
+    max = 0
+  ): void => {
+    this.data[collectionPath] = {};
+    const q = this.getQuery(collectionPath, queryList, orderList, max);
+    const unsubscribe = onSnapshot(q, (querySnapshot) => {
+      const items = {};
+      querySnapshot.forEach((doc) => {
+        const item = doc.data();
+        item.docId = doc.id;
+        items[doc.id] = item;
+      });
+      this.data[collectionPath] = items;
+    });
+    this.unsubscibe[collectionPath] = unsubscribe;
+  };
+
+  private getQuery = (
+    collectionPath: string,
+    queryList: FirestoreQuery[] = [],
+    orderList: FirestoreOrderBy[] = [],
+    max = 0,
+    after: DocumentData | null = null
+  ): Query => {
+    const queryConditions: QueryConstraint[] = queryList.map((condition) =>
+      where(condition.field, condition.operator, condition.value)
+    );
+
+    const orderConditions: QueryConstraint[] = orderList.map((condition) =>
+      orderBy(condition.field, condition.direction)
+    );
+
+    let limitList: FirestoreLimit[] = [];
+    if (max > 0) {
+      limitList = [{ limit: max }];
+    }
+
+    const limitConditions: QueryConstraint[] = limitList.map((condition) =>
+      limit(condition.limit)
+    );
+    if (after) {
+      return query(
+        collection(this.db, collectionPath),
+        ...queryConditions,
+        ...orderConditions,
+        ...limitConditions,
+        startAfter(after)
+      );
+    }
+    return query(
+      collection(this.db, collectionPath),
+      ...queryConditions,
+      ...orderConditions,
+      ...limitConditions
+    );
+  };
+
+  // Composable to update/add a document
+  public storeDoc = async (
+    collectionPath: string,
+    item: object
+  ): Promise<void> => {
+    const cloneItem = JSON.parse(JSON.stringify(item));
+    const currentTime = new Date().getTime();
+    cloneItem.last_updated = currentTime;
+    cloneItem.uid = this.user.uid;
+    if (!Object.prototype.hasOwnProperty.call(cloneItem, "doc_created_at")) {
+      cloneItem.doc_created_at = currentTime;
+    }
+    if (Object.prototype.hasOwnProperty.call(cloneItem, "docId")) {
+      const docId = cloneItem.docId;
+      if (Object.prototype.hasOwnProperty.call(this.data, collectionPath)) {
+        this.data[collectionPath][docId] = cloneItem;
+      }
+      setDoc(doc(this.db, collectionPath, docId), cloneItem);
+    } else {
+      const docRef = await addDoc(
+        collection(this.db, collectionPath),
+        cloneItem
+      );
+      if (Object.prototype.hasOwnProperty.call(this.data, collectionPath)) {
+        this.data[collectionPath][docRef.id] = cloneItem;
+      }
+      this.storeDoc(collectionPath, { ...cloneItem, docId: docRef.id });
+    }
+  };
+
+  // Composable to delete a document
+  public removeDoc = (collectionPath: string, docId: string): void => {
+    // Just in case getting collection back from firebase is slow:
+    if (Object.prototype.hasOwnProperty.call(this.data, collectionPath)) {
+      if (
+        Object.prototype.hasOwnProperty.call(this.data[collectionPath], docId)
+      ) {
+        delete this.data[collectionPath][docId];
+      }
+    }
+    deleteDoc(doc(this.db, collectionPath, docId));
+  };
+
+  // Composable to stop snapshot listener
+  public stopSnapshot = (collectionPath: string): void => {
+    if (this.unsubscibe[collectionPath] instanceof Function) {
+      this.unsubscibe[collectionPath]();
+      this.unsubscibe[collectionPath] = null;
+    }
+  };
+};

package/index.ts

@@ -1,448 +1,8 @@
-import { initializeApp } from "firebase/app";
-import { reactive } from "vue";
-
-import {
-  getFirestore,
-  collection,
-  addDoc,
-  updateDoc,
-  doc,
-  query,
-  onSnapshot,
-  WhereFilterOp,
-  QueryConstraint,
-  Unsubscribe,
-  where,
-  deleteDoc,
-  getDocs,
-  getDoc,
-  orderBy,
-  limit,
-  Query,
-  startAfter,
-  DocumentData,
-  setDoc
-} from "firebase/firestore";
-
-import {
-  getAuth,
-  setPersistence,
-  browserSessionPersistence,
-  browserLocalPersistence,
-  Persistence,
-  signInWithEmailAndPassword,
-  onAuthStateChanged,
-  signOut
-} from "firebase/auth";
-
-interface FirestoreQuery {
-  field: string;
-  operator: WhereFilterOp; // '==' | '<' | '<=' | '>' | '>=' | 'array-contains' | 'in' | 'array-contains-any';
-  value: unknown;
-}
-
-interface FirestoreOrderBy {
-  field: string;
-  direction: "asc" | "desc";
-}
-
-interface FirestoreLimit {
-  limit: number;
-}
-
-interface CollectionUnsubscribeObject {
-  [key: string]: Unsubscribe;
-}
-
-interface CollectionDataObject {
-  [key: string]: object;
-}
-
-interface UserDataObject {
-  uid: string | null;
-  email: string;
-  loggedIn: boolean;
-  logInError: boolean;
-  logInErrorMessage: string;
-}
-
-interface Credentials {
-  email: string;
-  password: string;
-}
-
-interface StaticDataResult {
-  data: object;
-  next: DocumentData | null;
-}
-
-const firebaseConfig = {
-  apiKey: import.meta.env.VITE_FIREBASE_API_KEY as string,
-  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN as string,
-  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID as string,
-  storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET as string,
-  messagingSenderId: import.meta.env
-    .VITE_FIREBASE_MESSAGING_SENDER_ID as string,
-  appId: import.meta.env.VITE_FIREBASE_APP_ID as string
-};
-
-// Initialize Firebase
-export const app = initializeApp(firebaseConfig);
-export const auth = getAuth(app);
-export const db = getFirestore(app);
-
-onAuthStateChanged(auth, (userAuth) => {
-  if (userAuth) {
-    user.email = userAuth.email;
-    user.uid = userAuth.uid;
-    user.loggedIn = true;
-    user.logInError = false;
-    user.logInErrorMessage = "";
-  } else {
-    user.email = "";
-    user.uid = null;
-    user.loggedIn = false;
-    user.logInError = false;
-    user.logInErrorMessage = "";
-  }
-});
-
-// Composable to logout
-export const logOut = (): void => {
-  signOut(auth)
-    .then(() => {
-      Object.keys(unsubscibe).forEach((key) => {
-        if (unsubscibe[key] instanceof Function) {
-          unsubscibe[key]();
-          unsubscibe[key] = null;
-        }
-      });
-    })
-    .catch(() => {
-      // Do nothing
-    });
-};
-
-// Composable to login and set persistence
-export const logIn = (credentials: Credentials, isPersistant = false): void => {
-  logOut();
-  let persistence: Persistence = browserSessionPersistence;
-  if (isPersistant) {
-    persistence = browserLocalPersistence;
-  }
-  setPersistence(auth, persistence)
-    .then(() => {
-      signInWithEmailAndPassword(auth, credentials.email, credentials.password)
-        .then(() => {
-          // do nothing
-        })
-        .catch((error) => {
-          user.email = "";
-          user.uid = null;
-
-          user.loggedIn = false;
-          user.logInError = true;
-          user.logInErrorMessage = error.code + ": " + error.message;
-        });
-    })
-    .catch((error) => {
-      user.email = "";
-      user.uid = null;
-
-      user.loggedIn = false;
-      user.logInError = true;
-      user.logInErrorMessage = error.code + ": " + error.message;
-    });
-};
-
-// Keeping this for reference on how to Type a Ref.
-// export const user = ref<UserDataObject>({
-//   uid: null,
-//   email: "",
-//   loggedIn: false,
-//   logInError: false,
-//   logInErrorMessage: ""
-// });
-
-// Simple Store Items (add matching key per firebase collection)
-export const data: CollectionDataObject = reactive({});
-export const unsubscibe: CollectionUnsubscribeObject = reactive({});
-export const user: UserDataObject = reactive({
-  uid: null,
-  email: "",
-  loggedIn: false,
-  logInError: false,
-  logInErrorMessage: ""
-});
-
-export const getDocData = async (
-  collectionPath: string,
-  docId: string
-): Promise<{ [key: string]: unknown }> => {
-  const docRef = doc(db, collectionPath, docId);
-  const docSnap = await getDoc(docRef);
-  const docData = docSnap.data();
-  docData.docId = docSnap.id;
-  return docData;
-};
-
-export const getStaticData = async (
-  collectionPath: string,
-  queryList: FirestoreQuery[] = [],
-  orderList: FirestoreOrderBy[] = [],
-  max = 0,
-  last: DocumentData | null = null
-): Promise<StaticDataResult> => {
-  const data: object = {};
-
-  const q = getQuery(collectionPath, queryList, orderList, max, last);
-
-  const docs = await getDocs(q);
-  const nextLast: DocumentData = docs.docs[docs.docs.length - 1];
-
-  docs.forEach((doc) => {
-    const item = doc.data();
-    item.docId = doc.id;
-    data[doc.id] = item;
-  });
-  return { data, next: nextLast };
-};
-
-// Class for wrapping a getSaticData to handle pagination
-export class SearchStaticData {
-  collectionPath = "";
-  queryList: FirestoreQuery[] = [];
-  orderList: FirestoreOrderBy[] = [];
-  max = 0;
-
-  results = reactive({
-    data: {},
-    pagination: [],
-    staticIsLastPage: true,
-    staticIsFirstPage: true,
-    staticCurrentPage: ""
-  });
-
-  prev = async (): Promise<void> => {
-    const findIndex = this.results.pagination.findIndex(
-      (x) => x.key === this.results.staticCurrentPage
-    );
-    let last = null;
-    if (findIndex === 1) {
-      this.results.staticCurrentPage = "";
-      this.results.staticIsLastPage = false;
-      this.results.staticIsFirstPage = true;
-    } else {
-      last = this.results.pagination[findIndex - 2].next;
-      this.results.staticCurrentPage =
-        this.results.pagination[findIndex - 2].key;
-    }
-    await this.afterNextPrev(last);
-  };
-
-  next = async (): Promise<void> => {
-    const findIndex = this.results.pagination.findIndex(
-      (x) => x.key === this.results.staticCurrentPage
-    );
-    const last = this.results.pagination[findIndex].next;
-    if (this.results.pagination.length === 1) {
-      this.results.staticIsFirstPage = true;
-    } else {
-      this.results.staticIsFirstPage = false;
-    }
-    await this.afterNextPrev(last);
-  };
-
-  afterNextPrev = async (last): Promise<void> => {
-    let results = await getStaticData(
-      "users",
-      this.queryList,
-      this.orderList,
-      this.max,
-      last
-    );
-
-    if (last && Object.keys(results.data).length === 0) {
-      this.results.staticIsLastPage = true;
-      if (this.results.pagination.length === 1) {
-        last = null;
-        this.results.staticCurrentPage = "";
-        this.results.staticIsFirstPage = true;
-      } else {
-        last = this.results.pagination[this.results.pagination.length - 2].next;
-        this.results.staticCurrentPage =
-          this.results.pagination[this.results.pagination.length - 2].key;
-      }
-      results = await getStaticData(
-        "users",
-        this.queryList,
-        this.orderList,
-        this.max,
-        last
-      );
-    } else {
-      this.results.staticIsLastPage = false;
-      if (this.results.pagination.length === 1) {
-        this.results.staticIsFirstPage = false;
-      }
-    }
-    this.results.data = results.data;
-    this.results.staticCurrentPage = results.next.id;
-    if (!this.results.staticIsLastPage) {
-      if (results.next) {
-        const findItem = this.results.pagination.find(
-          (x) => x.key === results.next.id
-        );
-        if (!findItem) {
-          this.results.pagination.push({
-            key: results.next.id,
-            next: results.next
-          });
-        }
-      }
-    }
-  };
-
-  getData = async (
-    collectionPath: string,
-    queryList: FirestoreQuery[] = [],
-    orderList: FirestoreOrderBy[] = [],
-    max = 0
-  ): Promise<void> => {
-    this.collectionPath = collectionPath;
-    this.queryList = queryList;
-    this.orderList = orderList;
-    this.max = max;
-    this.results.staticIsLastPage = true;
-    this.results.staticIsFirstPage = true;
-    this.results.staticCurrentPage = "";
-    this.results.pagination = [];
-    this.results.pagination = [];
-    this.results.data = {};
-    const results = await getStaticData(
-      collectionPath,
-      queryList,
-      orderList,
-      max
-    );
-    if (Object.keys(results.data).length > 0) {
-      this.results.staticIsLastPage = false;
-      this.results.data = results.data;
-      this.results.staticCurrentPage = results.next.id;
-      this.results.pagination.push({
-        key: results.next.id,
-        next: results.next
-      });
-    } else {
-      this.results.staticIsLastPage = true;
-      this.results.staticIsFirstPage = true;
-    }
-  };
-}
-
-// Composable to start snapshot listener and set unsubscribe function
-export const startSnapshot = (
-  collectionPath: string,
-  queryList: FirestoreQuery[] = [],
-  orderList: FirestoreOrderBy[] = [],
-  max = 0
-): void => {
-  data[collectionPath] = {};
-  const q = getQuery(collectionPath, queryList, orderList, max);
-  const unsubscribe = onSnapshot(q, (querySnapshot) => {
-    const items = {};
-    querySnapshot.forEach((doc) => {
-      const item = doc.data();
-      item.docId = doc.id;
-      items[doc.id] = item;
-    });
-    data[collectionPath] = items;
-  });
-  unsubscibe[collectionPath] = unsubscribe;
-};
-
-const getQuery = (
-  collectionPath: string,
-  queryList: FirestoreQuery[] = [],
-  orderList: FirestoreOrderBy[] = [],
-  max = 0,
-  after: DocumentData | null = null
-): Query => {
-  const queryConditions: QueryConstraint[] = queryList.map((condition) =>
-    where(condition.field, condition.operator, condition.value)
-  );
-
-  const orderConditions: QueryConstraint[] = orderList.map((condition) =>
-    orderBy(condition.field, condition.direction)
-  );
-
-  let limitList: FirestoreLimit[] = [];
-  if (max > 0) {
-    limitList = [{ limit: max }];
-  }
-
-  const limitConditions: QueryConstraint[] = limitList.map((condition) =>
-    limit(condition.limit)
-  );
-  if (after) {
-    return query(
-      collection(db, collectionPath),
-      ...queryConditions,
-      ...orderConditions,
-      ...limitConditions,
-      startAfter(after)
-    );
-  }
-  return query(
-    collection(db, collectionPath),
-    ...queryConditions,
-    ...orderConditions,
-    ...limitConditions
-  );
-};
-
-// Composable to update/add a document
-export const storeDoc = async (
-  collectionPath: string,
-  item: object
-): Promise<void> => {
-  const cloneItem = JSON.parse(JSON.stringify(item));
-  const currentTime = new Date().getTime();
-  cloneItem.last_updated = currentTime;
-  cloneItem.uid = user.uid;
-  if (!Object.prototype.hasOwnProperty.call(cloneItem, "doc_created_at")) {
-    cloneItem.doc_created_at = currentTime;
-  }
-  if (Object.prototype.hasOwnProperty.call(cloneItem, "docId")) {
-    const docId = cloneItem.docId;
-    if (Object.prototype.hasOwnProperty.call(data, collectionPath)) {
-      data[collectionPath][docId] = cloneItem;
-    }
-    setDoc(doc(db, collectionPath, docId), cloneItem);
-  } else {
-    const docRef = await addDoc(collection(db, collectionPath), cloneItem);
-    if (Object.prototype.hasOwnProperty.call(data, collectionPath)) {
-      data[collectionPath][docRef.id] = cloneItem;
-    }
-    storeDoc(collectionPath, { ...cloneItem, docId: docRef.id });
-  }
-};
-
-// Composable to delete a document
-export const removeDoc = (collectionPath: string, docId: string): void => {
-  // Just in case getting collection back from firebase is slow:
-  if (Object.prototype.hasOwnProperty.call(data, collectionPath)) {
-    if (Object.prototype.hasOwnProperty.call(data[collectionPath], docId)) {
-      delete data[collectionPath][docId];
-    }
-  }
-  deleteDoc(doc(db, collectionPath, docId));
-};
-
-// Composable to stop snapshot listener
-export const stopSnapshot = (collectionPath: string): void => {
-  if (unsubscibe[collectionPath] instanceof Function) {
-    unsubscibe[collectionPath]();
-    unsubscibe[collectionPath] = null;
+import { EdgeFirebase } from "./edgeFirebase";
+export default {
+  install: (app, options) => {
+    const eFb = new EdgeFirebase(options);
+    app.provide("edgeFirebase", eFb);
   }
 };
+export { EdgeFirebase };

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@edgedev/firebase",
-  "version": "1.1.6",
-  "description": "Composables and stores for firebase",
+  "version": "1.2.2",
+  "description": "Vue 3 / Nuxt 3 Plugin or Nuxt 3 global composable for firebase authenication and firestore",
   "main": "index.ts",
   "author": "Seth Fischer",
+  "keywords": [
+    "firebase",
+    "nuxt 3",
+    "vue 3"
+  ],
   "license": "ISC",
   "publishConfig": {
     "access": "public"
@@ -14,17 +19,14 @@
     "@typescript-eslint/parser": "^5.40.0",
     "eslint": "^8.25.0",
     "eslint-config-prettier": "^8.5.0",
+    "firebase": "^9.12.1",
     "prettier": "^2.7.1",
     "typescript": "^4.8.4",
-    "vite": "^3.1.8",
-    "vue": "^3.2.41",
-    "firebase": "^9.12.1"
+    "vue": "^3.2.41"
   },
-  "dependencies": {},
   "peerDependencies": {
     "firebase": "^9.12.1",
-    "vue": "^3.0.0",
-    "vite": "^3.1.8"
+    "vue": "^3.0.0"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"