@firecms/collection_editor 3.0.0-alpha.5 → 3.0.0-alpha.51

package/src/ui/collection_editor/SubcollectionsEditTab.tsx

@@ -0,0 +1,252 @@
+import React from "react";
+import {
+    AddIcon,
+    Button,
+    Container,
+    DeleteConfirmationDialog,
+    DeleteIcon,
+    EntityCollection,
+    EntityCustomView,
+    IconButton,
+    InfoLabel,
+    Paper,
+    resolveEntityView,
+    Table,
+    TableBody,
+    TableCell,
+    TableRow,
+    Tooltip,
+    Typography,
+    useFireCMSContext,
+    User
+} from "@firecms/core";
+import { useFormikContext } from "formik";
+import { CollectionEditorDialog } from "./CollectionEditorDialog";
+import { CollectionsConfigController } from "../../types/config_controller";
+import { PersistedCollection } from "../../types/persisted_collection";
+import { CollectionInference } from "../../types/collection_inference";
+import { EntityCustomViewsSelectDialog } from "./EntityCustomViewsSelectDialog";
+
+export function SubcollectionsEditTab({
+                                          collection,
+                                          parentCollection,
+                                          configController,
+                                          collectionInference,
+                                          getUser,
+                                          parentCollectionIds
+                                      }: {
+    collection: PersistedCollection,
+    parentCollection?: EntityCollection,
+    configController: CollectionsConfigController;
+    collectionInference?: CollectionInference;
+    getUser: (uid: string) => User | null;
+    parentCollectionIds?: string[];
+}) {
+
+    const { entityViews: contextEntityViews } = useFireCMSContext();
+
+    const [subcollectionToDelete, setSubcollectionToDelete] = React.useState<string | undefined>();
+    const [addEntityViewDialogOpen, setAddEntityViewDialogOpen] = React.useState<boolean>(false);
+    const [viewToDelete, setViewToDelete] = React.useState<string | undefined>();
+
+    const [currentDialog, setCurrentDialog] = React.useState<{
+        isNewCollection: boolean,
+        editedCollectionPath?: string,
+    }>();
+
+    const {
+        values,
+        setFieldValue,
+    } = useFormikContext<EntityCollection>();
+
+    const subcollections = collection.subcollections ?? [];
+    const resolvedEntityViews = values.entityViews?.filter(e => typeof e === "string")
+        .map(e => resolveEntityView(e, contextEntityViews))
+        .filter(Boolean) as EntityCustomView[] ?? [];
+    const hardCodedEntityViews = collection.entityViews?.filter(e => typeof e !== "string") as EntityCustomView[] ?? [];
+    const totalEntityViews = resolvedEntityViews.length + hardCodedEntityViews.length;
+
+    return (
+        <div className={"overflow-auto my-auto"}>
+            <Container maxWidth={"2xl"} className={"flex flex-col gap-4 p-8 m-auto"}>
+                <div className={"flex  flex-col gap-16"}>
+
+                    <div className={"flex-grow flex flex-col gap-4 items-start"}>
+                        <Typography variant={"h5"}>
+                            Subcollections of {values.name}
+                        </Typography>
+
+                        {subcollections && subcollections.length > 0 &&
+                            <Paper className={"flex flex-col gap-4 p-2 w-full"}>
+                                <Table>
+                                    <TableBody>
+                                        {subcollections.map((subcollection) => (
+                                            <TableRow key={subcollection.path}
+                                                      onClick={() => setCurrentDialog({
+                                                          isNewCollection: false,
+                                                          editedCollectionPath: subcollection.path,
+                                                      })}>
+                                                <TableCell
+                                                    align="left">
+                                                    <Typography variant={"subtitle2"} className={"flex-grow"}>
+                                                        {subcollection.name}
+                                                    </Typography>
+                                                </TableCell>
+                                                <TableCell
+                                                    align="right">
+                                                    <Tooltip title={"Remove"}>
+                                                        <IconButton size="small"
+                                                                    onClick={(e) => {
+                                                                        e.preventDefault();
+                                                                        e.stopPropagation();
+                                                                        setSubcollectionToDelete(subcollection.path);
+                                                                    }}
+                                                                    color="inherit">
+                                                            <DeleteIcon size={"small"}/>
+                                                        </IconButton>
+                                                    </Tooltip>
+                                                </TableCell>
+                                            </TableRow>
+                                        ))}
+                                    </TableBody>
+                                </Table>
+                            </Paper>}
+
+                        <Button
+                            onClick={() => {
+                                setCurrentDialog({
+                                    isNewCollection: true
+                                });
+                            }}
+                            variant={"outlined"}
+                            startIcon={<AddIcon/>}>
+                            Add subcollection
+                        </Button>
+                    </div>
+
+                    <div className={"flex-grow  flex flex-col gap-4 items-start"}>
+                        <Typography variant={"h5"}>
+                            Custom views
+                        </Typography>
+
+                        {totalEntityViews > 0 && <>
+                            <Paper className={"flex flex-col gap-4 p-2 w-full"}>
+                                <Table>
+                                    <TableBody>
+                                        {resolvedEntityViews.map((view) => (
+                                            <TableRow key={view.key}>
+                                                <TableCell
+                                                    align="left">
+                                                    <Typography variant={"subtitle2"} className={"flex-grow"}>
+                                                        {view.name}
+                                                    </Typography>
+                                                </TableCell>
+                                                <TableCell
+                                                    align="right">
+                                                    <Tooltip title={"Remove"}>
+                                                        <IconButton size="small"
+                                                                    onClick={(e) => {
+                                                                        e.preventDefault();
+                                                                        e.stopPropagation();
+                                                                        setViewToDelete(view.key);
+                                                                    }}
+                                                                    color="inherit">
+                                                            <DeleteIcon size={"small"}/>
+                                                        </IconButton>
+                                                    </Tooltip>
+                                                </TableCell>
+                                            </TableRow>
+                                        ))}
+                                        {hardCodedEntityViews.map((view) => (
+                                            <TableRow key={view.key}>
+                                                <TableCell
+                                                    align="left">
+                                                    <Typography variant={"subtitle2"} className={"flex-grow"}>
+                                                        {view.name}
+                                                    </Typography>
+                                                    <Typography variant={"caption"} className={"flex-grow"}>
+                                                        This view is defined in code with
+                                                        key <code>{view.key}</code>
+                                                    </Typography>
+                                                </TableCell>
+                                            </TableRow>
+                                        ))}
+                                    </TableBody>
+                                </Table>
+                            </Paper>
+
+                        </>}
+
+                        {totalEntityViews === 0 &&
+                            <InfoLabel>
+                                <b>COMING SOON</b> Define your own custom views by uploading it with the CLI
+                            </InfoLabel>
+                        }
+
+                        <Button
+                            onClick={() => {
+                                setAddEntityViewDialogOpen(true);
+                            }}
+                            variant={"outlined"}
+                            startIcon={<AddIcon/>}>
+                            Add custom entity view
+                        </Button>
+
+                    </div>
+
+                </div>
+            </Container>
+
+            <div style={{ height: "52px" }}/>
+
+            {subcollectionToDelete &&
+                <DeleteConfirmationDialog open={Boolean(subcollectionToDelete)}
+                                          onAccept={() => {
+                                              configController.deleteCollection({
+                                                  path: subcollectionToDelete,
+                                                  parentCollectionIds: [...(parentCollectionIds ?? []), collection.path]
+                                              });
+                                              setSubcollectionToDelete(undefined);
+                                          }}
+                                          onCancel={() => setSubcollectionToDelete(undefined)}
+                                          title={<>Delete this subcollection?</>}
+                                          body={<> This will <b>not
+                                              delete any data</b>, only
+                                              the collection in the CMS</>}/>}
+            {viewToDelete &&
+                <DeleteConfirmationDialog open={Boolean(viewToDelete)}
+                                          onAccept={() => {
+                                              setFieldValue("entityViews", values.entityViews?.filter(e => e !== viewToDelete));
+                                              setViewToDelete(undefined);
+                                          }}
+                                          onCancel={() => setViewToDelete(undefined)}
+                                          title={<>Remove this view?</>}
+                                          body={<>This will <b>not
+                                              delete any data</b>, only
+                                              the view in the CMS</>}/>}
+
+            <CollectionEditorDialog
+                open={Boolean(currentDialog)}
+                configController={configController}
+                parentCollection={collection}
+                collectionInference={collectionInference}
+                parentCollectionIds={[...parentCollectionIds ?? [], values.id]}
+                isNewCollection={false}
+                {...currentDialog}
+                getUser={getUser}
+                handleClose={() => {
+                    setCurrentDialog(undefined);
+                }}/>
+
+            <EntityCustomViewsSelectDialog
+                open={addEntityViewDialogOpen}
+                onClose={(selectedViewKey) => {
+                    if (selectedViewKey) {
+                        console.log("selectedViewKey", selectedViewKey);
+                        setFieldValue("entityViews", [...(values.entityViews ?? []), selectedViewKey]);
+                    }
+                    setAddEntityViewDialogOpen(false);
+                }}/>
+        </div>
+    );
+}

