@firecms/collection_editor 3.0.0-alpha.16 → 3.0.0-alpha.18

package/src/utils/join_collections.ts

@@ -0,0 +1,144 @@
+import {
+    EntityCollection,
+    isPropertyBuilder, MapProperty,
+    mergeDeep,
+    PropertiesOrBuilders,
+    Property, PropertyOrBuilder,
+    sortProperties
+} from "@firecms/core";
+import { PersistedCollection } from "../types/persisted_collection";
+
+/**
+ *
+ * @param storedCollections
+ * @param codedCollections
+ */
+export function joinCollectionLists(storedCollections: PersistedCollection[], codedCollections: EntityCollection[] | undefined): EntityCollection[] {
+    const resolvedFetchedCollections: PersistedCollection[] = storedCollections.map(c => ({
+        ...c,
+        editable: true,
+        deletable: true
+    }));
+
+    // merge collections that are in both lists
+    const updatedCollections = (codedCollections ?? [])
+        .map((codedCollection) => {
+            const storedCollection = resolvedFetchedCollections?.find((collection) => {
+                return collection.path === codedCollection.path || (collection.alias && codedCollection.alias && collection.alias === codedCollection.alias);
+            });
+            if (!storedCollection) {
+                return {
+                    ...codedCollection,
+                    properties: markPropertiesAsNonEditable(codedCollection.properties as PropertiesOrBuilders),
+                    deletable: false
+                };
+            } else {
+                Object.values(storedCollection.properties).forEach((property) => {
+                    property.editable = true
+                });
+                const mergedCollection = mergeCollections(storedCollection, codedCollection);
+                return { ...mergedCollection, deletable: false };
+            }
+        });
+
+    // fetched collections that are not in the base collections
+    const resultStoredCollections = resolvedFetchedCollections
+        .filter((col) => !updatedCollections.map(c => c.path).includes(col.path) || !updatedCollections.map(c => c.alias).includes(col.alias));
+
+    console.log("Updated collections", { updatedCollections, resultStoredCollections });
+
+    return [...updatedCollections, ...resultStoredCollections];
+}
+
+function markPropertiesAsNonEditable(properties: PropertiesOrBuilders): PropertiesOrBuilders {
+    return Object.entries(properties).reduce((acc, [key, property]) => {
+        if (!isPropertyBuilder(property) && property.dataType === "map" && property.properties) {
+            const updated = { ...property, properties: markPropertiesAsNonEditable(property.properties as PropertiesOrBuilders) };
+            acc[key] = updated;
+        }
+        if (isPropertyBuilder(property)) {
+            acc[key] = property;
+        } else {
+            acc[key] = { ...property, editable: false };
+        }
+        return acc;
+    }, {} as PropertiesOrBuilders);
+
+}
+
+/**
+ *
+ * @param target
+ * @param source
+ */
+export function mergeCollections(target: EntityCollection, source: EntityCollection): EntityCollection {
+    const subcollectionsMerged = target.subcollections?.map((targetSubcollection) => {
+        const modifiedCollection =
+            source.subcollections?.find((sourceSubcollection) => sourceSubcollection.path === targetSubcollection.path) ??
+            source.subcollections?.find((sourceSubcollection) => sourceSubcollection.alias === targetSubcollection.alias);
+
+        if (!modifiedCollection) {
+            return targetSubcollection;
+        } else {
+            return mergeCollections(targetSubcollection, modifiedCollection);
+        }
+    });
+
+    const propertiesMerged: PropertiesOrBuilders = { ...target.properties } as PropertiesOrBuilders;
+    Object.keys(source.properties).forEach((key) => {
+        const property = target.properties[key] as Property;
+        if (property)
+            propertiesMerged[key] = mergePropertyOrBuilder(property, source.properties[key] as PropertyOrBuilder);
+        else
+            propertiesMerged[key] = source.properties[key] as PropertyOrBuilder;
+    });
+
+    const mergedCollection = mergeDeep(target, source);
+    const targetPropertiesOrder = getCollectionKeys(target);
+    const sourcePropertiesOrder = getCollectionKeys(source);
+    const mergedPropertiesOrder = [...new Set([...targetPropertiesOrder, ...sourcePropertiesOrder])];
+    const mergedEntityViews = [...new Set([...(target.entityViews ?? []), ...(source.entityViews ?? [])])];
+
+    return {
+        ...mergedCollection,
+        subcollections: subcollectionsMerged,
+        properties: sortProperties(propertiesMerged, mergedPropertiesOrder),
+        propertiesOrder: mergedPropertiesOrder,
+        entityViews: mergedEntityViews
+    }
+}
+
+function mergePropertyOrBuilder(target: Property, source: PropertyOrBuilder): PropertyOrBuilder {
+    if (isPropertyBuilder(source)) {
+        return source;
+    } else {
+        const mergedProperty = mergeDeep(target, source);
+        const targetEditable = Boolean(target.editable);
+        const sourceEditable = Boolean(source.editable);
+        if (source.dataType === "map" && source.properties) {
+            const targetProperties = ("properties" in target ? target.properties : {}) as PropertiesOrBuilders;
+            const sourceProperties = ("properties" in source ? source.properties : {}) as PropertiesOrBuilders;
+            const targetPropertiesOrder = "propertiesOrder" in target && target.propertiesOrder ? target.propertiesOrder : Object.keys(targetProperties);
+            const sourcePropertiesOrder = "propertiesOrder" in source && source.propertiesOrder ? source.propertiesOrder : ("properties" in source ? Object.keys(source.properties) : []);
+            const mergedPropertiesOrder = [...new Set([...targetPropertiesOrder, ...sourcePropertiesOrder])];
+            const mergedProperties: PropertiesOrBuilders = { ...targetProperties } as PropertiesOrBuilders;
+            Object.keys(source.properties).forEach((key) => {
+                const property = targetProperties[key] as Property;
+                if (property)
+                    mergedProperties[key] = mergePropertyOrBuilder(property, sourceProperties[key] as PropertyOrBuilder);
+            });
+            return { ...mergedProperty, editable: targetEditable && sourceEditable, properties: mergedProperties, propertiesOrder: mergedPropertiesOrder } as MapProperty;
+        }
+        return { ...mergedProperty, editable: targetEditable && sourceEditable };
+    }
+}
+
+function getCollectionKeys(collection: EntityCollection) {
+    if (collection.propertiesOrder && collection.propertiesOrder.length > 0) {
+        return collection.propertiesOrder;
+    }
+    return [
+        ...Object.keys(collection.properties),
+        ...(collection.additionalFields ?? [])?.map(f => f.id)
+    ];
+}