@rebasepro/core 0.0.1-canary.0

package/src/hooks/ApiConfigContext.tsx

@@ -0,0 +1,40 @@
+import React, { useContext } from "react";
+
+/**
+ * Configuration for API connectivity. Passed once at the top level
+ * and available to any hook that needs `apiUrl` or `getAuthToken`.
+ *
+ * Individual hooks can still accept explicit overrides — this context
+ * serves as a fallback to eliminate repetitive threading.
+ */
+export interface ApiConfig {
+    apiUrl: string;
+    getAuthToken?: () => Promise<string | null>;
+}
+
+const ApiConfigContext = React.createContext<ApiConfig | undefined>(undefined);
+
+/**
+ * Read the API config from context. Returns `undefined` if no provider is present,
+ * allowing hooks to fall back to their own props.
+ */
+export function useApiConfig(): ApiConfig | undefined {
+    return useContext(ApiConfigContext);
+}
+
+/**
+ * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * Typically rendered inside `<Rebase>` or at the app root.
+ */
+export function ApiConfigProvider({
+    apiUrl,
+    getAuthToken,
+    children
+}: ApiConfig & { children: React.ReactNode }) {
+    const value = React.useMemo(() => ({ apiUrl, getAuthToken }), [apiUrl, getAuthToken]);
+    return (
+        <ApiConfigContext.Provider value={value}>
+            {children}
+        </ApiConfigContext.Provider>
+    );
+}

package/src/hooks/data/delete.ts

@@ -0,0 +1,77 @@
+import {
+    DataSource,
+    DeleteEntityProps,
+    Entity,
+    EntityCallbacks,
+    EntityCollection,
+    EntityBeforeDeleteProps,
+    RebaseContext,
+    User
+} from "@rebasepro/types";
+
+/**
+ * @group Hooks and utilities
+ */
+export type DeleteEntityWithCallbacksProps<M extends Record<string, any>, USER extends User = User> =
+    DeleteEntityProps<M>
+    & {
+        callbacks?: EntityCallbacks<M, USER>;
+        onDeleteSuccess?: (entity: Entity<M>) => void;
+        onDeleteFailure?: (entity: Entity<M>, e: Error) => void;
+    }
+
+/**
+ * This function is in charge of deleting an entity in the datasource.
+ * It will run all the delete callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * If you just want to delete any data without running the `beforeDelete`,
+ * and `afterDelete` callbacks, you can use the `deleteEntity` method
+ * in the datasource ({@link useDataSource}).
+ *
+ * @param dataSource
+ * @param entity
+ * @param collection
+ * @param callbacks
+ * @param onDeleteSuccess
+ * @param onDeleteFailure
+ * @param context
+ * @group Hooks and utilities
+ */
+export async function deleteEntityWithCallbacks<M extends Record<string, any>, USER extends User>({
+    dataSource,
+    entity,
+    collection,
+    callbacks,
+    onDeleteSuccess,
+    onDeleteFailure,
+    context
+}: DeleteEntityWithCallbacksProps<M> & {
+    collection: EntityCollection<M>,
+    dataSource: DataSource,
+    context: RebaseContext<USER>
+}
+): Promise<boolean> {
+
+    console.debug("Deleting entity", entity.path, entity.id);
+
+    const entityDeleteProps: EntityBeforeDeleteProps<M, any> = {
+        entity,
+        collection,
+        entityId: entity.id,
+        path: entity.path,
+        context
+    };
+
+    return dataSource.deleteEntity({
+        entity,
+        collection
+    }).then(() => {
+        onDeleteSuccess && onDeleteSuccess(entity);
+        return true;
+    }).catch((e) => {
+        if (onDeleteFailure) onDeleteFailure(entity, e);
+        return false;
+    });
+}

package/src/hooks/data/save.ts

