react-firebase-ql 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 breedware
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# react-firebase-ql
+
+Small helpers/hooks for integrating Firebase with React.
+
+## Install
+npm install firebase react
+npm install my-react-firebase-lib
+
+## Usage
+import { useFirebaseAuth } from 'my-react-firebase-lib';
+
+function App() {
+  const user = useFirebaseAuth();
+  return <div>{user ? user.email : 'not signed in'}</div>;
+}

package/dist/index.d.ts

@@ -0,0 +1,304 @@
+import { WhereFilterOp, DocumentData, Firestore } from 'firebase/firestore';
+import { User, MultiFactorResolver, Unsubscribe, Auth, ApplicationVerifier, ConfirmationResult } from 'firebase/auth';
+import * as _firebase_firestore from '@firebase/firestore';
+import { FirebaseStorage } from 'firebase/storage';
+import { Dispatch, SetStateAction } from 'react';
+
+declare const fbsession: RegExp;
+type whereClause = {
+    key: string;
+    operator: WhereFilterOp;
+    value: any;
+};
+type andOrWhereClause = {
+    key: string;
+    operator: WhereFilterOp;
+    value: any;
+    type: 'and' | 'or';
+};
+declare enum UPLOADTYPES {
+    IMAGES = "images",
+    DOCUMENTS = "documents",
+    VIDEOS = "videos",
+    AUDIOS = "audios"
+}
+type dbItems = {
+    reference?: string;
+};
+type FunctionReturn = {
+    data: any;
+};
+declare enum AUTH_PROVIDERS {
+    GOOGLE = 0,
+    APPLE = 1,
+    FACEBOOK = 2,
+    TWITTER = 3
+}
+type QueryReturn = {
+    data?: any;
+    status: 'error' | 'success';
+    message: string;
+};
+type MFAVerifier = {
+    verificationId: string;
+    user?: User;
+    resolver?: MultiFactorResolver;
+};
+
+interface Model {
+    data: object;
+    find(id: string): Promise<boolean>;
+    findAll(ids?: string[]): Promise<boolean>;
+    findWhereOrAnd({ wh, lim, order, offset }: {
+        wh?: {
+            type: 'or' | 'and' | 'andOr';
+            parameter: whereClause[];
+        };
+        lim?: number;
+        order?: {
+            parameter: string;
+            direction?: 'asc' | 'desc';
+        };
+        offset?: string;
+    }): Promise<boolean>;
+    findWhere({ wh, lim, order, offset }: {
+        wh?: whereClause[];
+        lim?: number;
+        order?: {
+            parameter: string;
+            direction?: 'asc' | 'desc';
+        };
+        offset?: string;
+    }): Promise<DocumentData[]>;
+    save(data: object, id?: string): Promise<string | boolean>;
+    delete(id: string): Promise<boolean>;
+    update(data: object, id: string): Promise<boolean>;
+    stream(callBack: (data: DocumentData | DocumentData[] | undefined) => void, id?: string): void;
+    streamWhere(wh: whereClause[], callBack: (data: DocumentData[]) => void, lim?: number, order?: {
+        parameter: string;
+        direction?: 'asc' | 'desc';
+    }, offset?: string): void;
+    countData(where: whereClause[]): Promise<number>;
+    saveBatch({ data }: {
+        data: object[];
+    }): Promise<boolean>;
+    updateBatch({ data }: {
+        data: object[];
+        callBack: () => void;
+    }): Promise<boolean>;
+    deleteBatch({ ids }: {
+        ids: string[];
+    }): Promise<boolean>;
+    incrementDecrement({ dbReference, key, isIncrement, incrementalValue }: {
+        dbReference: string;
+        key: string;
+        isIncrement?: boolean;
+        incrementalValue?: number;
+    }): Promise<boolean>;
+}
+
+declare class BaseModel implements Model {
+    data: any;
+    private firestorDB?;
+    private table;
+    constructor(table: string, db: Firestore);
+    saveBatch({ data }: {
+        data: object[];
+    }): Promise<boolean>;
+    updateBatch({ data }: {
+        data: object[];
+    }): Promise<boolean>;
+    deleteBatch({ ids }: {
+        ids: string[];
+    }): Promise<boolean>;
+    stream(callBack: (data: DocumentData | DocumentData[] | undefined) => void, id?: string): _firebase_firestore.Unsubscribe | undefined;
+    streamWhere(wh: whereClause[], callBack: (data: DocumentData[]) => void, lim?: number, order?: {
+        parameter: string;
+        direction?: 'asc' | 'desc';
+    }, offset?: string): Unsubscribe | undefined;
+    find(id: string): Promise<boolean>;
+    dataExists(id: string): Promise<boolean>;
+    update(data: any, id: string): Promise<boolean>;
+    updateAtomicArray(data: any[], reference: string, key: string): Promise<boolean>;
+    removeFromArray(data: any[], id: string, key: string): Promise<boolean>;
+    findAll(ids?: string[]): Promise<boolean>;
+    findWhereOrAnd({ wh, lim, order, offset }: {
+        wh?: {
+            type: 'or' | 'and' | 'andOr';
+            parameter: andOrWhereClause[];
+        };
+        lim?: number;
+        order?: {
+            parameter: string;
+            direction?: 'asc' | 'desc';
+        };
+        offset?: string;
+    }): Promise<boolean>;
+    findWhere({ wh, lim, order, offset }: {
+        wh?: whereClause[];
+        lim?: number;
+        order?: {
+            parameter: string;
+            direction?: 'asc' | 'desc';
+        };
+        offset?: string;
+    }): Promise<DocumentData[]>;
+    save(data: any, id?: string | undefined): Promise<string | boolean>;
+    delete(id: string): Promise<boolean>;
+    incrementDecrement({ dbReference, key, isIncrement, incrementalValue }: {
+        dbReference: string;
+        key: string;
+        isIncrement?: boolean;
+        incrementalValue?: number;
+    }): Promise<boolean>;
+    countData(wh: whereClause[]): Promise<number>;
+    streamCount(wh: whereClause[], callBack: (data: number) => void, order?: {
+        parameter: string;
+        direction?: 'asc' | 'desc';
+    }, offset?: string): Promise<() => void>;
+}
+
+declare class Users extends BaseModel {
+    private user?;
+    registerWithEmailAndPassword({ auth, email, password, userData, persist, }: {
+        auth: Auth;
+        email: string;
+        password: string;
+        userData?: dbItems;
+        persist?: 'local' | 'session';
+    }): Promise<string | null>;
+    login({ email, password, auth, persist, verifyEmail }: {
+        email: string;
+        password: string;
+        auth: Auth;
+        persist?: 'session' | 'local';
+        verifyEmail?: boolean;
+    }): Promise<QueryReturn>;
+    signInWithPhoneNumber({ auth, phoneNumber, appVerifier }: {
+        auth: Auth;
+        phoneNumber: string;
+        appVerifier: ApplicationVerifier;
+    }): Promise<ConfirmationResult | boolean>;
+    isLoggedIn(auth: Auth): boolean;
+    resetPassword({ auth, newPassword }: {
+        auth: Auth;
+        newPassword: string;
+    }): Promise<boolean>;
+    sendPasswordResetMessage({ auth, email }: {
+        auth: Auth;
+        email: string;
+    }): Promise<boolean>;
+    logout({ auth }: {
+        auth: Auth;
+    }): Promise<boolean>;
+    loginWithMultiAuthFactor({ email, password, auth, recaptcha, getNumber, persist, verifyEmail }: {
+        email: string;
+        password: string;
+        auth: Auth;
+        recaptcha: ApplicationVerifier;
+        getNumber?: boolean;
+        persist?: boolean;
+        verifyEmail?: boolean;
+    }): Promise<MFAVerifier | null>;
+    private getPhoneNumber;
+    private setMultiFactorEnrollment;
+    confirmOTP: (verifier: MFAVerifier, userCode: string) => Promise<User | null>;
+    private sendOTP;
+    verifyEmail: (auth: Auth, actionCode: string) => Promise<boolean>;
+    verifyPasswordResetLink: (auth: Auth, actionCode: string) => Promise<string>;
+    deleteAccount(user: User): Promise<void>;
+    sendEmailVerification(user: User): Promise<string | null>;
+    doPasswordReset(auth: Auth, actionCode: string, newPassword: string): Promise<boolean>;
+}
+
+declare class StorageUpload {
+    uploadError?: string;
+    file?: File | string;
+    private additionalPath?;
+    private maxSize?;
+    fullPath?: string;
+    private storage;
+    constructor(props: {
+        storage: FirebaseStorage;
+        file: File | string;
+        basePath: UPLOADTYPES;
+        otherPath: string;
+        maxSize?: number;
+    });
+    private validateFile;
+    private sizeMetric;
+    private getExtensionName;
+    private getDocExtensionName;
+    private setUploadError;
+    private setFilePath;
+    doUpload(): Promise<string | boolean>;
+    private uploadAsString;
+    private uploadAsFile;
+    static deleteFile(filePath: string, storage: FirebaseStorage): Promise<boolean>;
+}
+
+declare const generateRandomString: (length: number) => string;
+declare const camelToTitleCase: (key: string) => string;
+declare function convertUnicode(input: string): string;
+declare const moneyFormatter: (x: number | string, shorten?: boolean, decimailPlaces?: number) => string;
+declare function getDaysAgo(startDate: Date, daysApart: number): Date;
+declare function timeAgo(dateInput: Date | string | number): string;
+declare const range: (start: number, end: number) => number[];
+declare const nairaFormatter: (amount: number) => string;
+declare const camelCaseToNormal: (camelCaseStr: string) => string;
+declare const errorLogger: (...error: any) => void;
+declare function isValidEmail(email: string): string | undefined;
+declare function isValidPassword(password: string): string | undefined;
+declare function numberToAlphabet(num: number): string;
+declare const getNthNumberOfArray: (param: {
+    num: number;
+    step: number;
+    start?: number;
+}) => number[];
+declare const noEmptyField: (args: {
+    requiredFields: string[];
+    formData: any;
+}) => boolean;
+declare const getInitials: (fullName?: string) => string;
+type TimeStamp = {
+    unix: number;
+    iso: string;
+};
+declare const fetchCurrentTimestamp: () => Promise<TimeStamp>;
+declare const formHasError: (formError: Record<string, string | undefined>) => boolean;
+
+declare function useAuth(auth: Auth, callback: (user: User | null) => void): void;
+
+declare const useCount: <T extends BaseModel>(param: {
+    model: T | any;
+    where?: whereClause[];
+}) => [number, boolean, Dispatch<SetStateAction<boolean>>];
+
+declare const useFetch: <T extends BaseModel>(param: {
+    model: T | any;
+    where?: whereClause[];
+    reference?: string;
+    filter?: {
+        orderBy?: {
+            parameter: string;
+            direction?: "asc" | "desc";
+        };
+        offset?: string;
+        limit?: number;
+    };
+}) => [typeof param.model.data, boolean, Dispatch<SetStateAction<boolean>>];
+
+declare const useStream: <T extends BaseModel>(param: {
+    model: T | any;
+    where?: whereClause[];
+    reference?: string;
+    filter?: {
+        orderBy?: {
+            parameter: string;
+            direction?: "asc" | "desc";
+        };
+        offset?: string;
+    };
+}, callback: (data: any) => void) => void;
+
+export { AUTH_PROVIDERS, BaseModel, FunctionReturn, MFAVerifier, Model, QueryReturn, StorageUpload, UPLOADTYPES, Users, andOrWhereClause, camelCaseToNormal, camelToTitleCase, convertUnicode, dbItems, errorLogger, fbsession, fetchCurrentTimestamp, formHasError, generateRandomString, getDaysAgo, getInitials, getNthNumberOfArray, isValidEmail, isValidPassword, moneyFormatter, nairaFormatter, noEmptyField, numberToAlphabet, range, timeAgo, useAuth, useCount, useFetch, useStream, whereClause };