@rebasepro/cms 0.0.1-canary.4d4fb3e

package/src/components/EntityCollectionView/EntityCollectionViewActions.tsx

@@ -0,0 +1,149 @@
+import type { EntityCollection } from "@rebasepro/types";
+import React from "react";
+
+import { useAuthController, useRebaseContext, useLargeLayout, useTranslation, useSlot } from "@rebasepro/core";
+import { CollectionActionsProps, EntityTableController, SelectionController, ViewMode } from "@rebasepro/types";
+import {
+    AddIcon,
+    Button,
+    DeleteIcon,
+    IconButton,
+    Tooltip
+} from "@rebasepro/ui";
+import { ErrorBoundary } from "@rebasepro/ui";
+import { usePermissions } from "@rebasepro/core";
+import { toArray } from "@rebasepro/utils";
+import { ImportCollectionAction } from "../../data_import/import";
+import { ExportCollectionAction } from "../../data_export/export";
+import { EditorCollectionAction } from "../../collection_editor/ui/EditorCollectionAction";
+import { useCollectionEditorController } from "../../collection_editor/useCollectionEditorController";
+
+export type EntityCollectionViewActionsProps<M extends Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+}
+
+export function EntityCollectionViewActions<M extends Record<string, unknown>>({
+    collection,
+    relativePath,
+    parentCollectionIds,
+    onNewClick,
+    onMultipleDeleteClick,
+    selectionEnabled,
+    path,
+    selectionController,
+    tableController,
+    collectionEntitiesCount,
+}: EntityCollectionViewActionsProps<M>) {
+
+    const context = useRebaseContext();
+
+    const { canCreate, canDelete } = usePermissions();
+
+    const largeLayout = useLargeLayout();
+    const { t } = useTranslation();
+
+    // Check if the collection editor context is available (ConfigControllerProvider present)
+    const collectionEditorController = useCollectionEditorController();
+    const hasCollectionEditor = Boolean(collectionEditorController?.editCollection);
+
+    const selectedEntities = selectionController.selectedEntities;
+
+    const addButton = canCreate(collection, path) &&
+        onNewClick && (largeLayout
+            ? <Button
+                id={`add_entity_${path}`}
+                onClick={onNewClick}
+                startIcon={<AddIcon size={"small"} />}
+                variant="filled"
+                color="primary">
+                Add {collection.singularName ?? collection.name}
+            </Button>
+            : <Button
+                id={`add_entity_${path}`}
+                onClick={onNewClick}
+                variant="filled"
+                color="primary"
+            >
+                <AddIcon size={"small"} />
+            </Button>);
+
+    const multipleDeleteEnabled = canDelete(collection, path, null);
+
+    let multipleDeleteButton: React.ReactNode | undefined;
+    if (selectionEnabled) {
+        const button = largeLayout
+            ? <Button
+                variant={"text"}
+                disabled={!(selectedEntities?.length) || !multipleDeleteEnabled}
+                startIcon={<DeleteIcon size={"small"} />}
+                onClick={onMultipleDeleteClick}
+                color={"primary"}
+                className="lg:w-20"
+            >
+                ({selectedEntities?.length})
+            </Button>
+            : <IconButton
+                size={"small"}
+                color={"primary"}
+                disabled={!(selectedEntities?.length) || !multipleDeleteEnabled}
+                onClick={onMultipleDeleteClick}>
+                <DeleteIcon size={"small"} />
+            </IconButton>;
+        multipleDeleteButton =
+            <Tooltip
+                title={multipleDeleteEnabled ? t("delete") : t("delete_not_allowed")}>
+                {button}
+            </Tooltip>
+    }
+
+    const actionProps: CollectionActionsProps<M> = {
+        path,
+        relativePath,
+        parentCollectionIds,
+        collection,
+        selectionController,
+        context,
+        tableController,
+        collectionEntitiesCount
+    };
+
+    const actions = toArray(collection.Actions)
+        .map((Action, i) => (
+            <ErrorBoundary key={`actions_${i}`}>
+                <Action {...actionProps} />
+            </ErrorBoundary>
+        ));
+
+    const pluginActions = useSlot("collection.actions", actionProps as any);
+
+    return (
+        <>
+            <ErrorBoundary>
+                {actions}
+                {pluginActions}
+            </ErrorBoundary>
+            <ErrorBoundary>
+                <ImportCollectionAction {...(actionProps as any)} />
+            </ErrorBoundary>
+            <ErrorBoundary>
+                <ExportCollectionAction {...(actionProps as any)} />
+            </ErrorBoundary>
+            {hasCollectionEditor && (
+                <ErrorBoundary>
+                    <EditorCollectionAction {...(actionProps as any)} />
+                </ErrorBoundary>
+            )}
+            {multipleDeleteButton}
+            {addButton}
+        </>
+    );
+}