@@ -0,0 +1,75 @@
+import { DataSource, Entity, EntityCollection, EntityValues, RebaseContext, SaveEntityProps } from "@rebasepro/types";
+import { useDataSource } from "./useDataSource";
+
+/**
+ * @group Hooks and utilities
+ */
+export type SaveEntityWithCallbacksProps<M extends Record<string, any>> =
+    SaveEntityProps<M> &
+    {
+        afterSave?: (updatedEntity: Entity<M>) => void,
+        afterSaveError?: (e: Error) => void
+    }
+
+/**
+ * This function is in charge of saving an entity to the datasource.
+ * It will run all the save callbacks specified in the collection.
+ * It is also possible to attach callbacks on save success or error, and callback
+ * errors.
+ *
+ * If you just want to save the data without running the `afterSave`,
+ * `afterSaveError` and `beforeSave` callbacks, you can use the `saveEntity` method
+ * in the datasource ({@link useDataSource}).
+ *
+ * @param collection
+ * @param path
+ * @param entityId
+ * @param callbacks
+ * @param values
+ * @param previousValues
+ * @param status
+ * @param dataSource
+ * @param context
+ * @param afterSave
+ * @param afterSaveError
+ * @see useDataSource
+ * @group Hooks and utilities
+ */
+export async function saveEntityWithCallbacks<M extends Record<string, any>>({
+    collection,
+    path,
+    entityId,
+    values,
+    previousValues,
+    status,
+    dataSource,
+    context,
+    afterSave,
+    afterSaveError
+}: SaveEntityWithCallbacksProps<M> & {
+    collection: EntityCollection,
+    dataSource: DataSource,
+    context: RebaseContext,
+}
+): Promise<Entity<M>> {
+
+    if (status !== "new" && !entityId) {
+        throw new Error("Entity id must be specified when updating an existing entity");
+    }
+
+    return dataSource.saveEntity({
+        collection,
+        path,
+        entityId,
+        values,
+        previousValues,
+        status
+    }).then((entity) => {
+        if (afterSave)
+            afterSave(entity);
+        return entity as Entity<M>;
+    }).catch((e) => {
+        if (afterSaveError) afterSaveError(e);
+        throw e;
+    });
+}

package/src/hooks/data/useCollectionFetch.tsx