package/src/ui/collection_editor/UnsavedChangesDialog.tsx

@@ -0,0 +1,47 @@
+import React from "react";
+import { Button, Dialog, DialogActions, DialogContent, Typography } from "@firecms/core";
+
+export interface UnsavedChangesDialogProps {
+    open: boolean;
+    body?: React.ReactNode;
+    title?: string;
+    handleOk: () => void;
+    handleCancel: () => void;
+}
+
+export function UnsavedChangesDialog({
+                                         open,
+                                         handleOk,
+                                         handleCancel,
+                                         body,
+                                         title
+                                     }: UnsavedChangesDialogProps) {
+
+    return (
+        <Dialog
+            open={open}
+            onOpenChange={(open) => open ? handleCancel() : handleOk()}
+            aria-labelledby="alert-dialog-title"
+            aria-describedby="alert-dialog-description"
+        >
+            <DialogContent>
+                <Typography variant={"h6"}>
+                    {title ?? "Unsaved changes"}
+                </Typography>
+
+                {body && <Typography>
+                    {body}
+                </Typography>}
+                <Typography>
+                    Are you sure?
+                </Typography>
+
+            </DialogContent>
+
+            <DialogActions>
+                <Button variant="text" onClick={handleCancel} autoFocus> Cancel </Button>
+                <Button onClick={handleOk}> Ok </Button>
+            </DialogActions>
+        </Dialog>
+    );
+}

