@rebasepro/core 0.0.1-canary.0

package/src/internal/common.tsx

@@ -0,0 +1,5 @@
+export const CONTAINER_FULL_WIDTH = "100vw";
+
+export const ADDITIONAL_TAB_WIDTH = "55vw";
+
+export const FORM_CONTAINER_WIDTH = "768px";

package/src/internal/useBuildDataSource.ts

@@ -0,0 +1,380 @@
+import { useCallback } from "react";
+import {
+    AuthController,
+    DataSource,
+    DeleteEntityProps,
+    Entity,
+    EntityCollection,
+    EntityValues,
+    FetchCollectionProps,
+    FetchEntityProps,
+    FilterValues,
+    RebaseContext,
+    ListenCollectionProps,
+    ListenEntityProps,
+    CollectionRegistryController,
+    Properties,
+    PropertyConfig,
+    SaveEntityProps
+} from "@rebasepro/types";
+import { updateDateAutoValues } from "@rebasepro/common";
+
+/**
+ * Use this hook to build a {@link DataSource} based on Firestore
+ * @param firebaseApp
+ * @group Firebase
+ */
+export function useBuildDataSource({
+    delegate,
+    propertyConfigs,
+    collectionRegistryController,
+    authController
+}: {
+    delegate: DataSource,
+    propertyConfigs?: Record<string, PropertyConfig>;
+    collectionRegistryController: CollectionRegistryController;
+    authController: AuthController;
+}): DataSource {
+
+    return {
+
+        /**
+         * Fetch entities in a Firestore path
+         * @param path
+         * @param collection
+         * @param filter
+         * @param limit
+         * @param startAfter
+         * @param searchString
+         * @param orderBy
+         * @param order
+         * @return Function to cancel subscription
+         * @see useCollectionFetch if you need this functionality implemented as a hook
+         * @group Firestore
+         */
+        fetchCollection: useCallback(<M extends Record<string, any>>({
+            path,
+            collection,
+            filter,
+            limit,
+            startAfter,
+            searchString,
+            orderBy,
+            order,
+        }: FetchCollectionProps<M>
+        ): Promise<Entity<M>[]> => {
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+            return usedDelegate.fetchCollection<M>({
+                path,
+                filter,
+                limit,
+                startAfter,
+                searchString,
+                orderBy,
+                order,
+                collection,
+            });
+        }, [delegate]),
+
+        /**
+         * Listen to a entities in a given path
+         * @param path
+         * @param collection
+         * @param onError
+         * @param filter
+         * @param limit
+         * @param startAfter
+         * @param searchString
+         * @param orderBy
+         * @param order
+         * @param onUpdate
+         * @return Function to cancel subscription
+         * @see useCollectionFetch if you need this functionality implemented as a hook
+         * @group Firestore
+         */
+        listenCollection: delegate.listenCollection
+            ? useCallback(<M extends Record<string, any>>(
+                {
+                    path,
+                    collection: collectionProp,
+                    filter,
+                    limit,
+                    startAfter,
+                    searchString,
+                    orderBy,
+                    order,
+                    onUpdate,
+                    onError
+                }: ListenCollectionProps<M>
+            ): () => void => {
+
+                const collection = collectionProp ?? collectionRegistryController.getCollection(path);
+                const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+
+                if (!usedDelegate.listenCollection)
+                    throw Error("useBuildDataSource delegate not initialised");
+
+                return usedDelegate.listenCollection<M>({
+                    path,
+                    filter,
+                    limit,
+                    startAfter,
+                    searchString,
+                    orderBy,
+                    order,
+                    onUpdate,
+                    onError,
+                    collection,
+                });
+            }, [delegate, collectionRegistryController.getCollection, collectionRegistryController])
+            : undefined,
+
+        /**
+         * Retrieve an entity given a path and a collection
+         * @param path
+         * @param entityId
+         * @param collection
+         * @group Firestore
+         */
+        fetchEntity: useCallback(<M extends Record<string, any>>({
+            path,
+            entityId,
+            collection
+        }: FetchEntityProps<M>
+        ): Promise<Entity<M> | undefined> => {
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+            return usedDelegate.fetchEntity({
+                path,
+                entityId,
+                collection,
+            });
+        }, [delegate.fetchEntity]),
+
+        /**
+         *
+         * @param path
+         * @param entityId
+         * @param collection
+         * @param onUpdate
+         * @param onError
+         * @return Function to cancel subscription
+         * @group Firestore
+         */
+        listenEntity: delegate.listenEntity
+            ? useCallback(<M extends Record<string, any>>(
+                {
+                    path,
+                    entityId,
+                    collection,
+                    onUpdate,
+                    onError
+                }: ListenEntityProps<M>): () => void => {
+                const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+
+                if (!usedDelegate.listenEntity)
+                    throw Error("useBuildDataSource delegate not initialised");
+
+                return usedDelegate.listenEntity<M>({
+                    path,
+                    entityId,
+                    onUpdate,
+                    onError,
+                    collection,
+                })
+            }, [delegate.listenEntity]) : undefined,
+
+        /**
+         * Save entity to the specified path. Note that Firestore does not allow
+         * undefined values.
+         * @param path
+         * @param entityId
+         * @param values
+         * @param schemaId
+         * @param collection
+         * @param status
+         * @group Firestore
+         */
+        saveEntity: useCallback(async <M extends Record<string, any>>(
+            {
+                path,
+                entityId,
+                values,
+                collection: collectionProp,
+                status
+            }: SaveEntityProps<M>): Promise<Entity<M>> => {
+
+            const collection = collectionProp ?? collectionRegistryController.getCollection(path);
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+
+            const properties: Properties | undefined = collection?.properties;
+
+            const updatedValues: Partial<EntityValues<M>> = properties
+                ? updateDateAutoValues(
+                    {
+                        inputValues: values,
+                        properties,
+                        status,
+                        timestampNowValue: usedDelegate.currentTime?.() ?? new Date()
+                    })
+                : values;
+
+            // Auto-assign order property value for new/copy entities
+            let finalValues = updatedValues;
+            const orderProperty = collection?.orderProperty;
+            if (orderProperty && (status === "new" || status === "copy")) {
+                const orderProp = properties?.[orderProperty as string];
+                if (orderProp) {
+                    const currentValue = updatedValues[orderProperty as keyof M];
+                    if (currentValue === undefined || currentValue === null) {
+                        try {
+                            const entities = await usedDelegate.fetchCollection({
+                                path,
+                                orderBy: orderProperty,
+                                order: "asc",
+                                limit: 1,
+                                collection
+                            });
+                            const minOrder = entities.length > 0
+                                ? entities[0].values?.[orderProperty] ?? null
+                                : null;
+                            finalValues = {
+                                ...updatedValues,
+                                [orderProperty]: minOrder !== null ? minOrder - 1 : 0
+                            } as EntityValues<M>;
+                        } catch (e) {
+                            console.error("Failed to fetch min order value:", e);
+                            // Fallback to 0 if query fails
+                            finalValues = {
+                                ...updatedValues,
+                                [orderProperty]: 0
+                            } as EntityValues<M>;
+                        }
+                    }
+                }
+            }
+
+            return usedDelegate.saveEntity({
+                path,
+                collection,
+                entityId,
+                values: finalValues,
+                status,
+            });
+        }, [delegate.saveEntity, delegate.currentTime, delegate.fetchCollection, collectionRegistryController.getCollection]),
+
+        /**
+         * Delete an entity
+         * @param entity
+         * @param collection
+         * @group Firestore
+         */
+        deleteEntity: useCallback(<M extends Record<string, any>>(
+            {
+                entity,
+                collection
+            }: DeleteEntityProps<M>
+        ): Promise<void> => {
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+            return usedDelegate.deleteEntity({
+                entity,
+                collection,
+            });
+        }, [delegate.deleteEntity]),
+
+        /**
+         * Check if the given property is unique in the given collection
+         * @param path Collection path
+         * @param name of the property
+         * @param value
+         * @param property
+         * @param entityId
+         * @return `true` if there are no other fields besides the given entity
+         * @group Firestore
+         */
+        checkUniqueField: useCallback((
+            path: string,
+            name: string,
+            value: any,
+            entityId?: string | number,
+            collection?: EntityCollection
+        ): Promise<boolean> => {
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+            return usedDelegate.checkUniqueField(path, name, value, entityId, collection);
+        }, [delegate.checkUniqueField]),
+
+
+        countEntities: delegate.countEntities ? async ({
+            path,
+            collection,
+            filter,
+            order,
+            orderBy
+        }: {
+            path: string,
+            collection: EntityCollection<any>,
+            filter?: FilterValues<Extract<keyof any, string>>,
+            orderBy?: string,
+            order?: "desc" | "asc",
+        }): Promise<number> => {
+            const usedDelegate = collection?.overrides?.dataSource ?? delegate;
+            return usedDelegate.countEntities!({
+                path,
+                filter,
+                orderBy,
+                order,
+                collection,
+            });
+        } : undefined,
+
+        isFilterCombinationValid: useCallback(({
+            path,
+            databaseId,
+            filterValues,
+            sortBy
+        }: {
+            path: string,
+            databaseId?: string,
+            filterValues: FilterValues<any>,
+            sortBy?: [string, "asc" | "desc"]
+        }): boolean => {
+            if (!delegate.isFilterCombinationValid)
+                return true;
+            return delegate.isFilterCombinationValid(
+                {
+                    path,
+                    databaseId,
+                    filterValues,
+                    sortBy,
+                }
+            )
+        }, [delegate.isFilterCombinationValid]),
+
+        initTextSearch: useCallback(async (props: {
+            context: RebaseContext,
+            path: string,
+            collection: EntityCollection,
+            parentCollectionIds?: string[]
+        }): Promise<boolean> => {
+            const usedDelegate = props.collection?.overrides?.dataSource ?? delegate;
+            if (!usedDelegate.initTextSearch)
+                return false;
+            return usedDelegate.initTextSearch(props)
+        }, [delegate.initTextSearch]),
+
+        needsInitTextSearch: Boolean(delegate.initTextSearch),
+
+        executeSql: delegate.executeSql ? (sql: string, options?: any) => {
+            return delegate.executeSql!(sql, options);
+        } : undefined,
+
+        fetchAvailableDatabases: delegate.fetchAvailableDatabases ? () => {
+            return delegate.fetchAvailableDatabases!();
+        } : undefined,
+
+        fetchAvailableRoles: delegate.fetchAvailableRoles ? () => {
+            return delegate.fetchAvailableRoles!();
+        } : undefined,
+
+    };
+
+}