package/src/components/EntityCollectionView/EntityCollectionViewStartActions.tsx

@@ -0,0 +1,122 @@
+import type { Properties } from "@rebasepro/types";
+import type { EntityCollection } from "@rebasepro/types";
+import React, { useState } from "react";
+import { useAuthController, useRebaseContext, useLargeLayout, useTranslation, useSlot } from "@rebasepro/core";
+import { CollectionActionsProps, EntityTableController, SelectionController } from "@rebasepro/types";
+import { ErrorBoundary } from "@rebasepro/ui";
+import { ClearFilterSortButton } from "../ClearFilterSortButton";
+import { FiltersDialog } from "./FiltersDialog";
+import { Badge, Button, cls, FilterListIcon, IconButton, Tooltip } from "@rebasepro/ui";
+import { toArray } from "@rebasepro/utils";
+
+export type EntityCollectionViewStartActionsProps<M extends Record<string, unknown>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount?: number;
+    /**
+     * Resolved properties from the collection for the filters dialog
+     */
+    resolvedProperties?: Properties;
+}
+
+export function EntityCollectionViewStartActions<M extends Record<string, unknown>>({
+    collection,
+    relativePath,
+    parentCollectionIds,
+    path,
+    selectionController,
+    tableController,
+    collectionEntitiesCount,
+    resolvedProperties
+}: EntityCollectionViewStartActionsProps<M>) {
+
+    const context = useRebaseContext();
+    const largeLayout = useLargeLayout();
+    const { t } = useTranslation();
+
+    // Filters dialog state
+    const [filtersDialogOpen, setFiltersDialogOpen] = useState(false);
+
+    // Count active filters (excluding force filters)
+    const filterValues = tableController.filterValues;
+    const forceFilter = collection.forceFilter;
+    const activeFilterCount = filterValues
+        ? Object.keys(filterValues).filter(key => !forceFilter || !(key in forceFilter)).length
+        : 0;
+
+    const actionProps: CollectionActionsProps<M> = {
+        path,
+        relativePath,
+        parentCollectionIds,
+        collection,
+        selectionController,
+        context,
+        tableController,
+        collectionEntitiesCount
+    };
+
+    // Filters button
+    const filtersButton = resolvedProperties && tableController.setFilterValues && (
+        <Tooltip title={t("filters")}
+            key={"filters_tooltip"}>
+            <Badge
+                color="primary"
+                invisible={activeFilterCount === 0}
+            >
+                {largeLayout ? (
+                    <Button
+                        variant="text"
+                        size="small"
+                        onClick={() => setFiltersDialogOpen(true)}
+                        startIcon={<FilterListIcon size="small" />}
+                        className={cls(activeFilterCount > 0 && "text-primary")}
+                    >
+                        {t("filters")}{activeFilterCount > 0 ? ` (${activeFilterCount})` : ""}
+                    </Button>
+                ) : (
+                    <IconButton
+                        size="small"
+                        onClick={() => setFiltersDialogOpen(true)}
+                        className={cls(activeFilterCount > 0 && "text-primary")}
+                    >
+                        <FilterListIcon size="small" />
+                    </IconButton>
+                )}
+            </Badge>
+        </Tooltip>
+    );
+
+    const actions: React.ReactNode[] = [
+        filtersButton,
+        <ClearFilterSortButton
+            key={"clear_filter"}
+            tableController={tableController}
+            enabled={!collection.forceFilter} />
+    ];
+
+    const pluginActionsStart = useSlot("collection.actions.start", actionProps);
+
+    return (
+        <>
+            {actions}
+            {pluginActionsStart}
+
+            {/* Filters Dialog */}
+            {resolvedProperties && tableController.setFilterValues && (
+                <FiltersDialog
+                    open={filtersDialogOpen}
+                    onOpenChange={setFiltersDialogOpen}
+                    properties={resolvedProperties}
+                    filterValues={tableController.filterValues}
+                    setFilterValues={(filterValues) => tableController.setFilterValues?.(filterValues ?? {})}
+                    forceFilter={collection.forceFilter}
+                />
+            )}
+        </>
+    );
+}
+

