@rebasepro/firebase 0.0.1-canary.2 → 0.0.1-canary.eb08332

package/src/hooks/useFirebaseRealTimeDBDelegate.ts

@@ -15,18 +15,9 @@ import {
     startAt
 } from "@firebase/database";
 import { useCallback } from "react";
-import {
-    DataSource,
-    DeleteEntityProps,
-    Entity,
-    FetchCollectionProps,
-    FetchEntityProps,
-    ListenCollectionProps,
-    ListenEntityProps,
-    SaveEntityProps
-} from "@rebasepro/core";
-
-export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: FirebaseApp }): DataSource {
+import { DataDriver, DeleteProps, FetchCollectionProps, FetchOneProps, FilterValues, ListenCollectionProps, ListenOneProps, SaveProps } from "@rebasepro/types";
+
+export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: FirebaseApp }): DataDriver {
 
     const fetchCollection = useCallback(async <M extends Record<string, any>>({
         path,
@@ -36,7 +27,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         orderBy,
         order,
         searchString
-    }: FetchCollectionProps<M>): Promise<Entity<M>[]> => {
+    }: FetchCollectionProps<M>): Promise<Record<string, unknown>[]> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
@@ -46,18 +37,17 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 
         // Example to apply "limit" and "startAfter"
         if (startAfter !== undefined) {
-            dbQuery = query(dbQuery, orderByKey(), startAt(startAfter as any));
+            dbQuery = query(dbQuery, orderByKey(), startAt(String(startAfter)));
         }
         if (limit !== undefined) {
             dbQuery = query(dbQuery, limitToFirst(limit));
         }
 
-        const snapshot = await get(dbQuery);
-        if (snapshot.exists()) {
-            return Object.entries(snapshot.val()).map(([id, values]) => ({
-                id,
-                path: path,
-                values: delegateToCMSModel(values) as M,
+        const entity = await get(dbQuery);
+        if (entity.exists()) {
+            return Object.entries(entity.val()).map(([id, values]) => ({
+                ...(delegateToCMSModel(values) as Record<string, unknown>),
+                id
             }));
         }
         return [];
@@ -65,7 +55,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 
     const listenCollection = useCallback(<M extends Record<string, any>>({
         path,
-        onUpdate,
+        onUpdate
         // Realtime Database does not directly support onError in onValue
     }: ListenCollectionProps<M>): () => void => {
         if (!firebaseApp) {
@@ -74,12 +64,11 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         const database = getDatabase(firebaseApp);
 
         const dbRef = ref(database, path);
-        const unsubscribe = onValue(dbRef, (snapshot) => {
-            if (snapshot.exists()) {
-                const result: Entity<M>[] = Object.entries(snapshot.val()).map(([id, values]) => ({
-                    id,
-                    path: path,
-                    values: delegateToCMSModel(values) as M,
+        const unsubscribe = onValue(dbRef, (entity) => {
+            if (entity.exists()) {
+                const result: Record<string, unknown>[] = Object.entries(entity.val()).map(([id, values]) => ({
+                    ...(delegateToCMSModel(values) as Record<string, unknown>),
+                    id
                 }));
                 onUpdate(result);
             } else {
@@ -90,44 +79,42 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         return () => unsubscribe();
     }, [firebaseApp]);
 
-    const fetchEntity = useCallback(async <M extends Record<string, any>>({
+    const fetchOne = useCallback(async <M extends Record<string, any>>({
         path,
-        entityId,
-    }: FetchEntityProps<M>): Promise<Entity<M> | undefined> => {
+        id
+    }: FetchOneProps<M>): Promise<Record<string, unknown> | undefined> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
         const database = getDatabase(firebaseApp);
 
-        const snapshot = await get(ref(database, `${path}/${entityId}`));
-        if (snapshot.exists()) {
+        const entity = await get(ref(database, `${path}/${id}`));
+        if (entity.exists()) {
             return {
-                id: entityId,
-                path: path,
-                values: delegateToCMSModel(snapshot.val()) as M
+                ...(delegateToCMSModel(entity.val()) as Record<string, unknown>),
+                id: id
             };
         }
         return undefined;
     }, [firebaseApp]);
 
-    const listenEntity = useCallback(<M extends Record<string, any>>({
+    const listenOne = useCallback(<M extends Record<string, any>>({
         path,
-        entityId,
+        id,
         onUpdate,
         onError
-    }: ListenEntityProps<M>): () => void => {
+    }: ListenOneProps<M>): () => void => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
         const database = getDatabase(firebaseApp);
 
-        const dbRef = ref(database, `${path}/${entityId}`);
-        const unsubscribe = onValue(dbRef, (snapshot) => {
-            if (snapshot.exists()) {
+        const dbRef = ref(database, `${path}/${id}`);
+        const unsubscribe = onValue(dbRef, (entity) => {
+            if (entity.exists()) {
                 onUpdate({
-                    id: entityId,
-                    path,
-                    values: delegateToCMSModel(snapshot.val()) as M
+                    ...(delegateToCMSModel(entity.val()) as Record<string, unknown>),
+                    id: id
                 });
             } else {
                 onError?.(new Error("Entity does not exist"));
@@ -137,18 +124,18 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         return () => unsubscribe();
     }, [firebaseApp]);
 
-    const saveEntity = useCallback(async <M extends Record<string, any>>({
+    const save = useCallback(async <M extends Record<string, any>>({
         path,
-        entityId,
-        values,
-    }: SaveEntityProps<M>): Promise<Entity<M>> => {
+        id,
+        values
+    }: SaveProps<M>): Promise<Record<string, unknown>> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
         const database = getDatabase(firebaseApp);
 
-        // If entityId is not provided, a new entity will be created
-        const finalId = entityId ?? push(ref(database, path)).key;
+        // If id is not provided, a new entity will be created
+        const finalId = id ?? push(ref(database, path)).key;
         if (!finalId) {
             throw new Error("Could not generate a new id");
         }
@@ -158,41 +145,40 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         await set(ref(database, `${path}/${finalId}`), transformedValues);
 
         return {
-            id: finalId,
-            path: path,
-            values: values as M
+            ...values,
+            id: finalId
         };
     }, [firebaseApp]);
 
-    const deleteEntity = useCallback(async <M extends Record<string, any>>({
-        entity,
-    }: DeleteEntityProps<M>): Promise<void> => {
+    const deleteOne = useCallback(async <M extends Record<string, any>>({
+        row
+    }: DeleteProps<M>): Promise<void> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
         const database = getDatabase(firebaseApp);
 
-        await remove(ref(database, `${entity.path}/${entity.id}`));
+        await remove(ref(database, `${row.path}/${row.id}`));
     }, [firebaseApp]);
 
-    // Implementing additional methods required by DataSource
-    const checkUniqueField = useCallback(async (slug: string, name: string, value: any, entityId?: string | number): Promise<boolean> => {
+    // Implementing additional methods required by DataDriver
+    const checkUniqueField = useCallback(async (slug: string, name: string, value: unknown, id?: string | number): Promise<boolean> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
         }
         const database = getDatabase(firebaseApp);
 
         // Simplified example; the Realtime Database does not support querying with "not equal" conditions
-        const dbRef = query(ref(database, slug), orderByChild(name), startAt(value), limitToFirst(1));
-        const snapshot = await get(dbRef);
+        const dbRef = query(ref(database, slug), orderByChild(name), startAt(value as string | number | boolean | null), limitToFirst(1));
+        const entity = await get(dbRef);
 
-        if (!snapshot.exists()) {
+        if (!entity.exists()) {
             return true;
         }
 
         // Check if the found entity is the same as the one being checked
-        const [key, entityValue] = Object.entries(snapshot.val())[0];
-        if (entityValue && typeof entityValue === "object" && (entityValue as any)[name] === value && key === entityId) {
+        const [key, entityValue] = Object.entries(entity.val())[0];
+        if (entityValue && typeof entityValue === "object" && (entityValue as Record<string, unknown>)[name] === value && key === id) {
             return true;
         }
 
@@ -203,7 +189,11 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         path,
         filter,
         sortBy
-    }: any): boolean => {
+    }: {
+        path: string;
+        filter?: FilterValues<string>;
+        sortBy?: [string, "asc" | "desc"];
+    }): boolean => {
         return false;
     }, []);
 
@@ -211,10 +201,10 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
         key: "firebase_rtdb",
         fetchCollection,
         listenCollection,
-        fetchEntity,
-        listenEntity,
-        saveEntity,
-        deleteEntity,
+        fetchOne,
+        listenOne,
+        save,
+        delete: deleteOne,
         checkUniqueField,
         isFilterCombinationValid,
         currentTime: () => new Date()
@@ -222,12 +212,11 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 }
 
 
-
 /**
  * Transform data from RTDB format back to CMS format
  * This is used internally when fetching/listening to data
  */
-function delegateToCMSModel(data: any): any {
+function delegateToCMSModel(data: unknown): unknown {
     if (data === null || data === undefined) return null;
 
     if (Array.isArray(data)) {
@@ -235,9 +224,9 @@ function delegateToCMSModel(data: any): any {
     }
 
     if (typeof data === "object") {
-        const result: Record<string, any> = {};
-        for (const key of Object.keys(data)) {
-            const childValue = delegateToCMSModel(data[key]);
+        const result: Record<string, unknown> = {};
+        for (const key of Object.keys(data as Record<string, unknown>)) {
+            const childValue = delegateToCMSModel((data as Record<string, unknown>)[key]);
             if (childValue !== undefined)
                 result[key] = childValue;
         }
@@ -251,20 +240,21 @@ function delegateToCMSModel(data: any): any {
  * Transform data from CMS format to RTDB format
  * This is used internally when saving data
  */
-function cmsToRTDBModel(data: any, database: Database): any {
+function cmsToRTDBModel(data: unknown, database: Database): unknown {
     if (data === undefined) {
         return null;
     } else if (data === null) {
         return null;
     } else if (Array.isArray(data)) {
         return data.filter(v => v !== undefined).map(v => cmsToRTDBModel(v, database));
-    } else if (data.isEntityReference && data.isEntityReference()) {
-        return ref(database, `${data.slug}/${data.id}`);
+    } else if (typeof data === "object" && data !== null && "isEntityReference" in data && typeof (data as Record<string, unknown>).isEntityReference === "function" && (data as { isEntityReference: () => boolean }).isEntityReference()) {
+        const entityRef = data as unknown as { slug: string; id: string };
+        return ref(database, `${entityRef.slug}/${entityRef.id}`);
     } else if (data instanceof Date) {
         // For dates, convert to ISO string or timestamp.
         return data.toISOString();
     } else if (data && typeof data === "object") {
-        return Object.entries(data)
+        return Object.entries(data as Record<string, unknown>)
             .map(([key, v]) => {
                 const rtdbModel = cmsToRTDBModel(v, database);
                 if (rtdbModel !== undefined)
@@ -272,7 +262,8 @@ function cmsToRTDBModel(data: any, database: Database): any {
                 else
                     return {};
             })
-            .reduce((a, b) => ({ ...a, ...b }), {});
+            .reduce((a, b) => ({ ...a,
+...b }), {});
     }
     return data;
 }

package/src/hooks/useFirebaseStorageSource.ts

@@ -8,7 +8,7 @@ import {
     ref,
     uploadBytesResumable
 } from "@firebase/storage";
-import { DownloadConfig, DownloadMetadata, StorageListResult, StorageSource, UploadFileProps } from "@rebasepro/core";
+import { DownloadConfig, DownloadMetadata, StorageListResult, StorageSource, UploadFileProps } from "@rebasepro/types";
 
 /**
  * @group Firebase
@@ -29,10 +29,9 @@ export function useFirebaseStorageSource({
     const projectId = firebaseApp?.options?.projectId;
     const urlsCache: Record<string, DownloadConfig> = {};
     return {
-        uploadFile({
+        putObject({
             file,
-            fileName,
-            path,
+            key,
             metadata,
             bucket
         }: UploadFileProps)
@@ -42,9 +41,8 @@ export function useFirebaseStorageSource({
                 const storageBucketUrl = bucket ?? bucketUrl;
                 const storage = getStorage(firebaseApp, storageBucketUrl);
                 if (!storage) throw Error("useFirebaseStorageSource Firebase not initialised");
-                const usedFilename = fileName ?? file.name;
 
-                const storageRef = ref(storage, `${path}/${usedFilename}`);
+                const storageRef = ref(storage, key);
                 const uploadTask = uploadBytesResumable(storageRef, file, metadata);
 
                 return new Promise((resolve, reject) => {
@@ -71,8 +69,8 @@ export function useFirebaseStorageSource({
                     setProgressTimeout();
 
                     uploadTask.on("state_changed",
-                        (snapshot) => {
-                            const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
+                        (entity) => {
+                            const progress = (entity.bytesTransferred / entity.totalBytes) * 100;
 
                             if (progress > lastProgress) {
                                 lastProgress = progress;
@@ -102,8 +100,7 @@ export function useFirebaseStorageSource({
                             } else if (errorMessage.toLowerCase().includes("network")) {
                                 reject(new Error("Network error: Check your internet connection"));
                             } else {
-                                const newError = new Error(errorMessage);
-                                (newError as any).code = error?.code;
+                                const newError = Object.assign(new Error(errorMessage), { code: error?.code });
                                 reject(newError);
                             }
                         },
@@ -112,9 +109,9 @@ export function useFirebaseStorageSource({
                             const fullPath = uploadTask.snapshot.ref.fullPath;
                             const bucketName = uploadTask.snapshot.ref.bucket;
                             resolve({
-                                path: fullPath,
+                                key: fullPath,
                                 bucket: bucketName,
-                                storageUrl: `gs://${bucketName}/${fullPath}`
+                                storageUrl: `s3://${bucketName}/${fullPath}`
                             });
                         }
                     );
@@ -124,7 +121,7 @@ export function useFirebaseStorageSource({
             }
         },
 
-        async getFile(path: string, bucket?: string): Promise<File | null> {
+        async getObject(path: string, bucket?: string): Promise<File | null> {
             try {
                 if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
                 const storageBucketUrl = bucket ?? bucketUrl;
@@ -135,21 +132,22 @@ export function useFirebaseStorageSource({
                 const response = await fetch(url);
                 const blob = await response.blob();
                 return new File([blob], path);
-            } catch (e: any) {
-                if (e?.code === "storage/object-not-found") return null;
+            } catch (e: unknown) {
+                if (typeof e === "object" && e !== null && "code" in e && (e as { code: string }).code === "storage/object-not-found") return null;
                 throw e;
             }
         },
 
-        async getDownloadURL(storagePathOrUrl: string, bucket?: string): Promise<DownloadConfig> {
+        async getSignedUrl(storagePathOrUrl: string, bucket?: string): Promise<DownloadConfig> {
             if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
 
-            // Support fully-qualified gs:// URLs
+            // Support fully-qualified s3:// and gs:// URLs for backward compatibility
             let resolvedPathOrUrl = storagePathOrUrl;
             let resolvedBucket = bucket;
-            if (storagePathOrUrl.startsWith("gs://")) {
-                // Format: gs://<bucket>/<path>
-                const withoutProtocol = storagePathOrUrl.substring("gs://".length);
+            const match = storagePathOrUrl.match(/^(s3|gs):\/\//);
+            if (match) {
+                const protocolLength = match[0].length;
+                const withoutProtocol = storagePathOrUrl.substring(protocolLength);
                 const firstSlash = withoutProtocol.indexOf("/");
                 if (firstSlash > 0) {
                     resolvedBucket = withoutProtocol.substring(0, firstSlash);
@@ -172,8 +170,8 @@ export function useFirebaseStorageSource({
                 }
                 urlsCache[storagePathOrUrl] = result;
                 return result;
-            } catch (e: any) {
-                if (e?.code === "storage/object-not-found") return {
+            } catch (e: unknown) {
+                if (typeof e === "object" && e !== null && "code" in e && (e as { code: string }).code === "storage/object-not-found") return {
                     url: null,
                     fileNotFound: true
                 };
@@ -181,7 +179,7 @@ export function useFirebaseStorageSource({
             }
         },
 
-        async list(path: string, options?: {
+        async listObjects(prefix: string, options?: {
             bucket?: string,
             maxResults?: number,
             pageToken?: string
@@ -190,14 +188,14 @@ export function useFirebaseStorageSource({
             const storageBucketUrl = options?.bucket ?? bucketUrl;
             const storage = getStorage(firebaseApp, storageBucketUrl);
             if (!storage) throw Error("useFirebaseStorageSource Firebase not initialised");
-            const folderRef = ref(storage, path);
+            const folderRef = ref(storage, prefix);
             return await list(folderRef, {
                 maxResults: options?.maxResults,
                 pageToken: options?.pageToken
             });
         },
 
-        async deleteFile(path: string, bucket?: string): Promise<void> {
+        async deleteObject(path: string, bucket?: string): Promise<void> {
             if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
             const storageBucketUrl = bucket ?? bucketUrl;
             const storage = getStorage(firebaseApp, storageBucketUrl);