package/src/ui/collection_editor/import/CollectionEditorImportDataPreview.tsx

@@ -0,0 +1,37 @@
+import { convertDataToEntity, getPropertiesMapping, ImportConfig } from "@firecms/data_import_export";
+import { EntityCollectionTable, Properties, Typography, useSelectionController } from "@firecms/core";
+import { useEffect } from "react";
+
+export function CollectionEditorImportDataPreview({ importConfig, properties, propertiesOrder }: {
+    importConfig: ImportConfig,
+    properties: Properties,
+    propertiesOrder: string[]
+}) {
+
+    useEffect(() => {
+        const propertiesMapping = getPropertiesMapping(importConfig.originProperties, properties);
+        const mappedData = importConfig.importData.map(d => convertDataToEntity(d, importConfig.idColumn, importConfig.headersMapping, properties, propertiesMapping, "TEMP_PATH"));
+        importConfig.setEntities(mappedData);
+        console.log("res", { propertiesMapping, mappedData })
+    }, []);
+
+    const selectionController = useSelectionController();
+
+    return <EntityCollectionTable
+        title={<div>
+            <Typography variant={"subtitle2"}>Imported data preview</Typography>
+            <Typography variant={"caption"}>Entities with the same id will be overwritten</Typography>
+        </div>}
+        tableController={{
+            data: importConfig.entities,
+            dataLoading: false,
+            noMoreToLoad: false
+        }}
+        endAdornment={<div className={"h-12"}/>}
+        filterable={false}
+        sortable={false}
+        selectionController={selectionController}
+        displayedColumnIds={propertiesOrder.map(p => ({ key: p, disabled: false }))}
+        properties={properties}/>
+
+}