@@ -0,0 +1,148 @@
+import { useEffect, useState } from "react";
+import { Entity, EntityCollection, FilterValues, RebaseContext, User } from "@rebasepro/types";
+import { useDataSource } from "./useDataSource";
+import { useCMSUrlController } from "../navigation/contexts";
+import { useRebaseContext } from "../useRebaseContext";
+
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchProps<M extends Record<string, any>> {
+
+    /**
+     * Absolute collection path
+     */
+    path: string;
+
+    /**
+     * collection of the entity displayed by this collection
+     */
+    collection: EntityCollection<M>
+
+    /**
+     * Number of entities to fetch
+     */
+    itemCount?: number;
+
+    /**
+     * Filter the fetched data by the property
+     */
+    filterValues?: FilterValues<Extract<keyof M, string>>;
+
+    /**
+     * Sort the results by
+     */
+    sortBy?: [Extract<keyof M, string>, "asc" | "desc"];
+
+    /**
+     * Search string
+     */
+    searchString?: string;
+}
+
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionFetchResult<M extends Record<string, any>> {
+    data: Entity<M>[];
+    dataLoading: boolean;
+    noMoreToLoad: boolean;
+    dataLoadingError?: Error;
+}
+
+/**
+ * This hook is used to fetch collections using a given collection
+ * @param path
+ * @param collection
+ * @param filterValues
+ * @param sortBy
+ * @param itemCount
+ * @param searchString
+ * @group Hooks and utilities
+ */
+export function useCollectionFetch<M extends Record<string, any>, USER extends User>(
+    {
+        path: inputPath,
+        collection,
+        filterValues,
+        sortBy,
+        itemCount,
+        searchString
+    }: CollectionFetchProps<M>): CollectionFetchResult<M> {
+
+    const dataSource = useDataSource(collection);
+    const navigationController = useCMSUrlController();
+
+    const path = navigationController.resolveDatabasePathsFrom(inputPath);
+
+    const sortByProperty = sortBy ? sortBy[0] : undefined;
+    const currentSort = sortBy ? sortBy[1] : undefined;
+
+    const context: RebaseContext<USER> = useRebaseContext();
+
+    const [data, setData] = useState<Entity<M>[]>([]);
+
+    const [dataLoading, setDataLoading] = useState<boolean>(false);
+    const [dataLoadingError, setDataLoadingError] = useState<Error | undefined>();
+    const [noMoreToLoad, setNoMoreToLoad] = useState<boolean>(false);
+
+    useEffect(() => {
+
+        setDataLoading(true);
+
+        const onEntitiesUpdate = async (entities: Entity<M>[]) => {
+            setDataLoading(false);
+            setDataLoadingError(undefined);
+            setData(entities.map(e => ({
+                ...e,
+                // values: sanitizeData(e.values, resolvedCollection.properties)
+            })));
+            setNoMoreToLoad(!itemCount || entities.length < itemCount);
+        };
+
+        const onError = (error: Error) => {
+            console.error("ERROR", error);
+            setDataLoading(false);
+            setData([]);
+            setDataLoadingError(error);
+        };
+
+        if (dataSource.listenCollection) {
+            return dataSource.listenCollection<M>({
+                path: path,
+                collection,
+                onUpdate: onEntitiesUpdate,
+                onError,
+                searchString,
+                filter: filterValues,
+                limit: itemCount,
+                startAfter: undefined,
+                orderBy: sortByProperty,
+                order: currentSort
+            });
+        } else {
+            dataSource.fetchCollection<M>({
+                path: path,
+                collection,
+                searchString,
+                filter: filterValues,
+                limit: itemCount,
+                startAfter: undefined,
+                orderBy: sortByProperty,
+                order: currentSort
+            })
+                .then(onEntitiesUpdate)
+                .catch(onError);
+            return () => {
+            };
+        }
+    }, [path, itemCount, currentSort, sortByProperty, filterValues, searchString]);
+
+    return {
+        data,
+        dataLoading,
+        dataLoadingError,
+        noMoreToLoad
+    };
+
+}

package/src/hooks/data/useDataOrder.ts

@@ -0,0 +1,26 @@
+import { Entity } from "@rebasepro/types";
+
+export interface DataOrderProps<M extends Record<string, any>> {
+    data: Entity<M>[];
+    entitiesDisplayedFirst?: Entity<M>[];
+}
+
+/**
+ * This hook is used to have some entities at the beginning of data.
+ * @param path
+ * @param entitiesDisplayedFirst
+ * @group Hooks and utilities
+ */
+export function useDataOrder<M extends Record<string, any>>(
+    {
+        data,
+        entitiesDisplayedFirst
+    }: DataOrderProps<M>): Entity<M>[] {
+
+    if (!entitiesDisplayedFirst)
+        return data;
+
+    const displayedFirstId = new Set(entitiesDisplayedFirst.map((e) => e.id));
+    return [...entitiesDisplayedFirst, ...data.filter((e) => !displayedFirstId.has(e.id))];
+
+}

package/src/hooks/data/useDataSource.tsx

@@ -0,0 +1,22 @@
+import { useContext } from "react";
+import { DataSource, EntityCollection } from "@rebasepro/types";
+import { DataSourceContext } from "../../contexts/DataSourceContext";
+
+/**
+ * Use this hook to get the datasource being used
+ * @group Hooks and utilities
+ */
+export const useDataSource = (collection?: EntityCollection<any, any>): DataSource => {
+    // const customizationController = useCustomizationController();
+    // const navigationController = useCollectionRegistryController();
+    const defaultDataSource = useContext(DataSourceContext);
+    // if (collection?.overrides?.dataSource) {
+    //     console.trace("Using custom data source for collection " + collection.id);
+    //     return useBuildDataSource({
+    //         delegate: collection.overrides.dataSource,
+    //         propertyConfigs: customizationController?.propertyConfigs,
+    //         navigationController: navigationController
+    //     });
+    // }
+    return defaultDataSource;
+};