package/src/components/EntityCollectionView/FiltersDialog.tsx

@@ -0,0 +1,249 @@
+import type { Property } from "@rebasepro/types";
+import React, { useCallback, useMemo, useState } from "react";
+import { FilterValues, WhereFilterOp } from "@rebasepro/types";
+import {
+    Button,
+    cls,
+    defaultBorderMixin,
+    Dialog,
+    DialogActions,
+    DialogContent,
+    DialogTitle,
+    FilterListIcon,
+    Typography
+} from "@rebasepro/ui";
+import { StringNumberFilterField } from "../SelectableTable/filters/StringNumberFilterField";
+import { BooleanFilterField } from "../SelectableTable/filters/BooleanFilterField";
+import { DateTimeFilterField } from "../SelectableTable/filters/DateTimeFilterField";
+import { ReferenceFilterField } from "../SelectableTable/filters/ReferenceFilterField";
+import { VirtualTableWhereFilterOp } from "@rebasepro/ui";
+import { enumToObjectEntries } from "@rebasepro/common";
+import { useTranslation } from "@rebasepro/core";
+
+export interface FiltersDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    properties: Record<string, Property>;
+    filterValues: FilterValues<any> | undefined;
+    setFilterValues: (filterValues?: FilterValues<any>) => void;
+    forceFilter?: FilterValues<any>;
+}
+
+/**
+ * Dialog that displays all filterable properties from a collection
+ * and allows setting filter values for each.
+ */
+export function FiltersDialog({
+    open,
+    onOpenChange,
+    properties,
+    filterValues,
+    setFilterValues,
+    forceFilter
+}: FiltersDialogProps) {
+    const { t } = useTranslation();
+    // Local state for filters being edited
+    const [localFilters, setLocalFilters] = useState<FilterValues<any>>(filterValues ?? {});
+
+    // Track hidden state for reference fields (when reference dialog is open)
+    const [hiddenFields, setHiddenFields] = useState<Record<string, boolean>>({});
+
+    // Reset local state when dialog opens
+    React.useEffect(() => {
+        if (open) {
+            setLocalFilters(filterValues ?? {});
+        }
+    }, [open, filterValues]);
+
+    // Get list of filterable properties
+    const filterableProperties = useMemo(() => {
+        return Object.entries(properties).filter(([key, property]) => {
+            if (!property) return false;
+            // Force filter properties should not be editable
+            if (forceFilter && key in forceFilter) return false;
+            // Check if property type is filterable
+            const baseProperty = property.type === "array" ? property.of : property;
+            if (!baseProperty || Array.isArray(baseProperty)) return false;
+            return ["string", "number", "boolean", "date", "reference"].includes(baseProperty.type);
+        });
+    }, [properties, forceFilter]);
+
+    const handleFilterChange = useCallback((propertyKey: string, value?: [VirtualTableWhereFilterOp, any]) => {
+        setLocalFilters(prev => {
+            const newFilters = { ...prev };
+            if (value) {
+                newFilters[propertyKey] = value as [WhereFilterOp, any];
+            } else {
+                delete newFilters[propertyKey];
+            }
+            return newFilters;
+        });
+    }, []);
+
+    const handleApply = useCallback(() => {
+        const hasFilters = Object.keys(localFilters).length > 0;
+        setFilterValues(hasFilters ? { ...localFilters, ...forceFilter } : (forceFilter || undefined));
+        onOpenChange(false);
+    }, [localFilters, setFilterValues, forceFilter, onOpenChange]);
+
+    const handleClearAll = useCallback(() => {
+        setLocalFilters({});
+    }, []);
+
+    const setHiddenForField = useCallback((propertyKey: string, hidden: boolean) => {
+        setHiddenFields(prev => ({
+            ...prev,
+            [propertyKey]: hidden
+        }));
+    }, []);
+
+    // Check if any reference field's dialog is currently open (should hide this dialog)
+    const isAnyFieldHidden = Object.values(hiddenFields).some(hidden => hidden);
+    const activeFilterCount = Object.keys(localFilters).length;
+
+    const renderFilterField = useCallback((propertyKey: string, property: Property) => {
+        const isArray = property.type === "array";
+        const ofProp = isArray && "of" in property ? property.of : undefined;
+        const baseProperty: Property | undefined = isArray ? (Array.isArray(ofProp) ? ofProp[0] : ofProp) as Property | undefined : property;
+
+        if (!baseProperty) return null;
+
+        const filterValue = localFilters[propertyKey] as [VirtualTableWhereFilterOp, any] | undefined;
+        const setValue = (value?: [VirtualTableWhereFilterOp, any]) => handleFilterChange(propertyKey, value);
+
+        if (baseProperty.type === "reference") {
+            return (
+                <ReferenceFilterField
+                    value={filterValue}
+                    setValue={setValue}
+                    name={propertyKey}
+                    isArray={isArray}
+                    path={baseProperty.path}
+                    title={property.name}
+                    includeId={baseProperty.includeId}
+                    previewProperties={baseProperty.previewProperties}
+                    hidden={hiddenFields[propertyKey] ?? false}
+                    setHidden={(hidden) => setHiddenForField(propertyKey, hidden)}
+                />
+            );
+        } else if (baseProperty.type === "number" || baseProperty.type === "string") {
+            const enumValues = baseProperty.enum ? enumToObjectEntries(baseProperty.enum) : undefined;
+            return (
+                <StringNumberFilterField
+                    value={filterValue}
+                    setValue={setValue}
+                    name={propertyKey}
+                    type={baseProperty.type}
+                    isArray={isArray}
+                    enumValues={enumValues}
+                    title={property.name}
+                />
+            );
+        } else if (baseProperty.type === "boolean") {
+            return (
+                <BooleanFilterField
+                    value={filterValue}
+                    setValue={setValue}
+                    name={propertyKey}
+                    title={property.name}
+                />
+            );
+        } else if (baseProperty.type === "date") {
+            return (
+                <DateTimeFilterField
+                    value={filterValue}
+                    setValue={setValue}
+                    name={propertyKey}
+                    mode={baseProperty.mode}
+                    isArray={isArray}
+                    title={property.name}
+                />
+            );
+        }
+
+        return null;
+    }, [localFilters, handleFilterChange, hiddenFields, setHiddenForField]);
+
+    return (
+        <Dialog
+            open={open}
+            onOpenChange={onOpenChange}
+            maxWidth="3xl"
+            fullWidth
+            containerClassName={isAnyFieldHidden ? "hidden" : undefined}
+        >
+            <DialogTitle className="flex items-center gap-2" variant="h6">
+                {t("filters")}
+                {activeFilterCount > 0 && (
+                    <span className="ml-2 px-2 py-0.5 text-xs rounded-full bg-primary text-white">
+                        {activeFilterCount}
+                    </span>
+                )}
+            </DialogTitle>
+
+            <DialogContent >
+                {filterableProperties.length === 0 ? (
+                    <Typography color="secondary" className="py-8 text-center">
+                        {t("no_filterable_properties")}
+                    </Typography>
+                ) : (
+                    <table className="w-full border-collapse">
+                        <tbody>
+                            {filterableProperties.map(([propertyKey, property], index) => {
+                                const hasFilter = propertyKey in localFilters;
+
+                                return (
+                                    <tr key={propertyKey} className={cls(
+                                        index > 0 && "border-t",
+                                        defaultBorderMixin
+                                    )}>
+                                        {/* Property name on the left */}
+                                        <td className="py-3 pr-4 align-middle w-[160px]">
+                                            <Typography
+                                                variant="body2"
+                                                className={cls(
+                                                    "font-medium",
+                                                    hasFilter && "text-primary"
+                                                )}
+                                            >
+                                                {property.name || propertyKey}
+                                            </Typography>
+                                        </td>
+
+                                        {/* Filter field on the right */}
+                                        <td className="py-3">
+                                            {renderFilterField(propertyKey, property)}
+                                        </td>
+                                    </tr>
+                                );
+                            })}
+                        </tbody>
+                    </table>
+                )}
+            </DialogContent>
+
+            <DialogActions>
+                <Button
+                    variant="text"
+                    onClick={handleClearAll}
+                    disabled={activeFilterCount === 0}
+                >
+                    {t("clear_all")}
+                </Button>
+                <div className="flex-grow" />
+                <Button
+                    variant="text"
+                    onClick={() => onOpenChange(false)}
+                >
+                    {t("cancel")}
+                </Button>
+                <Button
+                    variant="filled"
+                    onClick={handleApply}
+                >
+                    {t("apply_filters")}
+                </Button>
+            </DialogActions>
+        </Dialog>
+    );
+}