package/src/internal/useBuildSideDialogsController.tsx

@@ -0,0 +1,135 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import { SideDialogPanelProps, SideDialogsController } from "@rebasepro/types";
+import { deepEqual as equal } from "fast-equals"
+
+export function useBuildSideDialogsController(): SideDialogsController {
+
+    const location = useLocation();
+    const navigate = useNavigate();
+
+    const [sidePanels, setSidePanels] = useState<SideDialogPanelProps[]>([]);
+    const sidePanelsRef = useRef<SideDialogPanelProps[]>(sidePanels);
+
+    const routesStore = useRef<Record<string, SideDialogPanelProps>>({});
+    const routesCount = useRef<number>(0);
+
+    const updateSidePanels = (newPanels: SideDialogPanelProps[]) => {
+        sidePanelsRef.current = newPanels;
+        setSidePanels(newPanels);
+    };
+
+    useEffect(() => {
+        const state = location.state as any;
+        const panelKeys: string[] = state?.panels ?? [];
+        const newPanels = panelKeys
+            .map(key => routesStore.current[key])
+            .filter(p => Boolean(p)) as SideDialogPanelProps[];
+        if (!equal(sidePanelsRef.current.map(p => p.key), newPanels.map(p => p.key))) {
+            updateSidePanels(newPanels);
+            // If all panels were cleared via explicit navigation (full-screen expand),
+            // reset routesCount so close() doesn't fire navigate(-1)
+            if (newPanels.length === 0) {
+                routesCount.current = 0;
+            }
+        }
+    }, [location]);
+
+    const close = useCallback(() => {
+
+        const currentPanels = sidePanelsRef.current;
+        if (currentPanels.length === 0)
+            return;
+
+        const lastSidePanel = currentPanels[currentPanels.length - 1];
+        const updatedPanels = [...currentPanels.slice(0, -1)];
+        updateSidePanels(updatedPanels);
+
+        if (routesCount.current > 0) {
+            if (lastSidePanel.urlPath) // if it has a url path, we need to navigate back, don't remove this code
+                navigate(-1);
+            routesCount.current--;
+        } else if (lastSidePanel.parentUrlPath) {
+            const baseLocation = (location.state as any)?.base_location ?? location;
+            navigate(
+                lastSidePanel.parentUrlPath,
+                {
+                    replace: true,
+                    state: {
+                        base_location: baseLocation,
+                        panels: updatedPanels.map(p => p.key)
+                    }
+                }
+            );
+        }
+    }, [navigate, location]);
+
+    const open = useCallback((panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => {
+
+        const newPanels: SideDialogPanelProps[] = Array.isArray(panelProps) ? panelProps : [panelProps];
+
+        newPanels.forEach((panel) => {
+            routesStore.current[panel.key] = panel;
+        });
+        routesCount.current = routesCount.current + newPanels.length;
+
+        const baseLocation = (location.state as any)?.base_location ?? location;
+
+        const currentPanels = sidePanelsRef.current;
+        const updatedPanels = [...currentPanels, ...newPanels];
+        updateSidePanels(updatedPanels);
+
+        newPanels.forEach((panel) => {
+            if (panel.urlPath) {
+                navigate(
+                    panel.urlPath,
+                    {
+                        state: {
+                            base_location: baseLocation,
+                            panels: updatedPanels.map(p => p.key)
+                        }
+                    }
+                );
+            }
+        });
+
+    }, [location, navigate]);
+
+    const replace = useCallback((panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => {
+
+        const newPanels: SideDialogPanelProps[] = Array.isArray(panelProps) ? panelProps : [panelProps];
+        newPanels.forEach((panel) => {
+            routesStore.current[panel.key] = panel;
+        });
+
+        const baseLocation = (location.state as any)?.base_location ?? location;
+
+        const currentPanels = sidePanelsRef.current;
+        const updatedPanels = [...currentPanels.slice(0, -newPanels.length), ...newPanels];
+        updateSidePanels(updatedPanels);
+
+        newPanels.forEach((panel) => {
+            if (panel.urlPath) {
+                navigate(
+                    panel.urlPath,
+                    {
+                        replace: true,
+                        state: {
+                            base_location: baseLocation,
+                            panels: updatedPanels.map(p => p.key)
+                        }
+                    }
+                );
+            }
+        });
+
+    }, [location, navigate]);
+
+    return {
+        sidePanels,
+        setSidePanels: updateSidePanels,
+        close,
+        open,
+        replace
+    };
+}