package/src/ui/collection_editor/import/CollectionEditorImportMapping.tsx

@@ -0,0 +1,275 @@
+import {
+    DataNewPropertiesMapping,
+    getInferenceType,
+    ImportConfig,
+    ImportNewPropertyFieldPreview
+} from "@firecms/data_import_export";
+import { getIn, useFormikContext } from "formik";
+
+import {
+    Container,
+    FieldConfigBadge,
+    getFieldConfig,
+    getFieldId,
+    Properties,
+    Property,
+    PropertyConfig,
+    Select,
+    Tooltip,
+    Typography
+} from "@firecms/core";
+import React, { useState } from "react";
+import { OnPropertyChangedParams, PropertyFormDialog, PropertyWithId } from "../PropertyEditView";
+import { getFullId, idToPropertiesPath, namespaceToPropertiesOrderPath } from "../util";
+import { PersistedCollection } from "../../../types/persisted_collection";
+import { updatePropertyFromWidget } from "../utils/update_property_for_widget";
+import { PropertySelectItem } from "../PropertySelectItem";
+import { supportedFields } from "../utils/supported_fields";
+import { buildPropertyFromData } from "@firecms/schema_inference";
+
+export function CollectionEditorImportMapping({
+                                                  importConfig,
+                                                  propertyConfigs,
+                                                  collectionEditable
+                                              }:
+                                                  {
+                                                      importConfig: ImportConfig,
+                                                      propertyConfigs: Record<string, PropertyConfig>,
+                                                      collectionEditable: boolean
+                                                  }) {
+
+    const {
+        setFieldValue,
+        setFieldTouched,
+        values
+    } = useFormikContext<PersistedCollection>();
+    const [selectedProperty, setSelectedProperty] = useState<PropertyWithId | undefined>(undefined);
+
+    const currentPropertiesOrderRef = React.useRef<{
+        [key: string]: string[]
+    }>(values.propertiesOrder ? { "": values.propertiesOrder } : {});
+
+    const propertyKey = selectedProperty ? selectedProperty.id : undefined;
+    const property = selectedProperty || undefined;
+
+    const onPropertyChanged = ({
+                                   id,
+                                   property,
+                                   previousId,
+                                   namespace
+                               }: OnPropertyChangedParams) => {
+
+        const fullId = id ? getFullId(id, namespace) : undefined;
+        const propertyPath = fullId ? idToPropertiesPath(fullId) : undefined;
+
+        // setSelectedProperty(property);
+        const getCurrentPropertiesOrder = (namespace?: string) => {
+            if (!namespace) return currentPropertiesOrderRef.current[""];
+            return currentPropertiesOrderRef.current[namespace] ?? getIn(values, namespaceToPropertiesOrderPath(namespace));
+        }
+
+        const updatePropertiesOrder = (newPropertiesOrder: string[], namespace?: string) => {
+            const propertiesOrderPath = namespaceToPropertiesOrderPath(namespace);
+
+            setFieldValue(propertiesOrderPath, newPropertiesOrder, false);
+            currentPropertiesOrderRef.current[namespace ?? ""] = newPropertiesOrder;
+
+        };
+
+        // If the id has changed we need to a little cleanup
+        if (previousId && previousId !== id) {
+            const previousFullId = getFullId(previousId, namespace);
+            const previousPropertyPath = idToPropertiesPath(previousFullId);
+
+            const currentPropertiesOrder = getCurrentPropertiesOrder(namespace);
+
+            // replace previousId with id in propertiesOrder
+            const newPropertiesOrder = currentPropertiesOrder
+                .map((p) => p === previousId ? id : p)
+                .filter((p) => p !== undefined) as string[];
+            updatePropertiesOrder(newPropertiesOrder, namespace);
+
+            // replace previousId with id in headersMapping
+            const newHeadersMapping = { ...importConfig.headersMapping };
+            Object.keys(newHeadersMapping).forEach((key) => {
+                if (newHeadersMapping[key] === previousId) {
+                    newHeadersMapping[key] = id ?? "";
+                }
+            });
+            importConfig.setHeadersMapping(newHeadersMapping);
+
+            // if (id) {
+            //     setSelectedPropertyIndex(newPropertiesOrder.indexOf(id));
+            //     setSelectedPropertyKey(id);
+            // }
+            setFieldValue(previousPropertyPath, undefined, false);
+            setFieldTouched(previousPropertyPath, false, false);
+        }
+
+        if (propertyPath) {
+            setFieldValue(propertyPath, property, false);
+            setFieldTouched(propertyPath, true, false);
+        }
+    };
+    const onPropertyTypeChanged = async ({
+                                             id,
+                                             importKey,
+                                             property,
+                                             namespace
+                                         }: OnPropertyChangedParams & {
+        importKey: string
+    }) => {
+
+        const fullId = id ? getFullId(id, namespace) : undefined;
+        const propertyPath = fullId ? idToPropertiesPath(fullId) : undefined;
+
+        // we try to infer the rest of the properties of a property, from the type and the data
+        const propertyData = importConfig.importData.map((d) => getIn(d, importKey));
+        const inferredNewProperty = {
+            ...buildPropertyFromData(propertyData, property, getInferenceType),
+            editable: true
+        };
+
+        if (propertyPath) {
+            if (inferredNewProperty) {
+                console.log("updating inferredNewProperty", {
+                    property,
+                    inferredNewProperty
+                })
+                setFieldValue(propertyPath, inferredNewProperty, false);
+            } else {
+                setFieldValue(propertyPath, property, false);
+            }
+            setFieldTouched(propertyPath, true, false);
+        }
+    };
+
+    return (
+
+        <div className={"overflow-auto my-auto bg-gray-50 dark:bg-gray-900"}>
+            <Container maxWidth={"6xl"} className={"flex flex-col gap-4 p-8 m-auto"}>
+
+                <Typography variant="h6" className={"mt-4"}>Data property mapping</Typography>
+
+                <DataNewPropertiesMapping headersMapping={importConfig.headersMapping}
+                                          idColumn={importConfig.idColumn}
+                                          originProperties={importConfig.originProperties}
+                                          destinationProperties={values.properties as Properties}
+                                          onIdPropertyChanged={(value) => importConfig.setIdColumn(value)}
+                                          buildPropertyView={({
+                                                                  property,
+                                                                  propertyKey,
+                                                                  importKey
+                                                              }) => {
+                                              return <ImportNewPropertyFieldPreview
+                                                  property={property}
+                                                  propertyKey={propertyKey}
+                                                  onPropertyNameChanged={(propertyKey: string, value: string) => setFieldValue(`properties.${propertyKey}.name`, value, false)}
+                                                  onEditClick={() => {
+                                                      if (!propertyKey || !property) return;
+                                                      setSelectedProperty({
+                                                          ...property,
+                                                          id: propertyKey,
+                                                          editable: true
+                                                      });
+                                                  }}
+                                                  propertyTypeView={<PropertySelect property={property}
+                                                                                    disabled={false}
+                                                                                    onPropertyChanged={(props) => onPropertyTypeChanged({
+                                                                                        ...props,
+                                                                                        importKey
+                                                                                    })}
+                                                                                    propertyKey={propertyKey}
+                                                                                    propertyConfigs={propertyConfigs}/>}
+                                              />;
+                                          }}/>
+            </Container>
+
+            <PropertyFormDialog
+                open={selectedProperty !== undefined}
+                propertyKey={propertyKey}
+                property={property}
+                inArray={false}
+                autoUpdateId={false}
+                onPropertyChanged={onPropertyChanged}
+                allowDataInference={false}
+                collectionEditable={collectionEditable}
+                onOkClicked={() => {
+                    setSelectedProperty(undefined);
+                }}
+                onCancel={() => {
+                    setSelectedProperty(undefined);
+                }}
+                autoOpenTypeSelect={false}
+                existingProperty={false}
+                propertyConfigs={propertyConfigs}/>
+
+            <div style={{ height: "52px" }}/>
+        </div>
+    );
+
+}
+
+function PropertySelect({
+                            property,
+                            onPropertyChanged,
+                            propertyKey,
+                            propertyConfigs,
+                            disabled
+                        }: {
+    property: Property | null,
+    propertyKey: string | null,
+    onPropertyChanged: ({
+                            id,
+                            property,
+                            previousId,
+                            namespace
+                        }: OnPropertyChangedParams) => void,
+    propertyConfigs: Record<string, PropertyConfig>,
+    disabled?: boolean
+}) {
+
+    const fieldId = property ? getFieldId(property) : null;
+    const widget = property ? getFieldConfig(property, propertyConfigs) : null;
+
+    const [selectOpen, setSelectOpen] = useState(false);
+
+    return <Tooltip title={property && widget ? `${widget?.name} - ${property.dataType}` : undefined}
+                    open={selectOpen ? false : undefined}>
+        <Select
+            open={selectOpen}
+            onOpenChange={setSelectOpen}
+            invisible={true}
+            className={"w-full"}
+            disabled={disabled}
+            error={!widget}
+            value={fieldId ?? ""}
+            placeholder={"Select a property widget"}
+            position={"item-aligned"}
+            renderValue={(value) => {
+                if (!widget) return null;
+                return <FieldConfigBadge propertyConfig={widget}/>
+            }}
+            onValueChange={(newSelectedWidgetId) => {
+                const newProperty = updatePropertyFromWidget(property, newSelectedWidgetId, propertyConfigs)
+                if (!propertyKey) return;
+                onPropertyChanged({
+                    id: propertyKey,
+                    property: newProperty,
+                    previousId: propertyKey,
+                    namespace: undefined
+                });
+                console.log("newSelectedWidgetId", newSelectedWidgetId);
+            }}>
+            {Object.entries(supportedFields).map(([key, widget]) => {
+                return <PropertySelectItem
+                    key={key}
+                    value={key}
+                    optionDisabled={false}
+                    propertyConfig={widget}
+                    existing={false}/>;
+            })
+            }
+        </Select>
+    </Tooltip>;
+}

