react-firebase-ql 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1359 @@
+// src/Users.ts
+import {
+  setPersistence,
+  browserSessionPersistence,
+  signInWithEmailAndPassword,
+  signInWithPhoneNumber,
+  updatePassword,
+  sendPasswordResetEmail,
+  signOut,
+  getMultiFactorResolver,
+  multiFactor,
+  PhoneAuthProvider,
+  PhoneMultiFactorGenerator,
+  createUserWithEmailAndPassword,
+  sendEmailVerification,
+  applyActionCode,
+  verifyPasswordResetCode,
+  deleteUser,
+  browserLocalPersistence,
+  confirmPasswordReset
+} from "firebase/auth";
+
+// src/BaseModel.ts
+import {
+  doc,
+  collection,
+  onSnapshot,
+  where,
+  orderBy,
+  getDoc,
+  startAfter,
+  limit,
+  query,
+  updateDoc,
+  getDocs,
+  addDoc,
+  setDoc,
+  deleteDoc,
+  increment,
+  getCountFromServer,
+  writeBatch,
+  or,
+  and,
+  arrayUnion,
+  arrayRemove
+} from "firebase/firestore";
+
+// src/helpers.ts
+var generateRandomString = (length) => {
+  if (length > 60) {
+    throw new Error(`Maximum generatable character is 60, ${length} was required`);
+  }
+  var result = "";
+  var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  var charactersLength = characters.length;
+  for (var i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+};
+var camelToTitleCase = (key) => {
+  const topic = key[0].toUpperCase() + key.slice(1);
+  let result = "";
+  let i = 0;
+  while (i < topic.length) {
+    if (i === 0) {
+      result += topic.charAt(i);
+    } else {
+      if (topic.charAt(i) === topic.charAt(i).toUpperCase()) {
+        result += ` ${topic.charAt(i)}`;
+      } else {
+        result += topic.charAt(i);
+      }
+    }
+    i++;
+  }
+  return result;
+};
+function convertUnicode(input) {
+  return input.replace(/\\+u([0-9a-fA-F]{4})/g, (a, b) => String.fromCharCode(parseInt(b, 16)));
+}
+var moneyFormatter = (x, shorten = true, decimailPlaces) => {
+  if (x === void 0) {
+    return "";
+  }
+  const base = 1e5;
+  const num = parseInt(x);
+  if (num < base || !shorten) {
+    return num.toFixed(decimailPlaces).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  } else {
+    let val = "";
+    if (num / base < 10) {
+      val = (num / 1e3).toFixed(decimailPlaces) + "K";
+    } else if (num < base * 1e4) {
+      val = (num / (base * 10)).toFixed(decimailPlaces) + "M";
+    } else {
+      val = (num / (base * 1e4)).toFixed(decimailPlaces) + "B";
+    }
+    return val;
+  }
+};
+function getDaysAgo(startDate, daysApart) {
+  const localCopy = new Date(startDate.toDateString());
+  return new Date(localCopy.setDate(localCopy.getDate() + daysApart));
+}
+function timeAgo(dateInput) {
+  const date = new Date(dateInput);
+  if (isNaN(date.getTime())) {
+    throw new Error("Invalid date input");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const secondsAgo = Math.floor((now.getTime() - date.getTime()) / 1e3);
+  const minutesAgo = Math.floor(secondsAgo / 60);
+  if (minutesAgo < 1)
+    return "Just now";
+  const hoursAgo = Math.floor(minutesAgo / 60);
+  if (hoursAgo < 1)
+    return `${minutesAgo} minute${minutesAgo !== 1 ? "s" : ""} ago`;
+  const daysAgo = Math.floor(hoursAgo / 24);
+  if (daysAgo < 1)
+    return `${hoursAgo} hour${hoursAgo !== 1 ? "s" : ""} ago`;
+  const monthsAgo = Math.floor(daysAgo / 30);
+  if (daysAgo < 30)
+    return `${daysAgo} day${daysAgo !== 1 ? "s" : ""} ago`;
+  const yearsAgo = Math.floor(monthsAgo / 12);
+  if (monthsAgo < 12)
+    return `${monthsAgo} month${monthsAgo !== 1 ? "s" : ""} ago`;
+  return `${yearsAgo} year${yearsAgo !== 1 ? "s" : ""} ago`;
+}
+var range = (start, end) => Array.from({ length: end - start + 1 }, (_, i) => start + i);
+var nairaFormatter = (amount) => {
+  return `\u20A6${moneyFormatter(amount, true, 2)}`;
+};
+var camelCaseToNormal = (camelCaseStr) => {
+  return camelCaseStr.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (str) => str.toUpperCase());
+};
+var errorLogger = (...error) => {
+  if (window.location.hostname === "localhost") {
+    console.log(error);
+  }
+};
+function isValidEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  const pass = emailRegex.test(email);
+  if (!pass) {
+    return "Invalid email address";
+  }
+}
+function isValidPassword(password) {
+  if (password.length < 8) {
+    return "Password cannot be less than 8 characters in length";
+  }
+  const hasUppercase = /[A-Z]/.test(password);
+  if (!hasUppercase) {
+    return "Password must contain at least 1 uppercase letter";
+  }
+  const isAllUppercase = /^[A-Z]+$/.test(password);
+  if (isAllUppercase) {
+    return "Password cannot be all uppercase letter";
+  }
+  const hasSpecialCharacter = /[!@#$%^&*(),.?":{}|<>]/.test(password);
+  if (!hasSpecialCharacter) {
+    return "Password must contain at least 1 special character";
+  }
+}
+function numberToAlphabet(num) {
+  let result = "";
+  while (num > 0) {
+    num--;
+    const charCode = num % 26 + 65;
+    result = String.fromCharCode(charCode) + result;
+    num = Math.floor(num / 26);
+  }
+  return result;
+}
+var getNthNumberOfArray = (param) => {
+  const { num, step, start } = param;
+  if (num <= 0 || step <= 0) {
+    throw new Error("Both number and step must be greater than 0");
+  }
+  return Array.from({ length: Math.floor(num / step) }, (_, i) => {
+    if (start) {
+      i = start + i - 1;
+      return (i + 1) * step;
+    }
+    return (i + 1) * step;
+  });
+};
+var noEmptyField = (args) => {
+  return args.requiredFields.every(
+    (field) => Object.keys(FormData).includes(field) && args.formData[field] !== void 0 && args.formData[field] !== null && args.formData[field] !== ""
+  );
+};
+var getInitials = (fullName) => {
+  if (fullName) {
+    const names = fullName.trim().split(/\s+/);
+    if (names.length >= 2) {
+      const firstInitial = names[0].charAt(0).toUpperCase();
+      const lastInitial = names[names.length - 1].charAt(0).toUpperCase();
+      return `${firstInitial}${lastInitial}`;
+    }
+    if (names.length === 1) {
+      const name = names[0];
+      return `${name.charAt(0).toUpperCase()}${name.charAt(name.length - 1).toUpperCase()}`;
+    }
+  }
+  return "";
+};
+var fetchCurrentTimestamp = async () => {
+  const res = await fetch("https://worldtimeapi.org/api/timezone/etc/utc");
+  if (!res.ok)
+    throw new Error("Failed to fetch time");
+  const data = await res.json();
+  return {
+    iso: data.datetime,
+    unix: data.unixtime * 1e3
+    // Convert to milliseconds if needed
+  };
+};
+var formHasError = (formError) => {
+  return Object.values(formError).every((item) => item !== void 0);
+};
+
+// src/BaseModel.ts
+var BaseModel = class {
+  // offset data
+  // offset?: QueryDocumentSnapshot<DocumentData>;
+  constructor(table, db) {
+    // Get a new write batch
+    // protected batch?: WriteBatch
+    // Database table name
+    this.table = "";
+    this.table = table;
+    this.firestorDB = db;
+  }
+  /**
+   * save multiple documents
+   * @param param0 
+   */
+  async saveBatch({ data }) {
+    try {
+      const batch = writeBatch(this.firestorDB);
+      const obj = data;
+      obj.forEach((document) => {
+        const docRef = document.reference ? doc(this.firestorDB, this.table, document.reference) : doc(collection(this.firestorDB, this.table));
+        if (document.reference) {
+          delete document.reference;
+        }
+        batch.set(docRef, document);
+      });
+      await batch.commit();
+      return true;
+    } catch (error) {
+      throw new Error(`saveBatch: , ${error}`);
+    }
+  }
+  /**
+   * update multiple documents
+   * @param param0 
+   */
+  async updateBatch({ data }) {
+    try {
+      const batch = writeBatch(this.firestorDB);
+      const obj = data;
+      obj.forEach((document) => {
+        const docRef = doc(this.firestorDB, this.table, document.reference);
+        delete document.reference;
+        batch.update(docRef, document);
+      });
+      await batch.commit();
+      return true;
+    } catch (error) {
+      throw new Error(`updateBatch: , ${error}`);
+    }
+  }
+  /**
+   * delete multiple documents
+   * @param param0 
+   */
+  async deleteBatch({ ids }) {
+    try {
+      const batch = writeBatch(this.firestorDB);
+      ids.forEach((id) => {
+        const docRef = doc(this.firestorDB, this.table, id);
+        batch.delete(docRef);
+      });
+      await batch.commit();
+      return true;
+    } catch (error) {
+      throw new Error(`deleteBatch: , ${error}`);
+    }
+  }
+  /**
+   * Get realtime update from the database
+   * @param id 
+   */
+  stream(callBack, id) {
+    const ref2 = id ? doc(this.firestorDB, this.table, id) : collection(this.firestorDB, this.table);
+    try {
+      if (id) {
+        return onSnapshot(ref2, (doc2) => {
+          callBack(doc2.exists() ? { ...doc2.data(), reference: ref2.id } : void 0);
+        });
+      } else {
+        return onSnapshot(ref2, (snapShot) => {
+          callBack(
+            snapShot.docs.map((value) => {
+              const data = { ...value.data(), reference: value.id };
+              return data;
+            })
+          );
+        });
+      }
+    } catch (error) {
+      callBack(void 0);
+    }
+  }
+  /**
+   * Get realtime value from database with where clause
+   * @param wh 
+   * @param lim 
+   * @param order 
+   */
+  streamWhere(wh, callBack, lim, order, offset) {
+    try {
+      const whereParameter = wh.map((clause) => where(
+        clause.key,
+        clause.operator,
+        clause.value
+      ));
+      let constraint = [];
+      if (wh) {
+        constraint.push(...whereParameter);
+      }
+      if (order) {
+        constraint.push(orderBy(order.parameter, order.direction));
+      }
+      if (offset) {
+        getDoc(doc(this.firestorDB, this.table, offset)).then((off) => {
+          constraint.push(startAfter(off));
+        }).catch((error) => errorLogger(error));
+      }
+      if (lim) {
+        constraint.push(limit(lim));
+      }
+      const ref2 = collection(this.firestorDB, this.table);
+      return onSnapshot(query(
+        ref2,
+        ...constraint
+      ), (snapShot) => {
+        callBack(snapShot.docs.map((value) => {
+          const data = { ...value.data(), reference: value.id };
+          return data;
+        }));
+      });
+    } catch (error) {
+      throw new Error(`streamWhere: , ${error}`);
+    }
+  }
+  /**
+   * Fetch a single item from database
+   * @param id 
+   */
+  async find(id) {
+    try {
+      const ref2 = doc(this.firestorDB, this.table, id);
+      const docSnap = await getDoc(ref2);
+      if (docSnap.exists()) {
+        this.data = { ...docSnap.data(), reference: id };
+        return true;
+      }
+      return false;
+    } catch (error) {
+      throw new Error(`find: , ${error}`);
+    }
+  }
+  /**
+   * check if data exists
+   * @param id 
+   * @returns 
+   */
+  async dataExists(id) {
+    try {
+      const ref2 = doc(this.firestorDB, this.table, id);
+      const docSanp = await getDoc(ref2);
+      return docSanp.exists();
+    } catch (error) {
+      throw new Error(`dataExists: , ${error}`);
+    }
+  }
+  /**
+   * Update part of a data
+   * @param data 
+   * @param id 
+   * @returns 
+   */
+  async update(data, id) {
+    try {
+      delete data.reference;
+      const docRef = doc(this.firestorDB, this.table, id);
+      await updateDoc(docRef, data);
+      return true;
+    } catch (error) {
+      throw new Error(`update: , ${error}`);
+    }
+  }
+  /**
+   * update an array in a document
+   * @param {Array<any>} data array of data to be saved
+   * @param {string} reference document reference
+   * @param {string} key document object key containing the array
+   * @returns {boolean}
+   */
+  async updateAtomicArray(data, reference, key) {
+    try {
+      const docRef = doc(this.firestorDB, this.table, reference);
+      await updateDoc(docRef, { [key]: arrayUnion(...data) });
+      return true;
+    } catch (error) {
+      throw new Error(`updateAtomicArray error: ${error}`);
+    }
+  }
+  /**
+   * removes items from document array
+   * @param {Array<any>} data array of data to be removed
+   * @param {string} id document reference
+   * @param {string} key key to reference
+   * @returns {boolean}
+   */
+  async removeFromArray(data, id, key) {
+    try {
+      const docRef = doc(this.firestorDB, this.table, id);
+      await updateDoc(docRef, { [key]: arrayRemove(...data) });
+      return true;
+    } catch (error) {
+      throw new Error(`updateAtomicArray error: ${error}`);
+    }
+  }
+  /**
+   * Get all items from database
+   * @returns void
+   */
+  async findAll(ids) {
+    try {
+      const colRef = collection(this.firestorDB, this.table);
+      if (ids) {
+        const results = [];
+        for (let id of ids) {
+          const found = await this.find(id);
+          if (found) {
+            results.push(this.data);
+          }
+        }
+        this.data = results;
+        return true;
+      } else {
+        const snaptshots = await getDocs(colRef);
+        if (!snaptshots.empty) {
+          this.data = snaptshots.docs.map((document) => {
+            return { ...document.data(), reference: document.id };
+          });
+          return true;
+        } else {
+          return false;
+        }
+      }
+    } catch (error) {
+      throw new Error(`findAll: , ${error}`);
+    }
+  }
+  /**
+   * perform complex query
+   * @param param0 
+   */
+  async findWhereOrAnd({ wh, lim, order, offset }) {
+    try {
+      const colRef = collection(this.firestorDB, this.table);
+      const andWhere = [];
+      const orWhere = [];
+      let filterConstraint = and();
+      if (wh) {
+        wh.parameter.forEach((clause) => {
+          const whe = where(
+            clause.key,
+            clause.operator,
+            clause.value
+          );
+          clause.type === "and" ? andWhere.push(whe) : orWhere.push(whe);
+        });
+        if (wh.type === "andOr") {
+          filterConstraint = and(...andWhere, or(...orWhere));
+        } else if (wh.type === "or") {
+          filterConstraint = or(...orWhere);
+        } else {
+          filterConstraint = and(...andWhere);
+        }
+      }
+      let constraint = [];
+      if (order) {
+        constraint.push(orderBy(order.parameter, order.direction));
+      }
+      if (offset) {
+        const off = await getDoc(doc(this.firestorDB, this.table, offset));
+        constraint.push(startAfter(off));
+      }
+      if (lim) {
+        constraint.push(limit(lim));
+      }
+      const snapshot = await getDocs(
+        query(
+          colRef,
+          filterConstraint,
+          ...constraint
+        )
+      );
+      if (!snapshot.empty) {
+        this.data = snapshot.docs.map((document) => {
+          return { ...document.data(), reference: document.id };
+        });
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      throw new Error(`findWhereOrAnd: ${error}`);
+    }
+  }
+  /**
+   * complex query with and only
+   * @param param0 
+   * @returns 
+   */
+  async findWhere({ wh, lim, order, offset }) {
+    try {
+      const whereParameter = wh ? wh.map((clause) => where(
+        clause.key,
+        clause.operator,
+        clause.value
+      )) : [];
+      let constraint = [];
+      if (wh) {
+        constraint.push(...whereParameter);
+      }
+      if (order) {
+        constraint.push(orderBy(order.parameter, order.direction));
+      }
+      if (offset) {
+        const off = await getDoc(doc(this.firestorDB, this.table, offset));
+        constraint.push(startAfter(off));
+      }
+      if (lim) {
+        constraint.push(limit(lim));
+      }
+      const ref2 = collection(this.firestorDB, this.table);
+      const snapshot = await getDocs(
+        query(
+          ref2,
+          ...constraint
+        )
+      );
+      if (!snapshot.empty) {
+        return snapshot.docs.map((document) => {
+          return { ...document.data(), reference: document.id };
+        });
+      } else {
+        return [];
+      }
+    } catch (error) {
+      throw new Error(`findWhere: , ${error}`);
+    }
+  }
+  /**
+   * create or update data
+   * @param data 
+   */
+  async save(data, id) {
+    delete data.reference;
+    try {
+      if (id === void 0) {
+        const documentRef = await addDoc(collection(this.firestorDB, this.table), data);
+        return documentRef.id;
+      } else {
+        await setDoc(doc(this.firestorDB, this.table, id), data);
+        return id;
+      }
+    } catch (error) {
+      throw new Error(`save error: , ${error}`);
+    }
+  }
+  /**
+   * Delete document from database
+   * @param id 
+   */
+  async delete(id) {
+    try {
+      await deleteDoc(doc(this.firestorDB, this.table, id));
+      return true;
+    } catch (error) {
+      throw new Error(`delete: , ${error}`);
+    }
+  }
+  /**
+   * Increment or decrement counters
+   * @param param0 
+   */
+  async incrementDecrement({ dbReference, key, isIncrement = true, incrementalValue }) {
+    try {
+      const docRef = doc(this.firestorDB, this.table, dbReference);
+      const value = isIncrement ? incrementalValue != null ? incrementalValue : 1 : (incrementalValue != null ? incrementalValue : 1) * -1;
+      await updateDoc(docRef, { [key]: increment(value) });
+      return true;
+    } catch (error) {
+      throw new Error(`incrementDecrement: , ${error}`);
+    }
+  }
+  /**
+   * Count data in database
+   * @param {whereClause[]} wh - query parameter (e.g. [
+   * {
+   */
+  async countData(wh) {
+    try {
+      const qryParameter = wh.map((clause) => where(
+        clause.key,
+        clause.operator,
+        clause.value
+      ));
+      const qry = query(
+        collection(this.firestorDB, this.table),
+        ...qryParameter
+      );
+      const aggregate = await getCountFromServer(qry);
+      return aggregate.data().count;
+    } catch (error) {
+      throw new Error(`countData error: ,${error}`);
+    }
+  }
+  /**
+   * Get realtime value from database with where clause
+   * @param wh 
+   * @param lim 
+   * @param order 
+   */
+  async streamCount(wh, callBack, order, offset) {
+    try {
+      const whereParameter = wh.map(
+        (clause) => where(clause.key, clause.operator, clause.value)
+      );
+      const constraint = [...whereParameter];
+      if (order)
+        constraint.push(orderBy(order.parameter, order.direction));
+      if (offset) {
+        const off = await getDoc(doc(this.firestorDB, this.table, offset));
+        constraint.push(startAfter(off));
+      }
+      const streamerConstraint = [...constraint, limit(1)];
+      const ref2 = collection(this.firestorDB, this.table);
+      const unsubscribe = onSnapshot(
+        query(ref2, ...streamerConstraint),
+        async (snapShot) => {
+          if (snapShot.empty)
+            return;
+          const aggregate = await getCountFromServer(query(
+            collection(this.firestorDB, this.table),
+            ...constraint
+          ));
+          callBack(aggregate.data().count);
+        }
+      );
+      return unsubscribe;
+    } catch (error) {
+      throw new Error(`streamCount: ${error}`);
+    }
+  }
+};
+
+// src/Users.ts
+var Users = class extends BaseModel {
+  constructor() {
+    super(...arguments);
+    /**
+     * fetch phone number from database
+     * @param uid 
+     * @returns 
+     */
+    this.getPhoneNumber = async (uid) => {
+      let phoneNumber = null;
+      const dbUser = await this.find(uid);
+      if (dbUser) {
+        const dUser = this.data;
+        phoneNumber = dUser.phoneNumber;
+      }
+      return phoneNumber;
+    };
+    /**
+     * send OTP to enable 2 factor authentication
+     * @param user 
+     * @param recaptchaverifier 
+     */
+    this.setMultiFactorEnrollment = async (user, recaptchaverifier, auth, phoneNumber) => {
+      try {
+        const multifactorSession = await multiFactor(user).getSession();
+        const phoneInfoOptions = {
+          phoneNumber,
+          session: multifactorSession
+        };
+        const phoneAuthProvider = new PhoneAuthProvider(auth);
+        return await phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, recaptchaverifier);
+      } catch (e) {
+        throw new Error(`setMultiFactorEnrollment error: , ${e}`);
+      }
+    };
+    /**
+     * complete user signIn process with OTP
+     * @param param0 
+     * @param userCode 
+     * @param user 
+     * @param onSuccess 
+     * @returns {User | null}
+     */
+    this.confirmOTP = async (verifier, userCode) => {
+      try {
+        const { verificationId, resolver } = verifier;
+        const cred = PhoneAuthProvider.credential(verificationId, userCode);
+        const multiFactorAssertion = PhoneMultiFactorGenerator.assertion(cred);
+        let user = null;
+        if (resolver) {
+          const credential = await resolver.resolveSignIn(multiFactorAssertion);
+          user = credential.user;
+        } else {
+          if (verifier.user) {
+            await multiFactor(verifier.user).enroll(multiFactorAssertion, "primary phone");
+            user = verifier.user;
+          }
+        }
+        return user;
+      } catch (error) {
+        throw new Error(`confirmOTP error: , ${error}`);
+      }
+    };
+    /**
+     * send OTP to member
+     * @param resolver 
+     * @param recaptchaVerifier 
+     * @param setter 
+     * @returns {MFAVerifier | null}
+     */
+    this.sendOTP = async (resolver, recaptchaVerifier, auth) => {
+      try {
+        if (resolver.hints[0].factorId === PhoneMultiFactorGenerator.FACTOR_ID) {
+          const phoneInfoOptions = {
+            multiFactorHint: resolver.hints[0],
+            session: resolver.session
+          };
+          const phoneAuthProvider = new PhoneAuthProvider(auth);
+          const verificationId = await phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, recaptchaVerifier);
+          return { verificationId, resolver };
+        } else {
+          return null;
+        }
+      } catch (e) {
+        throw new Error(`sendOTP error: , ${e}`);
+      }
+    };
+    /**
+     * Handle email verification for user
+     * @param auth 
+     * @param actionCode 
+     * @returns {error: string | null}
+     */
+    this.verifyEmail = async (auth, actionCode) => {
+      try {
+        await applyActionCode(auth, actionCode);
+        return true;
+      } catch (error) {
+        throw new Error(`verifyEmail error: , ${error}`);
+      }
+    };
+    /**
+     * confirm that password reset link is correct
+     * @param auth 
+     * @param actionCode 
+     * @returns {email: string | null} 
+     */
+    this.verifyPasswordResetLink = async (auth, actionCode) => {
+      try {
+        return await verifyPasswordResetCode(auth, actionCode);
+      } catch (error) {
+        throw new Error(`passwordResetLink error: , ${error}`);
+      }
+    };
+  }
+  /**
+   * register user and send email verification
+   * delete user if registration is not successful
+   * @param param0 
+   */
+  async registerWithEmailAndPassword({
+    auth,
+    email,
+    password,
+    userData,
+    persist = "session"
+  }) {
+    try {
+      if (persist) {
+        await setPersistence(auth, persist === "local" ? browserLocalPersistence : browserSessionPersistence);
+      }
+      const credential = await createUserWithEmailAndPassword(auth, email, password);
+      this.user = credential.user;
+      if (userData) {
+        await this.save(userData, credential.user.uid);
+      }
+      return credential.user.uid;
+    } catch (error) {
+      if (this.user) {
+        this.deleteAccount(this.user);
+      }
+      throw new Error(`registerWithEmailAndPassword error: , ${error}`);
+    }
+  }
+  /**
+  * confirm user is valid and get their information
+  * from firestore users table if exists
+  * @param { string , string, boolean} credentials - login credentials 
+  * @returns {Promise<QueryReturn>}
+  */
+  async login({ email, password, auth, persist = "session", verifyEmail = false }) {
+    try {
+      if (persist) {
+        await setPersistence(auth, persist === "local" ? browserLocalPersistence : browserSessionPersistence);
+      }
+      const userAuth = await signInWithEmailAndPassword(auth, email, password);
+      if (userAuth) {
+        if (verifyEmail && !userAuth.user.emailVerified) {
+          return { message: "Email is not verified", status: "error" };
+        } else {
+          return { message: "User successfully logged in", status: "success", data: userAuth.user };
+        }
+      } else {
+        return { message: "Unknown account", status: "error" };
+      }
+    } catch (error) {
+      throw new Error(`login error: , ${error}`);
+    }
+  }
+  /**
+   * sign user with user's number
+   * @param param0 
+   * @returns 
+   */
+  async signInWithPhoneNumber({ auth, phoneNumber, appVerifier }) {
+    try {
+      return await signInWithPhoneNumber(auth, phoneNumber, appVerifier);
+    } catch (error) {
+      throw new Error(`signInWithPhoneNumber error: , ${error}`);
+    }
+  }
+  /**
+   * Check if user is currently logged in
+   * @param auth 
+   * @returns 
+   */
+  isLoggedIn(auth) {
+    try {
+      if (auth.currentUser) {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      throw new Error(`isLoggedIn error: , ${error}`);
+    }
+  }
+  /**
+   * Reset logged in user's password
+   * @param {Auth, string} param0 
+   * @returns {boolean}
+   */
+  async resetPassword({ auth, newPassword }) {
+    try {
+      await updatePassword(auth.currentUser, newPassword);
+      return true;
+    } catch (e) {
+      throw new Error(`resetPassword error: , ${e}`);
+    }
+  }
+  /**
+   * send password reset message to user's email address
+   * @param param0 
+   * @returns 
+   */
+  async sendPasswordResetMessage({ auth, email }) {
+    try {
+      await sendPasswordResetEmail(auth, email);
+      return true;
+    } catch (e) {
+      throw new Error(`sendPasswordResetMessage error: , ${e}`);
+    }
+  }
+  /**
+   * logout users and end current session
+   * @param param0 
+   * @returns 
+   */
+  async logout({ auth }) {
+    try {
+      await signOut(auth);
+      return true;
+    } catch (e) {
+      throw new Error(`logout error: , ${e}`);
+    }
+  }
+  /**
+  * create and validate users
+  * @param param0 
+  */
+  async loginWithMultiAuthFactor({ email, password, auth, recaptcha, getNumber, persist = true, verifyEmail = false }) {
+    try {
+      if (persist) {
+        await setPersistence(auth, browserSessionPersistence);
+      }
+      const credential = await signInWithEmailAndPassword(auth, email, password);
+      if (credential) {
+        if (verifyEmail && !credential.user.emailVerified) {
+          await this.sendEmailVerification(credential.user);
+          throw new Error("Email is not verified");
+        }
+        let phoneNumber;
+        if (getNumber) {
+          phoneNumber = await this.getPhoneNumber(credential.user.uid);
+        }
+        const user = credential.user;
+        const verificationId = await this.setMultiFactorEnrollment(user, recaptcha, auth, phoneNumber != null ? phoneNumber : credential.user.phoneNumber);
+        if (verificationId) {
+          return { verificationId, user };
+        } else {
+          return null;
+        }
+      } else {
+        return null;
+      }
+    } catch (e) {
+      const error = e;
+      if (error.code === "auth/multi-factor-auth-required") {
+        const resolver = getMultiFactorResolver(auth, error);
+        return await this.sendOTP(resolver, recaptcha, auth);
+      } else {
+        throw new Error(`loginWithMultiAuthFactor error: ${error}`);
+      }
+    }
+  }
+  /**
+   * delete user account
+   * @param user 
+   */
+  async deleteAccount(user) {
+    try {
+      await Promise.all([
+        deleteUser(user),
+        this.delete(user.uid)
+      ]);
+    } catch (error) {
+      throw new Error(`deleteAccount error: ,${error}`);
+    }
+  }
+  /**
+   * resend email verification for expired link
+   * @param auth 
+   * @returns 
+   */
+  async sendEmailVerification(user) {
+    try {
+      if (user) {
+        sendEmailVerification(user);
+        return null;
+      } else {
+        return "Unknown user account, please sign up!";
+      }
+    } catch (error) {
+      throw new Error(`sendEmailVerification error: , ${error}`);
+    }
+  }
+  async doPasswordReset(auth, actionCode, newPassword) {
+    try {
+      await confirmPasswordReset(auth, actionCode, newPassword);
+      return true;
+    } catch (e) {
+      throw new Error(`doPasswordReset error: , ${e}`);
+    }
+  }
+};
+
+// src/Storage.ts
+import {
+  ref,
+  uploadString,
+  getDownloadURL,
+  uploadBytesResumable,
+  deleteObject
+} from "firebase/storage";
+
+// src/constants.ts
+var fbsession = /^firebase:authUser:/;
+var UPLOADTYPES = /* @__PURE__ */ ((UPLOADTYPES2) => {
+  UPLOADTYPES2["IMAGES"] = "images";
+  UPLOADTYPES2["DOCUMENTS"] = "documents";
+  UPLOADTYPES2["VIDEOS"] = "videos";
+  UPLOADTYPES2["AUDIOS"] = "audios";
+  return UPLOADTYPES2;
+})(UPLOADTYPES || {});
+var AUTH_PROVIDERS = /* @__PURE__ */ ((AUTH_PROVIDERS2) => {
+  AUTH_PROVIDERS2[AUTH_PROVIDERS2["GOOGLE"] = 0] = "GOOGLE";
+  AUTH_PROVIDERS2[AUTH_PROVIDERS2["APPLE"] = 1] = "APPLE";
+  AUTH_PROVIDERS2[AUTH_PROVIDERS2["FACEBOOK"] = 2] = "FACEBOOK";
+  AUTH_PROVIDERS2[AUTH_PROVIDERS2["TWITTER"] = 3] = "TWITTER";
+  return AUTH_PROVIDERS2;
+})(AUTH_PROVIDERS || {});
+
+// src/Storage.ts
+var StorageUpload = class {
+  constructor(props) {
+    // validate file (size, type)
+    this.validateFile = (file, storageRef) => {
+      var _a;
+      let goodSize = false;
+      let goodType = false;
+      let extension = "";
+      let goodTypes = [];
+      if (typeof file !== "string") {
+        if (storageRef === "images" /* IMAGES */) {
+          goodTypes = ["image/png", "image/jpg", "image/jpeg"];
+          extension = this.getExtensionName(file.type);
+        } else if (storageRef === "documents" /* DOCUMENTS */) {
+          goodTypes = [
+            "application/pdf",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-excel"
+          ];
+          extension = this.getDocExtensionName(file.type);
+        } else if (storageRef === "videos" /* VIDEOS */) {
+          goodTypes = ["video/mp4", "video/m4v"];
+        } else if (storageRef === "audios" /* AUDIOS */) {
+          goodTypes = ["audio/mp3", "audio/mpeg"];
+        }
+        goodType = goodTypes.includes(file.type);
+        goodSize = file.size > 0 && file.size <= this.maxSize;
+      } else {
+        goodType = true;
+        goodSize = true;
+      }
+      if (!goodSize || !goodType) {
+        this.setUploadError(storageRef, (_a = this.maxSize) != null ? _a : 1e6, goodSize);
+      } else {
+        this.setFilePath(storageRef, extension);
+      }
+    };
+    /**
+     * Get human readable form for file size
+     * @param size 
+     * @returns 
+     */
+    this.sizeMetric = (size) => {
+      let result = `${size} bytes`;
+      if (size <= 999999) {
+        result = `${Math.round(size / 1e3)} Kb`;
+      } else if (size <= 999999999) {
+        result = `${Math.round(size / 1e6)} Mb`;
+      } else if (size <= 999999999999) {
+        result = `${Math.round(size / 1e9)} Gb`;
+      } else if (size <= 999999999999999) {
+        result = `${Math.round(size / 1e12)} T`;
+      }
+      return result;
+    };
+    /**
+     * Get file extensions
+     * @param fileType 
+     * @returns 
+     */
+    this.getExtensionName = (fileType) => {
+      let ext = "";
+      if (fileType === "application/pdf") {
+        ext = "pdf";
+      }
+      if (fileType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") {
+        ext = ".xlsx";
+      }
+      if (fileType === "application/vnd.ms-excel") {
+        ext = ".xls";
+      }
+      return ext;
+    };
+    this.getDocExtensionName = (fileType) => {
+      let ext = "";
+      if (fileType === "image/png") {
+        ext = "png";
+      }
+      if (fileType === "image/jpg") {
+        ext = "jpg";
+      }
+      if (fileType === "image/jpeg") {
+        ext = "jpeg";
+      }
+      return ext;
+    };
+    /**
+     * setting error messages for failed file validation
+     * @param ref 
+     * @param maxSize 
+     * @param isGoodSize 
+     * @param isGoodType 
+     */
+    this.setUploadError = (ref2, maxSize, isGoodSize) => {
+      this.uploadError = !isGoodSize ? `File size is must not be larger than ${this.sizeMetric(maxSize)}` : `File is not a valid ${ref2 === "images" /* IMAGES */ ? "image" : ref2 === "documents" /* DOCUMENTS */ ? "document" : ref2 === "videos" /* VIDEOS */ ? "video" : "audio"}`;
+    };
+    // generate new file name and extension
+    this.setFilePath = (ref2, ext) => {
+      const d = /* @__PURE__ */ new Date();
+      const fileExtension = ref2 === "images" /* IMAGES */ || ref2 === "documents" /* DOCUMENTS */ ? "." + ext : (
+        // (ref===UPLOADTYPES.DOCUMENTS?'.pdf':(
+        ref2 === "videos" /* VIDEOS */ ? ".mp4" : ".mp3"
+      );
+      const fileName = generateRandomString(30);
+      this.fullPath = ref2.concat(
+        `/`,
+        `${this.additionalPath}/`,
+        `${fileName}_${d.getTime()}${fileExtension}`
+      );
+    };
+    /**
+     * upload base64 data_url
+     * @param reference 
+     */
+    this.uploadAsString = async (reference) => {
+      try {
+        const result = await uploadString(reference, this.file, "data_url");
+        if (result) {
+          return await getDownloadURL(ref(this.storage, result.ref.fullPath));
+        } else {
+          return false;
+        }
+      } catch (error) {
+        throw new Error(`uploadAsString: , ${error}`);
+      }
+    };
+    /**
+     * upload blobs and files
+     * @param reference 
+     */
+    this.uploadAsFile = async (reference) => {
+      try {
+        const snapShot = await uploadBytesResumable(reference, this.file);
+        if (snapShot) {
+          return await getDownloadURL(ref(this.storage, this.fullPath));
+        } else {
+          return false;
+        }
+      } catch (error) {
+        throw new Error(`uploadAsFile: , ${error}`);
+      }
+    };
+    const { file, basePath, otherPath, maxSize, storage } = props;
+    this.storage = storage;
+    if (file) {
+      this.additionalPath = otherPath;
+      this.maxSize = maxSize != null ? maxSize : 1e6;
+      this.file = file;
+      this.validateFile(file, basePath);
+    }
+  }
+  /**
+   * Upload images, documents and videos
+   * @param progressMonitor 
+   */
+  async doUpload() {
+    if (this.uploadError) {
+      throw new Error(`doUPload Error: ,${this.uploadError}`);
+    } else {
+      try {
+        const reference = ref(this.storage, this.fullPath);
+        if (typeof this.file === "string") {
+          console.log("uploading as string");
+          return await this.uploadAsString(reference);
+        } else {
+          console.log("uploading as file");
+          return await this.uploadAsFile(reference);
+        }
+      } catch (error) {
+        throw new Error(`doUPload Error: ,${error}`);
+      }
+    }
+  }
+  /**
+   * delete files from storage
+   * @param filePath 
+   * @param storage 
+   * @returns {boolean}
+   */
+  static async deleteFile(filePath, storage) {
+    try {
+      const delRef = ref(storage, filePath);
+      await deleteObject(delRef);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+};
+
+// src/useAuth.ts
+import { useEffect } from "react";
+import { onAuthStateChanged } from "firebase/auth";
+function useAuth(auth, callback) {
+  useEffect(() => {
+    const unsubscribe = onAuthStateChanged(auth, async (authUser) => {
+      callback(authUser);
+    });
+    return () => unsubscribe();
+  }, []);
+}
+
+// src/useCounter.ts
+import { useCallback, useEffect as useEffect2, useState } from "react";
+var useCount = (param) => {
+  const [data, setData] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const fetcher = useCallback(async () => {
+    if (!param.where)
+      return;
+    try {
+      const model = param.model;
+      const found = await model.countData(param.where);
+      setData(found);
+    } catch (error) {
+      errorLogger("useCount: ", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    JSON.stringify(param.where),
+    loading
+  ]);
+  useEffect2(() => {
+    fetcher();
+  }, [fetcher]);
+  return [data, loading, setLoading];
+};
+
+// src/useFetch.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useState as useState2 } from "react";
+var useFetch = (param) => {
+  const [data, setData] = useState2();
+  const [loading, setLoading] = useState2(true);
+  const fetcher = useCallback2(async () => {
+    var _a, _b, _c, _d;
+    if (!param.reference && !param.where)
+      return;
+    try {
+      const model = param.model;
+      if (param.reference) {
+        const found = await model.find(param.reference);
+        if (found)
+          setData(model.data);
+      } else if (param.where) {
+        const found = await model.findWhere({
+          wh: param.where,
+          lim: (_b = (_a = param.filter) == null ? void 0 : _a.limit) != null ? _b : 100,
+          order: (_c = param.filter) == null ? void 0 : _c.orderBy,
+          offset: (_d = param.filter) == null ? void 0 : _d.offset
+        });
+        setData(found);
+      }
+    } catch (error) {
+      errorLogger("useFetch: ", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    param.reference,
+    JSON.stringify(param.where),
+    JSON.stringify(param.filter),
+    loading
+  ]);
+  useEffect3(() => {
+    fetcher();
+  }, [fetcher]);
+  return [data, loading, setLoading];
+};
+
+// src/useStream.ts
+import { useEffect as useEffect4 } from "react";
+var useStream = (param, callback) => {
+  useEffect4(() => {
+    let unsubscribe;
+    try {
+      const { model, reference, where: where2, filter } = param;
+      if (reference) {
+        unsubscribe = model.stream((data) => {
+          if (data)
+            callback(data);
+        }, reference);
+      } else if (where2) {
+        const allInvalid = where2.every((item) => item.value === void 0);
+        if (allInvalid) {
+          callback([]);
+          return;
+        }
+        unsubscribe = model.streamWhere(
+          where2,
+          (data) => {
+            if (data)
+              callback(data);
+          },
+          100,
+          filter == null ? void 0 : filter.orderBy,
+          filter == null ? void 0 : filter.offset
+        );
+      }
+    } catch (error) {
+      errorLogger("useStream error:", error);
+    }
+    return () => {
+      if (typeof unsubscribe === "function") {
+        unsubscribe();
+      }
+    };
+  }, [JSON.stringify(param.where), JSON.stringify(param.filter), param.reference]);
+};
+export {
+  AUTH_PROVIDERS,
+  BaseModel,
+  StorageUpload,
+  UPLOADTYPES,
+  Users,
+  camelCaseToNormal,
+  camelToTitleCase,
+  convertUnicode,
+  errorLogger,
+  fbsession,
+  fetchCurrentTimestamp,
+  formHasError,
+  generateRandomString,
+  getDaysAgo,
+  getInitials,
+  getNthNumberOfArray,
+  isValidEmail,
+  isValidPassword,
+  moneyFormatter,
+  nairaFormatter,
+  noEmptyField,
+  numberToAlphabet,
+  range,
+  timeAgo,
+  useAuth,
+  useCount,
+  useFetch,
+  useStream
+};