package/src/hooks/data/useEntityFetch.tsx

@@ -0,0 +1,121 @@
+import { useEffect, useState } from "react";
+import { Entity, EntityCollection, RebaseContext, User } from "@rebasepro/types";
+import { useDataSource } from "./useDataSource";
+import { useCMSUrlController } from "../navigation/contexts";
+import { useRebaseContext } from "../useRebaseContext";
+
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchProps<M extends Record<string, any>, USER extends User = User> {
+    path: string;
+    entityId?: string | number;
+    databaseId?: string;
+    collection: EntityCollection<M, USER>;
+    useCache?: boolean;
+}
+
+/**
+ * @group Hooks and utilities
+ */
+export interface EntityFetchResult<M extends Record<string, any>> {
+    entity?: Entity<M>,
+    dataLoading: boolean,
+    dataLoadingError?: Error
+}
+
+const CACHE: Record<string, Entity<any> | undefined> = {};
+
+/**
+ * This hook is used to fetch an entity.
+ * It gives real time updates if the datasource supports it.
+ * @param path
+ * @param collection
+ * @param entityId
+ * @param useCache
+ * @group Hooks and utilities
+ */
+
+export function useEntityFetch<M extends Record<string, any>, USER extends User>(
+    {
+        path: inputPath,
+        entityId,
+        collection,
+        databaseId,
+        useCache = false
+    }: EntityFetchProps<M, USER>): EntityFetchResult<M> {
+
+    const dataSource = useDataSource(collection);
+    const navigationController = useCMSUrlController();
+
+    const path = navigationController.resolveDatabasePathsFrom(inputPath);
+
+    const context: RebaseContext<USER> = useRebaseContext();
+
+    const [entity, setEntity] = useState<Entity<M> | undefined>();
+    const [dataLoading, setDataLoading] = useState<boolean>(true);
+    const [dataLoadingError, setDataLoadingError] = useState<Error | undefined>();
+
+    useEffect(() => {
+
+        setDataLoading(true);
+
+        const onEntityUpdate = async (updatedEntity?: Entity<M> | null) => {
+            CACHE[`${path}/${entityId}`] = updatedEntity ?? undefined;
+            setEntity(updatedEntity ?? undefined);
+            setDataLoading(false);
+            setDataLoadingError(undefined);
+        };
+
+        const onError = (error: Error) => {
+            console.error("ERROR fetching entity", error);
+            setDataLoading(false);
+            setEntity(undefined);
+            setDataLoadingError(error);
+        };
+
+        if (entityId && useCache && CACHE[`${path}/${entityId}`]) {
+            setEntity(CACHE[`${path}/${entityId}`]);
+            setDataLoading(false);
+            setDataLoadingError(undefined);
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            return () => {
+            };
+        } else if (entityId && path && collection) {
+            if (dataSource.listenEntity) {
+                return dataSource.listenEntity<M>({
+                    path,
+                    entityId,
+                    databaseId,
+                    collection,
+                    onUpdate: onEntityUpdate,
+                    onError
+                });
+            } else {
+                dataSource.fetchEntity<M>({
+                    path,
+                    entityId,
+                    databaseId,
+                    collection
+                })
+                    .then(onEntityUpdate)
+                    .catch(onError);
+                return () => {
+                };
+            }
+        }
+        // if no entityId is provided we do nothing
+        else {
+            onEntityUpdate(undefined);
+            return () => {
+            };
+        }
+    }, [entityId, path]);
+
+    return {
+        entity,
+        dataLoading,
+        dataLoadingError
+    };
+
+}