package/src/ui/collection_editor/import/clean_import_data.ts

@@ -0,0 +1,53 @@
+import { Properties, slugify } from "@firecms/core";
+import { ImportConfig } from "@firecms/data_import_export";
+
+export function cleanPropertiesFromImport(properties: Properties, parentSlug = ""): {
+    headersMapping: ImportConfig["headersMapping"],
+    properties: Properties,
+    idColumn?: ImportConfig["idColumn"],
+} {
+
+    const result = Object.keys(properties).reduce((acc, key) => {
+        const property = properties[key];
+        const slug = slugify(key);
+        const fullSlug = parentSlug ? `${parentSlug}.${slug}` : slug;
+
+        if (property.dataType === "map" && property.properties) {
+            const slugifiedResult = cleanPropertiesFromImport(property.properties as Properties, fullSlug);
+            return {
+                headersMapping: { ...acc.headersMapping, [key]: fullSlug },
+                properties: {
+                    ...acc.properties,
+                    [slug]: {
+                        ...property,
+                        properties: slugifiedResult.properties,
+                        propertiesOrder: Object.keys(slugifiedResult.properties)
+                    }
+                }
+            }
+        }
+
+        const updatedProperties = {
+            ...acc.properties,
+            [slug]: property
+        } as Properties;
+
+        const headersMapping = { ...acc.headersMapping, [key]: fullSlug } as Record<string, string>;
+
+        return {
+            headersMapping,
+            properties: updatedProperties,
+        }
+    }, { headersMapping: {}, properties: {} });
+
+    const firstKey = Object.keys(result.headersMapping)?.[0];
+    let idColumn: string | undefined;
+    if (firstKey?.includes("id") || firstKey?.includes("key")) {
+        idColumn = firstKey;
+    }
+
+    return {
+        ...result,
+        idColumn
+    };
+}